@autobe/agent 0.20.0 → 0.22.0

package/lib/agent/src/orchestrate/interface/utils/JsonSchemaFactory.js

@@ -0,0 +1,1385 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSchemaFactory = void 0;
+const __typia_transform__accessExpressionAsString = __importStar(require("typia/lib/internal/_accessExpressionAsString.js"));
+const __typia_transform__assertGuard = __importStar(require("typia/lib/internal/_assertGuard.js"));
+const utils_1 = require("@autobe/utils");
+const typia_1 = __importDefault(require("typia"));
+var JsonSchemaFactory;
+(function (JsonSchemaFactory) {
+    JsonSchemaFactory.presets = (typeNames) => {
+        const schemas = {};
+        for (const [key, value] of Object.entries(DEFAULT_SCHEMAS)) {
+            schemas[key] = value;
+            typeNames.delete(key);
+        }
+        for (const key of typeNames)
+            if (JsonSchemaFactory.isPage(key)) {
+                const data = JsonSchemaFactory.getPageName(key);
+                schemas[key] = JsonSchemaFactory.page(data);
+                typeNames.delete(key);
+                typeNames.add(data);
+            }
+        return schemas;
+    };
+    JsonSchemaFactory.authorize = (schemas) => {
+        for (const [key, value] of Object.entries(schemas)) {
+            if (key.endsWith(".IAuthorized") === false)
+                continue;
+            else if (utils_1.AutoBeOpenApiTypeChecker.isObject(value) === false)
+                continue;
+            const parent = schemas[key.substring(0, key.length - ".IAuthorized".length)];
+            if (parent === undefined)
+                continue;
+            else if (utils_1.AutoBeOpenApiTypeChecker.isObject(parent) === false)
+                continue;
+            value.properties = Object.assign(Object.assign({}, parent.properties), value.properties);
+            value.required = [...parent.required];
+            if (value.required.includes("id") === false)
+                value.required.push("id");
+            if (value.required.includes("token") === false)
+                value.required.push("token");
+        }
+    };
+    JsonSchemaFactory.page = (key) => ({
+        type: "object",
+        properties: {
+            pagination: {
+                $ref: "#/components/schemas/IPage.IPagination",
+                description: "Page information.",
+            },
+            data: {
+                type: "array",
+                items: {
+                    $ref: `#/components/schemas/${key}`,
+                },
+                description: "List of records.",
+            },
+        },
+        required: ["pagination", "data"],
+        description: utils_1.StringUtil.trim `
+      A page.
+  
+      Collection of records with pagination information.
+    `,
+    });
+    JsonSchemaFactory.fix = (path, input) => {
+        if (isRecord(input) === false || isRecord(input[path]) === false)
+            return;
+        if (input[path].description)
+            delete input[path].description;
+        if (input[path].required)
+            delete input[path].required;
+        for (const key of Object.keys(input[path]))
+            if (DEFAULT_SCHEMAS[key] !== undefined)
+                input[path][key] = DEFAULT_SCHEMAS[key];
+            else if (JsonSchemaFactory.isPage(key) === true) {
+                const data = key.substring("IPage".length);
+                input[path][key] = JsonSchemaFactory.page(data);
+            }
+    };
+    JsonSchemaFactory.isPage = (key) => key.startsWith("IPage") === true &&
+        key.startsWith("IPage.") === false &&
+        key !== "IPage";
+    JsonSchemaFactory.getPageName = (key) => key.substring("IPage".length);
+    const isRecord = (input) => typeof input === "object" && input !== null;
+})(JsonSchemaFactory || (exports.JsonSchemaFactory = JsonSchemaFactory = {}));
+const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "object" === typeof value && null !== value && _iu1(value, true && _exceptionable);
+}); const _io1 = (input, _exceptionable = true) => ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["const", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io2 = (input, _exceptionable = true) => "boolean" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io3 = (input, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io4 = (input, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io5 = (input, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["format", "pattern", "contentMediaType", "minLength", "maxLength", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io6 = (input, _exceptionable = true) => "object" === typeof input.items && null !== input.items && _iu2(input.items, true && _exceptionable) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && "array" === input.type && "string" === typeof input.description && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["items", "uniqueItems", "minItems", "maxItems", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io7 = (input, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io8 = (input, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io9 = (input, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["format", "pattern", "contentMediaType", "minLength", "maxLength", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io10 = (input, _exceptionable = true) => ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["const"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io11 = (input, _exceptionable = true) => "boolean" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io12 = (input, _exceptionable = true) => "object" === typeof input.items && null !== input.items && _iu2(input.items, true && _exceptionable) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && "array" === input.type && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["items", "uniqueItems", "minItems", "maxItems", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io13 = (input, _exceptionable = true) => "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io0(input.properties, true && _exceptionable) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu2(input.additionalProperties, true && _exceptionable))) && (Array.isArray(input.required) && input.required.every((elem, _index1) => "string" === typeof elem)) && "object" === input.type && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["properties", "additionalProperties", "required", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io14 = (input, _exceptionable = true) => "string" === typeof input.$ref && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["$ref"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io15 = (input, _exceptionable = true) => Array.isArray(input.oneOf) && input.oneOf.every((elem, _index2) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["oneOf", "discriminator"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io16 = (input, _exceptionable = true) => "null" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io17 = (input, _exceptionable = true) => "string" === typeof input.propertyName && (undefined === input.mapping || "object" === typeof input.mapping && null !== input.mapping && false === Array.isArray(input.mapping) && _io18(input.mapping, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["propertyName", "mapping"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io18 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "string" === typeof value;
+}); const _io19 = (input, _exceptionable = true) => "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io0(input.properties, true && _exceptionable) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu2(input.additionalProperties, true && _exceptionable))) && (Array.isArray(input.required) && input.required.every((elem, _index3) => "string" === typeof elem)) && "object" === input.type && "string" === typeof input.description && (4 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["properties", "additionalProperties", "required", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io20 = (input, _exceptionable = true) => "string" === typeof input.$ref && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["$ref", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io21 = (input, _exceptionable = true) => Array.isArray(input.oneOf) && input.oneOf.every((elem, _index4) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator, true && _exceptionable)) && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["oneOf", "discriminator", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io22 = (input, _exceptionable = true) => "null" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if ("number" === input.type)
+        return _io8(input, true && _exceptionable);
+    else if ("integer" === input.type)
+        return _io7(input, true && _exceptionable);
+    else if ("string" === input.type)
+        return _io9(input, true && _exceptionable);
+    else if (undefined !== input["const"])
+        return _io10(input, true && _exceptionable);
+    else if ("null" === input.type)
+        return _io16(input, true && _exceptionable);
+    else if ("boolean" === input.type)
+        return _io11(input, true && _exceptionable);
+    else if ("array" === input.type)
+        return _io12(input, true && _exceptionable);
+    else if ("object" === input.type)
+        return _io13(input, true && _exceptionable);
+    else if (undefined !== input.$ref)
+        return _io14(input, true && _exceptionable);
+    else
+        return false;
+})(); const _iu1 = (input, _exceptionable = true) => (() => {
+    if (undefined !== input["const"])
+        return _io1(input, true && _exceptionable);
+    else if ("boolean" === input.type)
+        return _io2(input, true && _exceptionable);
+    else if ("number" === input.type)
+        return _io4(input, true && _exceptionable);
+    else if ("integer" === input.type)
+        return _io3(input, true && _exceptionable);
+    else if ("string" === input.type)
+        return _io5(input, true && _exceptionable);
+    else if ("array" === input.type)
+        return _io6(input, true && _exceptionable);
+    else if ("object" === input.type)
+        return _io19(input, true && _exceptionable);
+    else if (undefined !== input.$ref)
+        return _io20(input, true && _exceptionable);
+    else if (undefined !== input.oneOf)
+        return _io21(input, true && _exceptionable);
+    else if ("null" === input.type)
+        return _io22(input, true && _exceptionable);
+    else
+        return false;
+})(); const _iu2 = (input, _exceptionable = true) => (() => {
+    if ("number" === input.type)
+        return _io8(input, true && _exceptionable);
+    else if ("integer" === input.type)
+        return _io7(input, true && _exceptionable);
+    else if ("string" === input.type)
+        return _io9(input, true && _exceptionable);
+    else if (undefined !== input["const"])
+        return _io10(input, true && _exceptionable);
+    else if ("null" === input.type)
+        return _io16(input, true && _exceptionable);
+    else if ("boolean" === input.type)
+        return _io11(input, true && _exceptionable);
+    else if ("array" === input.type)
+        return _io12(input, true && _exceptionable);
+    else if ("object" === input.type)
+        return _io13(input, true && _exceptionable);
+    else if (undefined !== input.$ref)
+        return _io14(input, true && _exceptionable);
+    else if (undefined !== input.oneOf)
+        return _io15(input, true && _exceptionable);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return ("object" === typeof value && null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(AutoBeOpenApi.IJsonSchemaDescriptive.IArray | AutoBeOpenApi.IJsonSchemaDescriptive.IBoolean | AutoBeOpenApi.IJsonSchemaDescriptive.IConstant | AutoBeOpenApi.IJsonSchemaDescriptive.IInteger | AutoBeOpenApi.IJsonSchemaDescriptive.INull | AutoBeOpenApi.IJsonSchemaDescriptive.INumber | AutoBeOpenApi.IJsonSchemaDescriptive.IObject | AutoBeOpenApi.IJsonSchemaDescriptive.IOneOf | AutoBeOpenApi.IJsonSchemaDescriptive.IReference | AutoBeOpenApi.IJsonSchemaDescriptive.IString)",
+        value: value
+    }, _errorFactory)) && _au1(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(AutoBeOpenApi.IJsonSchemaDescriptive.IArray | AutoBeOpenApi.IJsonSchemaDescriptive.IBoolean | AutoBeOpenApi.IJsonSchemaDescriptive.IConstant | AutoBeOpenApi.IJsonSchemaDescriptive.IInteger | AutoBeOpenApi.IJsonSchemaDescriptive.INull | AutoBeOpenApi.IJsonSchemaDescriptive.INumber | AutoBeOpenApi.IJsonSchemaDescriptive.IObject | AutoBeOpenApi.IJsonSchemaDescriptive.IOneOf | AutoBeOpenApi.IJsonSchemaDescriptive.IReference | AutoBeOpenApi.IJsonSchemaDescriptive.IString)",
+        value: value
+    }, _errorFactory);
+}); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + "[\"const\"]",
+    expected: "(boolean | number | string)",
+    value: input["const"]
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["const", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao2 = (input, _path, _exceptionable = true) => ("boolean" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"boolean\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao3 = (input, _path, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minimum",
+    expected: "number & Type<\"int64\">",
+    value: input.minimum
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minimum",
+    expected: "((number & Type<\"int64\">) | undefined)",
+    value: input.minimum
+}, _errorFactory)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maximum",
+    expected: "number & Type<\"int64\">",
+    value: input.maximum
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maximum",
+    expected: "((number & Type<\"int64\">) | undefined)",
+    value: input.maximum
+}, _errorFactory)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMinimum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMinimum
+}, _errorFactory)) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMaximum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMaximum
+}, _errorFactory)) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "number & Type<\"uint64\">",
+    value: input.multipleOf
+}, _errorFactory)) && (0 < input.multipleOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "number & ExclusiveMinimum<0>",
+    value: input.multipleOf
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "((number & Type<\"uint64\"> & ExclusiveMinimum<0>) | undefined)",
+    value: input.multipleOf
+}, _errorFactory)) && ("integer" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"integer\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao4 = (input, _path, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minimum",
+    expected: "(number | undefined)",
+    value: input.minimum
+}, _errorFactory)) && (undefined === input.maximum || "number" === typeof input.maximum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maximum",
+    expected: "(number | undefined)",
+    value: input.maximum
+}, _errorFactory)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMinimum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMinimum
+}, _errorFactory)) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMaximum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMaximum
+}, _errorFactory)) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (0 < input.multipleOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "number & ExclusiveMinimum<0>",
+    value: input.multipleOf
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "((number & ExclusiveMinimum<0>) | undefined)",
+    value: input.multipleOf
+}, _errorFactory)) && ("number" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"number\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".format",
+    expected: "(string | undefined)",
+    value: input.format
+}, _errorFactory)) && (undefined === input.pattern || "string" === typeof input.pattern || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".pattern",
+    expected: "(string | undefined)",
+    value: input.pattern
+}, _errorFactory)) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".contentMediaType",
+    expected: "(string | undefined)",
+    value: input.contentMediaType
+}, _errorFactory)) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minLength",
+    expected: "number & Type<\"uint64\">",
+    value: input.minLength
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minLength",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.minLength
+}, _errorFactory)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxLength",
+    expected: "number & Type<\"uint64\">",
+    value: input.maxLength
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxLength",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.maxLength
+}, _errorFactory)) && ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"string\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["format", "pattern", "contentMediaType", "minLength", "maxLength", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao6 = (input, _path, _exceptionable = true) => (("object" === typeof input.items && null !== input.items || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".items",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: input.items
+}, _errorFactory)) && _au2(input.items, _path + ".items", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".items",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: input.items
+}, _errorFactory)) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".uniqueItems",
+    expected: "(boolean | undefined)",
+    value: input.uniqueItems
+}, _errorFactory)) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minItems",
+    expected: "number & Type<\"uint64\">",
+    value: input.minItems
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minItems",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.minItems
+}, _errorFactory)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxItems",
+    expected: "number & Type<\"uint64\">",
+    value: input.maxItems
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxItems",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.maxItems
+}, _errorFactory)) && ("array" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"array\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["items", "uniqueItems", "minItems", "maxItems", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao7 = (input, _path, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minimum",
+    expected: "number & Type<\"int64\">",
+    value: input.minimum
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minimum",
+    expected: "((number & Type<\"int64\">) | undefined)",
+    value: input.minimum
+}, _errorFactory)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maximum",
+    expected: "number & Type<\"int64\">",
+    value: input.maximum
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maximum",
+    expected: "((number & Type<\"int64\">) | undefined)",
+    value: input.maximum
+}, _errorFactory)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMinimum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMinimum
+}, _errorFactory)) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMaximum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMaximum
+}, _errorFactory)) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "number & Type<\"uint64\">",
+    value: input.multipleOf
+}, _errorFactory)) && (0 < input.multipleOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "number & ExclusiveMinimum<0>",
+    value: input.multipleOf
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "((number & Type<\"uint64\"> & ExclusiveMinimum<0>) | undefined)",
+    value: input.multipleOf
+}, _errorFactory)) && ("integer" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"integer\"",
+    value: input.type
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao8 = (input, _path, _exceptionable = true) => (undefined === input.minimum || "number" === typeof input.minimum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minimum",
+    expected: "(number | undefined)",
+    value: input.minimum
+}, _errorFactory)) && (undefined === input.maximum || "number" === typeof input.maximum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maximum",
+    expected: "(number | undefined)",
+    value: input.maximum
+}, _errorFactory)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMinimum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMinimum
+}, _errorFactory)) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".exclusiveMaximum",
+    expected: "(number | undefined)",
+    value: input.exclusiveMaximum
+}, _errorFactory)) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (0 < input.multipleOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "number & ExclusiveMinimum<0>",
+    value: input.multipleOf
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".multipleOf",
+    expected: "((number & ExclusiveMinimum<0>) | undefined)",
+    value: input.multipleOf
+}, _errorFactory)) && ("number" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"number\"",
+    value: input.type
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao9 = (input, _path, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".format",
+    expected: "(string | undefined)",
+    value: input.format
+}, _errorFactory)) && (undefined === input.pattern || "string" === typeof input.pattern || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".pattern",
+    expected: "(string | undefined)",
+    value: input.pattern
+}, _errorFactory)) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".contentMediaType",
+    expected: "(string | undefined)",
+    value: input.contentMediaType
+}, _errorFactory)) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minLength",
+    expected: "number & Type<\"uint64\">",
+    value: input.minLength
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minLength",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.minLength
+}, _errorFactory)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxLength",
+    expected: "number & Type<\"uint64\">",
+    value: input.maxLength
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxLength",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.maxLength
+}, _errorFactory)) && ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"string\"",
+    value: input.type
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["format", "pattern", "contentMediaType", "minLength", "maxLength", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao10 = (input, _path, _exceptionable = true) => ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + "[\"const\"]",
+    expected: "(boolean | number | string)",
+    value: input["const"]
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["const"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao11 = (input, _path, _exceptionable = true) => ("boolean" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"boolean\"",
+    value: input.type
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao12 = (input, _path, _exceptionable = true) => (("object" === typeof input.items && null !== input.items || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".items",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: input.items
+}, _errorFactory)) && _au2(input.items, _path + ".items", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".items",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: input.items
+}, _errorFactory)) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".uniqueItems",
+    expected: "(boolean | undefined)",
+    value: input.uniqueItems
+}, _errorFactory)) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minItems",
+    expected: "number & Type<\"uint64\">",
+    value: input.minItems
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".minItems",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.minItems
+}, _errorFactory)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxItems",
+    expected: "number & Type<\"uint64\">",
+    value: input.maxItems
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".maxItems",
+    expected: "((number & Type<\"uint64\">) | undefined)",
+    value: input.maxItems
+}, _errorFactory)) && ("array" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"array\"",
+    value: input.type
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["items", "uniqueItems", "minItems", "maxItems", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao13 = (input, _path, _exceptionable = true) => (("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".properties",
+    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>",
+    value: input.properties
+}, _errorFactory)) && _ao0(input.properties, _path + ".properties", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".properties",
+    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>",
+    value: input.properties
+}, _errorFactory)) && ((null !== input.additionalProperties || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".additionalProperties",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString | false | undefined)",
+    value: input.additionalProperties
+}, _errorFactory)) && (undefined === input.additionalProperties || false === input.additionalProperties || ("object" === typeof input.additionalProperties && null !== input.additionalProperties || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".additionalProperties",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString | false | undefined)",
+    value: input.additionalProperties
+}, _errorFactory)) && _au2(input.additionalProperties, _path + ".additionalProperties", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".additionalProperties",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString | false | undefined)",
+    value: input.additionalProperties
+}, _errorFactory))) && ((Array.isArray(input.required) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".required",
+    expected: "Array<string>",
+    value: input.required
+}, _errorFactory)) && input.required.every((elem, _index5) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".required[" + _index5 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".required",
+    expected: "Array<string>",
+    value: input.required
+}, _errorFactory)) && ("object" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"object\"",
+    value: input.type
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["properties", "additionalProperties", "required", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao14 = (input, _path, _exceptionable = true) => ("string" === typeof input.$ref || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".$ref",
+    expected: "string",
+    value: input.$ref
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["$ref"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao15 = (input, _path, _exceptionable = true) => ((Array.isArray(input.oneOf) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf",
+    expected: "Array<IInteger | INumber | IString | IConstant | IBoolean | IArray | IObject | IReference | INull>",
+    value: input.oneOf
+}, _errorFactory)) && input.oneOf.every((elem, _index6) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf[" + _index6 + "]",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: elem
+}, _errorFactory)) && _au0(elem, _path + ".oneOf[" + _index6 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf[" + _index6 + "]",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf",
+    expected: "Array<IInteger | INumber | IString | IConstant | IBoolean | IArray | IObject | IReference | INull>",
+    value: input.oneOf
+}, _errorFactory)) && (undefined === input.discriminator || ("object" === typeof input.discriminator && null !== input.discriminator || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".discriminator",
+    expected: "(AutoBeOpenApi.IJsonSchema.IOneOf.IDiscriminator | undefined)",
+    value: input.discriminator
+}, _errorFactory)) && _ao17(input.discriminator, _path + ".discriminator", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".discriminator",
+    expected: "(AutoBeOpenApi.IJsonSchema.IOneOf.IDiscriminator | undefined)",
+    value: input.discriminator
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["oneOf", "discriminator"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao16 = (input, _path, _exceptionable = true) => ("null" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"null\"",
+    value: input.type
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao17 = (input, _path, _exceptionable = true) => ("string" === typeof input.propertyName || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".propertyName",
+    expected: "string",
+    value: input.propertyName
+}, _errorFactory)) && (undefined === input.mapping || ("object" === typeof input.mapping && null !== input.mapping && false === Array.isArray(input.mapping) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".mapping",
+    expected: "(Record<string, string> | undefined)",
+    value: input.mapping
+}, _errorFactory)) && _ao18(input.mapping, _path + ".mapping", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".mapping",
+    expected: "(Record<string, string> | undefined)",
+    value: input.mapping
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["propertyName", "mapping"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao18 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "string" === typeof value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "string",
+        value: value
+    }, _errorFactory);
+}); const _ao19 = (input, _path, _exceptionable = true) => (("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".properties",
+    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>",
+    value: input.properties
+}, _errorFactory)) && _ao0(input.properties, _path + ".properties", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".properties",
+    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>",
+    value: input.properties
+}, _errorFactory)) && ((null !== input.additionalProperties || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".additionalProperties",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString | false | undefined)",
+    value: input.additionalProperties
+}, _errorFactory)) && (undefined === input.additionalProperties || false === input.additionalProperties || ("object" === typeof input.additionalProperties && null !== input.additionalProperties || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".additionalProperties",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString | false | undefined)",
+    value: input.additionalProperties
+}, _errorFactory)) && _au2(input.additionalProperties, _path + ".additionalProperties", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".additionalProperties",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IOneOf | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString | false | undefined)",
+    value: input.additionalProperties
+}, _errorFactory))) && ((Array.isArray(input.required) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".required",
+    expected: "Array<string>",
+    value: input.required
+}, _errorFactory)) && input.required.every((elem, _index7) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".required[" + _index7 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".required",
+    expected: "Array<string>",
+    value: input.required
+}, _errorFactory)) && ("object" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"object\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["properties", "additionalProperties", "required", "type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao20 = (input, _path, _exceptionable = true) => ("string" === typeof input.$ref || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".$ref",
+    expected: "string",
+    value: input.$ref
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["$ref", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao21 = (input, _path, _exceptionable = true) => ((Array.isArray(input.oneOf) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf",
+    expected: "Array<IInteger | INumber | IString | IConstant | IBoolean | IArray | IObject | IReference | INull>",
+    value: input.oneOf
+}, _errorFactory)) && input.oneOf.every((elem, _index8) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf[" + _index8 + "]",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: elem
+}, _errorFactory)) && _au0(elem, _path + ".oneOf[" + _index8 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf[" + _index8 + "]",
+    expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".oneOf",
+    expected: "Array<IInteger | INumber | IString | IConstant | IBoolean | IArray | IObject | IReference | INull>",
+    value: input.oneOf
+}, _errorFactory)) && (undefined === input.discriminator || ("object" === typeof input.discriminator && null !== input.discriminator || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".discriminator",
+    expected: "(AutoBeOpenApi.IJsonSchema.IOneOf.IDiscriminator | undefined)",
+    value: input.discriminator
+}, _errorFactory)) && _ao17(input.discriminator, _path + ".discriminator", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".discriminator",
+    expected: "(AutoBeOpenApi.IJsonSchema.IOneOf.IDiscriminator | undefined)",
+    value: input.discriminator
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["oneOf", "discriminator", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao22 = (input, _path, _exceptionable = true) => ("null" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".type",
+    expected: "\"null\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.description || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.assertEquals",
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "description"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("number" === input.type)
+        return _ao8(input, _path, true && _exceptionable);
+    else if ("integer" === input.type)
+        return _ao7(input, _path, true && _exceptionable);
+    else if ("string" === input.type)
+        return _ao9(input, _path, true && _exceptionable);
+    else if (undefined !== input["const"])
+        return _ao10(input, _path, true && _exceptionable);
+    else if ("null" === input.type)
+        return _ao16(input, _path, true && _exceptionable);
+    else if ("boolean" === input.type)
+        return _ao11(input, _path, true && _exceptionable);
+    else if ("array" === input.type)
+        return _ao12(input, _path, true && _exceptionable);
+    else if ("object" === input.type)
+        return _ao13(input, _path, true && _exceptionable);
+    else if (undefined !== input.$ref)
+        return _ao14(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "typia.assertEquals",
+            path: _path,
+            expected: "(AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.IString | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference)",
+            value: input
+        }, _errorFactory);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input["const"])
+        return _ao1(input, _path, true && _exceptionable);
+    else if ("boolean" === input.type)
+        return _ao2(input, _path, true && _exceptionable);
+    else if ("number" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else if ("integer" === input.type)
+        return _ao3(input, _path, true && _exceptionable);
+    else if ("string" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else if ("array" === input.type)
+        return _ao6(input, _path, true && _exceptionable);
+    else if ("object" === input.type)
+        return _ao19(input, _path, true && _exceptionable);
+    else if (undefined !== input.$ref)
+        return _ao20(input, _path, true && _exceptionable);
+    else if (undefined !== input.oneOf)
+        return _ao21(input, _path, true && _exceptionable);
+    else if ("null" === input.type)
+        return _ao22(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "typia.assertEquals",
+            path: _path,
+            expected: "(AutoBeOpenApi.IJsonSchemaDescriptive.IConstant | AutoBeOpenApi.IJsonSchemaDescriptive.IBoolean | AutoBeOpenApi.IJsonSchemaDescriptive.INumber | AutoBeOpenApi.IJsonSchemaDescriptive.IInteger | AutoBeOpenApi.IJsonSchemaDescriptive.IString | AutoBeOpenApi.IJsonSchemaDescriptive.IArray | AutoBeOpenApi.IJsonSchemaDescriptive.IObject | AutoBeOpenApi.IJsonSchemaDescriptive.IReference | AutoBeOpenApi.IJsonSchemaDescriptive.IOneOf | AutoBeOpenApi.IJsonSchemaDescriptive.INull)",
+            value: input
+        }, _errorFactory);
+})(); const _au2 = (input, _path, _exceptionable = true) => (() => {
+    if ("number" === input.type)
+        return _ao8(input, _path, true && _exceptionable);
+    else if ("integer" === input.type)
+        return _ao7(input, _path, true && _exceptionable);
+    else if ("string" === input.type)
+        return _ao9(input, _path, true && _exceptionable);
+    else if (undefined !== input["const"])
+        return _ao10(input, _path, true && _exceptionable);
+    else if ("null" === input.type)
+        return _ao16(input, _path, true && _exceptionable);
+    else if ("boolean" === input.type)
+        return _ao11(input, _path, true && _exceptionable);
+    else if ("array" === input.type)
+        return _ao12(input, _path, true && _exceptionable);
+    else if ("object" === input.type)
+        return _ao13(input, _path, true && _exceptionable);
+    else if (undefined !== input.$ref)
+        return _ao14(input, _path, true && _exceptionable);
+    else if (undefined !== input.oneOf)
+        return _ao15(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "typia.assertEquals",
+            path: _path,
+            expected: "(AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.IString | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IOneOf)",
+            value: input
+        }, _errorFactory);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input, true); 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: "typia.assertEquals",
+            path: _path + "",
+            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "typia.assertEquals",
+            path: _path + "",
+            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })()((_a = {
+    version: "3.1",
+    components: {
+        schemas: {
+            "IPage.IPagination": {
+                type: "object",
+                properties: {
+                    current: {
+                        type: "integer",
+                        minimum: 0,
+                        description: "Current page number."
+                    },
+                    limit: {
+                        type: "integer",
+                        minimum: 0,
+                        description: "Limitation of records per a page."
+                    },
+                    records: {
+                        type: "integer",
+                        minimum: 0,
+                        description: "Total records in the database."
+                    },
+                    pages: {
+                        type: "integer",
+                        minimum: 0,
+                        description: "Total pages.\n\nEqual to {@link records} / {@link limit} with ceiling."
+                    }
+                },
+                required: [
+                    "current",
+                    "limit",
+                    "records",
+                    "pages"
+                ],
+                description: "Page information."
+            },
+            IAuthorizationToken: {
+                type: "object",
+                properties: {
+                    access: {
+                        type: "string",
+                        description: "JWT access token for authenticated requests.\n\nThis token should be included in the Authorization header for subsequent\nauthenticated API requests as `Bearer {token}`."
+                    },
+                    refresh: {
+                        type: "string",
+                        description: "Refresh token for obtaining new access tokens.\n\nThis token can be used to request new access tokens when the current access\ntoken expires, extending the user's session."
+                    },
+                    expired_at: {
+                        type: "string",
+                        format: "date-time",
+                        description: "Access token expiration timestamp.\n\nISO 8601 date-time string indicating when the access token will expire and\ncan no longer be used for authentication."
+                    },
+                    refreshable_until: {
+                        type: "string",
+                        format: "date-time",
+                        description: "Refresh token expiration timestamp.\n\nISO 8601 date-time string indicating the latest time until which the\nrefresh token can be used to obtain new access tokens."
+                    }
+                },
+                required: [
+                    "access",
+                    "refresh",
+                    "expired_at",
+                    "refreshable_until"
+                ],
+                description: "Authorization token response structure.\n\nThis interface defines the structure of the authorization token response\nreturned after successful user authentication. It contains both access and\nrefresh tokens along with their expiration information.\n\nThis token structure is automatically included in API schemas when the system\ndetects authorization roles in the requirements analysis phase. It provides a\nstandard format for JWT-based authentication across the generated backend\napplications."
+            }
+        }
+    },
+    schemas: [
+        {
+            $ref: "#/components/schemas/IPage.IPagination"
+        },
+        {
+            $ref: "#/components/schemas/IAuthorizationToken"
+        }
+    ]
+}.components) === null || _a === void 0 ? void 0 : _a.schemas);
+//# sourceMappingURL=JsonSchemaFactory.js.map