"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