{"version":3,"sources":["../node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs","../src/shared/zod.ts"],"names":["__rest","s","e","t","p","i","isZodType","schema","typeName","_a","preserveMetadataFromModifier","zod","modifier","zodModifier","args","result","extendZodWithOpenApi","refOrOpenapi","metadata","_b","_c","_d","_e","_f","openapi","_g","param","restOfOpenApi","_internal","resultMetadata","originalExtend","extendedResult","zodDeepPartial","initialShape","resultShape","key","value","zodPick","zodOmit","init_dist","__esmMin","init_zod","z"],"mappings":"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","file":"chunk-Y7ZPKVJH.mjs","sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol */\r\n\r\n\r\nfunction __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\ntypeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\n\nfunction isZodType(schema, typeName) {\n    var _a;\n    return ((_a = schema === null || schema === void 0 ? void 0 : schema._def) === null || _a === void 0 ? void 0 : _a.typeName) === typeName;\n}\nfunction isAnyZodType(schema) {\n    return '_def' in schema;\n}\n\nfunction preserveMetadataFromModifier(zod, modifier) {\n    const zodModifier = zod.ZodType.prototype[modifier];\n    zod.ZodType.prototype[modifier] = function (...args) {\n        const result = zodModifier.apply(this, args);\n        result._def.openapi = this._def.openapi;\n        return result;\n    };\n}\nfunction extendZodWithOpenApi(zod) {\n    if (typeof zod.ZodType.prototype.openapi !== 'undefined') {\n        // This zod instance is already extended with the required methods,\n        // doing it again will just result in multiple wrapper methods for\n        // `optional` and `nullable`\n        return;\n    }\n    zod.ZodType.prototype.openapi = function (refOrOpenapi, metadata) {\n        var _a, _b, _c, _d, _e, _f;\n        const openapi = typeof refOrOpenapi === 'string' ? metadata : refOrOpenapi;\n        const _g = openapi !== null && openapi !== void 0 ? openapi : {}, { param } = _g, restOfOpenApi = __rest(_g, [\"param\"]);\n        const _internal = Object.assign(Object.assign({}, (_a = this._def.openapi) === null || _a === void 0 ? void 0 : _a._internal), (typeof refOrOpenapi === 'string'\n            ? { refId: refOrOpenapi }\n            : undefined));\n        const resultMetadata = Object.assign(Object.assign(Object.assign({}, (_b = this._def.openapi) === null || _b === void 0 ? void 0 : _b.metadata), restOfOpenApi), (((_d = (_c = this._def.openapi) === null || _c === void 0 ? void 0 : _c.metadata) === null || _d === void 0 ? void 0 : _d.param) || param\n            ? {\n                param: Object.assign(Object.assign({}, (_f = (_e = this._def.openapi) === null || _e === void 0 ? void 0 : _e.metadata) === null || _f === void 0 ? void 0 : _f.param), param),\n            }\n            : undefined));\n        const result = new this.constructor(Object.assign(Object.assign({}, this._def), { openapi: Object.assign(Object.assign({}, (Object.keys(_internal).length > 0 ? { _internal } : undefined)), (Object.keys(resultMetadata).length > 0\n                ? { metadata: resultMetadata }\n                : undefined)) }));\n        if (isZodType(this, 'ZodObject')) {\n            const originalExtend = this.extend;\n            result.extend = function (...args) {\n                var _a, _b, _c, _d, _e, _f, _g;\n                const extendedResult = originalExtend.apply(this, args);\n                extendedResult._def.openapi = {\n                    _internal: {\n                        extendedFrom: ((_b = (_a = this._def.openapi) === null || _a === void 0 ? void 0 : _a._internal) === null || _b === void 0 ? void 0 : _b.refId)\n                            ? { refId: (_d = (_c = this._def.openapi) === null || _c === void 0 ? void 0 : _c._internal) === null || _d === void 0 ? void 0 : _d.refId, schema: this }\n                            : (_f = (_e = this._def.openapi) === null || _e === void 0 ? void 0 : _e._internal) === null || _f === void 0 ? void 0 : _f.extendedFrom,\n                    },\n                    metadata: (_g = extendedResult._def.openapi) === null || _g === void 0 ? void 0 : _g.metadata,\n                };\n                return extendedResult;\n            };\n        }\n        return result;\n    };\n    preserveMetadataFromModifier(zod, 'optional');\n    preserveMetadataFromModifier(zod, 'nullable');\n    preserveMetadataFromModifier(zod, 'default');\n    preserveMetadataFromModifier(zod, 'transform');\n    preserveMetadataFromModifier(zod, 'refine');\n    const zodDeepPartial = zod.ZodObject.prototype.deepPartial;\n    zod.ZodObject.prototype.deepPartial = function () {\n        const initialShape = this._def.shape();\n        const result = zodDeepPartial.apply(this);\n        const resultShape = result._def.shape();\n        Object.entries(resultShape).forEach(([key, value]) => {\n            var _a, _b;\n            value._def.openapi = (_b = (_a = initialShape[key]) === null || _a === void 0 ? void 0 : _a._def) === null || _b === void 0 ? void 0 : _b.openapi;\n        });\n        result._def.openapi = undefined;\n        return result;\n    };\n    const zodPick = zod.ZodObject.prototype.pick;\n    zod.ZodObject.prototype.pick = function (...args) {\n        const result = zodPick.apply(this, args);\n        result._def.openapi = undefined;\n        return result;\n    };\n    const zodOmit = zod.ZodObject.prototype.omit;\n    zod.ZodObject.prototype.omit = function (...args) {\n        const result = zodOmit.apply(this, args);\n        result._def.openapi = undefined;\n        return result;\n    };\n}\n\nfunction isEqual(x, y) {\n    if (x === null || x === undefined || y === null || y === undefined) {\n        return x === y;\n    }\n    if (x === y || x.valueOf() === y.valueOf()) {\n        return true;\n    }\n    if (Array.isArray(x)) {\n        if (!Array.isArray(y)) {\n            return false;\n        }\n        if (x.length !== y.length) {\n            return false;\n        }\n    }\n    // if they are strictly equal, they both need to be object at least\n    if (!(x instanceof Object) || !(y instanceof Object)) {\n        return false;\n    }\n    // recursive object equality check\n    const keysX = Object.keys(x);\n    return (Object.keys(y).every(keyY => keysX.indexOf(keyY) !== -1) &&\n        keysX.every(key => isEqual(x[key], y[key])));\n}\nclass ObjectSet {\n    constructor() {\n        this.buckets = new Map();\n    }\n    put(value) {\n        const hashCode = this.hashCodeOf(value);\n        const itemsByCode = this.buckets.get(hashCode);\n        if (!itemsByCode) {\n            this.buckets.set(hashCode, [value]);\n            return;\n        }\n        const alreadyHasItem = itemsByCode.some(_ => isEqual(_, value));\n        if (!alreadyHasItem) {\n            itemsByCode.push(value);\n        }\n    }\n    contains(value) {\n        const hashCode = this.hashCodeOf(value);\n        const itemsByCode = this.buckets.get(hashCode);\n        if (!itemsByCode) {\n            return false;\n        }\n        return itemsByCode.some(_ => isEqual(_, value));\n    }\n    values() {\n        return [...this.buckets.values()].flat();\n    }\n    stats() {\n        let totalBuckets = 0;\n        let totalValues = 0;\n        let collisions = 0;\n        for (const bucket of this.buckets.values()) {\n            totalBuckets += 1;\n            totalValues += bucket.length;\n            if (bucket.length > 1) {\n                collisions += 1;\n            }\n        }\n        const hashEffectiveness = totalBuckets / totalValues;\n        return { totalBuckets, collisions, totalValues, hashEffectiveness };\n    }\n    hashCodeOf(object) {\n        let hashCode = 0;\n        if (Array.isArray(object)) {\n            for (let i = 0; i < object.length; i++) {\n                hashCode ^= this.hashCodeOf(object[i]) * i;\n            }\n            return hashCode;\n        }\n        if (typeof object === 'string') {\n            for (let i = 0; i < object.length; i++) {\n                hashCode ^= object.charCodeAt(i) * i;\n            }\n            return hashCode;\n        }\n        if (typeof object === 'number') {\n            return object;\n        }\n        if (typeof object === 'object') {\n            for (const [key, value] of Object.entries(object)) {\n                hashCode ^= this.hashCodeOf(key) + this.hashCodeOf(value !== null && value !== void 0 ? value : '');\n            }\n        }\n        return hashCode;\n    }\n}\n\nfunction isUndefined(value) {\n    return value === undefined;\n}\nfunction mapValues(object, mapper) {\n    const result = {};\n    Object.entries(object).forEach(([key, value]) => {\n        result[key] = mapper(value);\n    });\n    return result;\n}\nfunction omit(object, keys) {\n    const result = {};\n    Object.entries(object).forEach(([key, value]) => {\n        if (!keys.some(keyToOmit => keyToOmit === key)) {\n            result[key] = value;\n        }\n    });\n    return result;\n}\nfunction omitBy(object, predicate) {\n    const result = {};\n    Object.entries(object).forEach(([key, value]) => {\n        if (!predicate(value, key)) {\n            result[key] = value;\n        }\n    });\n    return result;\n}\nfunction compact(arr) {\n    return arr.filter((elem) => !isUndefined(elem));\n}\nconst objectEquals = isEqual;\nfunction uniq(values) {\n    const set = new ObjectSet();\n    values.forEach(value => set.put(value));\n    return [...set.values()];\n}\nfunction isString(val) {\n    return typeof val === 'string';\n}\n\nfunction getOpenApiMetadata(zodSchema) {\n    var _a, _b;\n    return omitBy((_b = (_a = zodSchema._def.openapi) === null || _a === void 0 ? void 0 : _a.metadata) !== null && _b !== void 0 ? _b : {}, isUndefined);\n}\n\nclass OpenAPIRegistry {\n    constructor(parents) {\n        this.parents = parents;\n        this._definitions = [];\n    }\n    get definitions() {\n        var _a, _b;\n        const parentDefinitions = (_b = (_a = this.parents) === null || _a === void 0 ? void 0 : _a.flatMap(par => par.definitions)) !== null && _b !== void 0 ? _b : [];\n        return [...parentDefinitions, ...this._definitions];\n    }\n    /**\n     * Registers a new component schema under /components/schemas/${name}\n     */\n    register(refId, zodSchema) {\n        const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);\n        this._definitions.push({ type: 'schema', schema: schemaWithRefId });\n        return schemaWithRefId;\n    }\n    /**\n     * Registers a new parameter schema under /components/parameters/${name}\n     */\n    registerParameter(refId, zodSchema) {\n        var _a, _b, _c;\n        const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);\n        const currentMetadata = (_a = schemaWithRefId._def.openapi) === null || _a === void 0 ? void 0 : _a.metadata;\n        const schemaWithMetadata = schemaWithRefId.openapi(Object.assign(Object.assign({}, currentMetadata), { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), { name: (_c = (_b = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : refId }) }));\n        this._definitions.push({\n            type: 'parameter',\n            schema: schemaWithMetadata,\n        });\n        return schemaWithMetadata;\n    }\n    /**\n     * Registers a new path that would be generated under paths:\n     */\n    registerPath(route) {\n        this._definitions.push({\n            type: 'route',\n            route,\n        });\n    }\n    /**\n     * Registers a new webhook that would be generated under webhooks:\n     */\n    registerWebhook(webhook) {\n        this._definitions.push({\n            type: 'webhook',\n            webhook,\n        });\n    }\n    /**\n     * Registers a raw OpenAPI component. Use this if you have a simple object instead of a Zod schema.\n     *\n     * @param type The component type, e.g. `schemas`, `responses`, `securitySchemes`, etc.\n     * @param name The name of the object, it is the key under the component\n     *             type in the resulting OpenAPI document\n     * @param component The actual object to put there\n     */\n    registerComponent(type, name, component) {\n        this._definitions.push({\n            type: 'component',\n            componentType: type,\n            name,\n            component,\n        });\n        return {\n            name,\n            ref: { $ref: `#/components/${type}/${name}` },\n        };\n    }\n    schemaWithRefId(refId, zodSchema) {\n        return zodSchema.openapi(refId);\n    }\n}\n\nclass ZodToOpenAPIError {\n    constructor(message) {\n        this.message = message;\n    }\n}\nclass ConflictError extends ZodToOpenAPIError {\n    constructor(message, data) {\n        super(message);\n        this.data = data;\n    }\n}\nclass MissingParameterDataError extends ZodToOpenAPIError {\n    constructor(data) {\n        super(`Missing parameter data, please specify \\`${data.missingField}\\` and other OpenAPI parameter props using the \\`param\\` field of \\`ZodSchema.openapi\\``);\n        this.data = data;\n    }\n}\nfunction enhanceMissingParametersError(action, paramsToAdd) {\n    try {\n        return action();\n    }\n    catch (error) {\n        if (error instanceof MissingParameterDataError) {\n            throw new MissingParameterDataError(Object.assign(Object.assign({}, error.data), paramsToAdd));\n        }\n        throw error;\n    }\n}\nclass UnknownZodTypeError extends ZodToOpenAPIError {\n    constructor(data) {\n        super(`Unknown zod object type, please specify \\`type\\` and other OpenAPI props using \\`ZodSchema.openapi\\`.`);\n        this.data = data;\n    }\n}\n\nclass Metadata {\n    static getMetadata(zodSchema) {\n        var _a;\n        const innerSchema = this.unwrapChained(zodSchema);\n        const metadata = zodSchema._def.openapi\n            ? zodSchema._def.openapi\n            : innerSchema._def.openapi;\n        /**\n         * Every zod schema can receive a `description` by using the .describe method.\n         * That description should be used when generating an OpenApi schema.\n         * The `??` bellow makes sure we can handle both:\n         * - schema.describe('Test').optional()\n         * - schema.optional().describe('Test')\n         */\n        const zodDescription = (_a = zodSchema.description) !== null && _a !== void 0 ? _a : innerSchema.description;\n        // A description provided from .openapi() should be taken with higher precedence\n        return {\n            _internal: metadata === null || metadata === void 0 ? void 0 : metadata._internal,\n            metadata: Object.assign({ description: zodDescription }, metadata === null || metadata === void 0 ? void 0 : metadata.metadata),\n        };\n    }\n    static getInternalMetadata(zodSchema) {\n        const innerSchema = this.unwrapChained(zodSchema);\n        const openapi = zodSchema._def.openapi\n            ? zodSchema._def.openapi\n            : innerSchema._def.openapi;\n        return openapi === null || openapi === void 0 ? void 0 : openapi._internal;\n    }\n    static getParamMetadata(zodSchema) {\n        var _a, _b;\n        const innerSchema = this.unwrapChained(zodSchema);\n        const metadata = zodSchema._def.openapi\n            ? zodSchema._def.openapi\n            : innerSchema._def.openapi;\n        /**\n         * Every zod schema can receive a `description` by using the .describe method.\n         * That description should be used when generating an OpenApi schema.\n         * The `??` bellow makes sure we can handle both:\n         * - schema.describe('Test').optional()\n         * - schema.optional().describe('Test')\n         */\n        const zodDescription = (_a = zodSchema.description) !== null && _a !== void 0 ? _a : innerSchema.description;\n        return {\n            _internal: metadata === null || metadata === void 0 ? void 0 : metadata._internal,\n            metadata: Object.assign(Object.assign({}, metadata === null || metadata === void 0 ? void 0 : metadata.metadata), { \n                // A description provided from .openapi() should be taken with higher precedence\n                param: Object.assign({ description: zodDescription }, (_b = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) === null || _b === void 0 ? void 0 : _b.param) }),\n        };\n    }\n    /**\n     * A method that omits all custom keys added to the regular OpenAPI\n     * metadata properties\n     */\n    static buildSchemaMetadata(metadata) {\n        return omitBy(omit(metadata, ['param']), isUndefined);\n    }\n    static buildParameterMetadata(metadata) {\n        return omitBy(metadata, isUndefined);\n    }\n    static applySchemaMetadata(initialData, metadata) {\n        return omitBy(Object.assign(Object.assign({}, initialData), this.buildSchemaMetadata(metadata)), isUndefined);\n    }\n    static getRefId(zodSchema) {\n        var _a;\n        return (_a = this.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.refId;\n    }\n    static unwrapChained(schema) {\n        return this.unwrapUntil(schema);\n    }\n    static getDefaultValue(zodSchema) {\n        const unwrapped = this.unwrapUntil(zodSchema, 'ZodDefault');\n        return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._def.defaultValue();\n    }\n    static unwrapUntil(schema, typeName) {\n        if (typeName && isZodType(schema, typeName)) {\n            return schema;\n        }\n        if (isZodType(schema, 'ZodOptional') ||\n            isZodType(schema, 'ZodNullable') ||\n            isZodType(schema, 'ZodBranded')) {\n            return this.unwrapUntil(schema.unwrap(), typeName);\n        }\n        if (isZodType(schema, 'ZodDefault') || isZodType(schema, 'ZodReadonly')) {\n            return this.unwrapUntil(schema._def.innerType, typeName);\n        }\n        if (isZodType(schema, 'ZodEffects')) {\n            return this.unwrapUntil(schema._def.schema, typeName);\n        }\n        if (isZodType(schema, 'ZodPipeline')) {\n            return this.unwrapUntil(schema._def.in, typeName);\n        }\n        return typeName ? undefined : schema;\n    }\n    static isOptionalSchema(zodSchema) {\n        return zodSchema.isOptional();\n    }\n}\n\nclass ArrayTransformer {\n    transform(zodSchema, mapNullableType, mapItems) {\n        var _a, _b;\n        const itemType = zodSchema._def.type;\n        return Object.assign(Object.assign({}, mapNullableType('array')), { items: mapItems(itemType), minItems: (_a = zodSchema._def.minLength) === null || _a === void 0 ? void 0 : _a.value, maxItems: (_b = zodSchema._def.maxLength) === null || _b === void 0 ? void 0 : _b.value });\n    }\n}\n\nclass BigIntTransformer {\n    transform(mapNullableType) {\n        return Object.assign(Object.assign({}, mapNullableType('string')), { pattern: `^\\d+$` });\n    }\n}\n\nclass DiscriminatedUnionTransformer {\n    transform(zodSchema, isNullable, mapNullableOfArray, mapItem, generateSchemaRef) {\n        const options = [...zodSchema.options.values()];\n        const optionSchema = options.map(mapItem);\n        if (isNullable) {\n            return {\n                oneOf: mapNullableOfArray(optionSchema, isNullable),\n            };\n        }\n        return {\n            oneOf: optionSchema,\n            discriminator: this.mapDiscriminator(options, zodSchema.discriminator, generateSchemaRef),\n        };\n    }\n    mapDiscriminator(zodObjects, discriminator, generateSchemaRef) {\n        // All schemas must be registered to use a discriminator\n        if (zodObjects.some(obj => Metadata.getRefId(obj) === undefined)) {\n            return undefined;\n        }\n        const mapping = {};\n        zodObjects.forEach(obj => {\n            var _a;\n            const refId = Metadata.getRefId(obj); // type-checked earlier\n            const value = (_a = obj.shape) === null || _a === void 0 ? void 0 : _a[discriminator];\n            if (isZodType(value, 'ZodEnum') || isZodType(value, 'ZodNativeEnum')) {\n                // Native enums have their keys as both number and strings however the number is an\n                // internal representation and the string is the access point for a documentation\n                const keys = Object.values(value.enum).filter(isString);\n                keys.forEach((enumValue) => {\n                    mapping[enumValue] = generateSchemaRef(refId);\n                });\n                return;\n            }\n            const literalValue = value === null || value === void 0 ? void 0 : value._def.value;\n            // This should never happen because Zod checks the disciminator type but to keep the types happy\n            if (typeof literalValue !== 'string') {\n                throw new Error(`Discriminator ${discriminator} could not be found in one of the values of a discriminated union`);\n            }\n            mapping[literalValue] = generateSchemaRef(refId);\n        });\n        return {\n            propertyName: discriminator,\n            mapping,\n        };\n    }\n}\n\nclass EnumTransformer {\n    transform(zodSchema, mapNullableType) {\n        // ZodEnum only accepts strings\n        return Object.assign(Object.assign({}, mapNullableType('string')), { enum: zodSchema._def.values });\n    }\n}\n\nclass IntersectionTransformer {\n    transform(zodSchema, isNullable, mapNullableOfArray, mapItem) {\n        const subtypes = this.flattenIntersectionTypes(zodSchema);\n        const allOfSchema = {\n            allOf: subtypes.map(mapItem),\n        };\n        if (isNullable) {\n            return {\n                anyOf: mapNullableOfArray([allOfSchema], isNullable),\n            };\n        }\n        return allOfSchema;\n    }\n    flattenIntersectionTypes(schema) {\n        if (!isZodType(schema, 'ZodIntersection')) {\n            return [schema];\n        }\n        const leftSubTypes = this.flattenIntersectionTypes(schema._def.left);\n        const rightSubTypes = this.flattenIntersectionTypes(schema._def.right);\n        return [...leftSubTypes, ...rightSubTypes];\n    }\n}\n\nclass LiteralTransformer {\n    transform(zodSchema, mapNullableType) {\n        return Object.assign(Object.assign({}, mapNullableType(typeof zodSchema._def.value)), { enum: [zodSchema._def.value] });\n    }\n}\n\n/**\n * Numeric enums have a reverse mapping https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings\n * whereas string ones don't.\n *\n * This function checks if an enum is fully numeric - i.e all values are numbers or not.\n * And filters out only the actual enum values when a reverse mapping is apparent.\n */\nfunction enumInfo(enumObject) {\n    const keysExceptReverseMappings = Object.keys(enumObject).filter(key => typeof enumObject[enumObject[key]] !== 'number');\n    const values = keysExceptReverseMappings.map(key => enumObject[key]);\n    const numericCount = values.filter(_ => typeof _ === 'number').length;\n    const type = numericCount === 0\n        ? 'string'\n        : numericCount === values.length\n            ? 'numeric'\n            : 'mixed';\n    return { values, type };\n}\n\nclass NativeEnumTransformer {\n    transform(zodSchema, mapNullableType) {\n        const { type, values } = enumInfo(zodSchema._def.values);\n        if (type === 'mixed') {\n            // enum Test {\n            //   A = 42,\n            //   B = 'test',\n            // }\n            //\n            // const result = z.nativeEnum(Test).parse('42');\n            //\n            // This is an error, so we can't just say it's a 'string'\n            throw new ZodToOpenAPIError('Enum has mixed string and number values, please specify the OpenAPI type manually');\n        }\n        return Object.assign(Object.assign({}, mapNullableType(type === 'numeric' ? 'integer' : 'string')), { enum: values });\n    }\n}\n\nclass NumberTransformer {\n    transform(zodSchema, mapNullableType, getNumberChecks) {\n        return Object.assign(Object.assign({}, mapNullableType(zodSchema.isInt ? 'integer' : 'number')), getNumberChecks(zodSchema._def.checks));\n    }\n}\n\nclass ObjectTransformer {\n    transform(zodSchema, defaultValue, mapNullableType, mapItem) {\n        var _a;\n        const extendedFrom = (_a = Metadata.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.extendedFrom;\n        const required = this.requiredKeysOf(zodSchema);\n        const properties = mapValues(zodSchema._def.shape(), mapItem);\n        if (!extendedFrom) {\n            return Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType('object')), { properties, default: defaultValue }), (required.length > 0 ? { required } : {})), this.generateAdditionalProperties(zodSchema, mapItem));\n        }\n        const parent = extendedFrom.schema;\n        // We want to generate the parent schema so that it can be referenced down the line\n        mapItem(parent);\n        const keysRequiredByParent = this.requiredKeysOf(parent);\n        const propsOfParent = mapValues(parent === null || parent === void 0 ? void 0 : parent._def.shape(), mapItem);\n        const propertiesToAdd = Object.fromEntries(Object.entries(properties).filter(([key, type]) => {\n            return !objectEquals(propsOfParent[key], type);\n        }));\n        const additionallyRequired = required.filter(prop => !keysRequiredByParent.includes(prop));\n        const objectData = Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType('object')), { default: defaultValue, properties: propertiesToAdd }), (additionallyRequired.length > 0\n            ? { required: additionallyRequired }\n            : {})), this.generateAdditionalProperties(zodSchema, mapItem));\n        return {\n            allOf: [\n                { $ref: `#/components/schemas/${extendedFrom.refId}` },\n                objectData,\n            ],\n        };\n    }\n    generateAdditionalProperties(zodSchema, mapItem) {\n        const unknownKeysOption = zodSchema._def.unknownKeys;\n        const catchallSchema = zodSchema._def.catchall;\n        if (isZodType(catchallSchema, 'ZodNever')) {\n            if (unknownKeysOption === 'strict') {\n                return { additionalProperties: false };\n            }\n            return {};\n        }\n        return { additionalProperties: mapItem(catchallSchema) };\n    }\n    requiredKeysOf(objectSchema) {\n        return Object.entries(objectSchema._def.shape())\n            .filter(([_key, type]) => !Metadata.isOptionalSchema(type))\n            .map(([key, _type]) => key);\n    }\n}\n\nclass RecordTransformer {\n    transform(zodSchema, mapNullableType, mapItem) {\n        const propertiesType = zodSchema._def.valueType;\n        const keyType = zodSchema._def.keyType;\n        const propertiesSchema = mapItem(propertiesType);\n        if (isZodType(keyType, 'ZodEnum') || isZodType(keyType, 'ZodNativeEnum')) {\n            // Native enums have their keys as both number and strings however the number is an\n            // internal representation and the string is the access point for a documentation\n            const keys = Object.values(keyType.enum).filter(isString);\n            const properties = keys.reduce((acc, curr) => (Object.assign(Object.assign({}, acc), { [curr]: propertiesSchema })), {});\n            return Object.assign(Object.assign({}, mapNullableType('object')), { properties });\n        }\n        return Object.assign(Object.assign({}, mapNullableType('object')), { additionalProperties: propertiesSchema });\n    }\n}\n\nclass StringTransformer {\n    transform(zodSchema, mapNullableType) {\n        var _a, _b, _c;\n        const regexCheck = this.getZodStringCheck(zodSchema, 'regex');\n        const length = (_a = this.getZodStringCheck(zodSchema, 'length')) === null || _a === void 0 ? void 0 : _a.value;\n        const maxLength = Number.isFinite(zodSchema.minLength)\n            ? (_b = zodSchema.minLength) !== null && _b !== void 0 ? _b : undefined\n            : undefined;\n        const minLength = Number.isFinite(zodSchema.maxLength)\n            ? (_c = zodSchema.maxLength) !== null && _c !== void 0 ? _c : undefined\n            : undefined;\n        return Object.assign(Object.assign({}, mapNullableType('string')), { \n            // FIXME: https://github.com/colinhacks/zod/commit/d78047e9f44596a96d637abb0ce209cd2732d88c\n            minLength: length !== null && length !== void 0 ? length : maxLength, maxLength: length !== null && length !== void 0 ? length : minLength, format: this.mapStringFormat(zodSchema), pattern: regexCheck === null || regexCheck === void 0 ? void 0 : regexCheck.regex.source });\n    }\n    /**\n     * Attempts to map Zod strings to known formats\n     * https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats\n     */\n    mapStringFormat(zodString) {\n        if (zodString.isUUID)\n            return 'uuid';\n        if (zodString.isEmail)\n            return 'email';\n        if (zodString.isURL)\n            return 'uri';\n        if (zodString.isDate)\n            return 'date';\n        if (zodString.isDatetime)\n            return 'date-time';\n        if (zodString.isCUID)\n            return 'cuid';\n        if (zodString.isCUID2)\n            return 'cuid2';\n        if (zodString.isULID)\n            return 'ulid';\n        if (zodString.isIP)\n            return 'ip';\n        if (zodString.isEmoji)\n            return 'emoji';\n        return undefined;\n    }\n    getZodStringCheck(zodString, kind) {\n        return zodString._def.checks.find((check) => {\n            return check.kind === kind;\n        });\n    }\n}\n\nclass TupleTransformer {\n    constructor(versionSpecifics) {\n        this.versionSpecifics = versionSpecifics;\n    }\n    transform(zodSchema, mapNullableType, mapItem) {\n        const { items } = zodSchema._def;\n        const schemas = items.map(mapItem);\n        return Object.assign(Object.assign({}, mapNullableType('array')), this.versionSpecifics.mapTupleItems(schemas));\n    }\n}\n\nclass UnionTransformer {\n    transform(zodSchema, mapNullableOfArray, mapItem) {\n        const options = this.flattenUnionTypes(zodSchema);\n        const schemas = options.map(schema => {\n            // If any of the underlying schemas of a union is .nullable then the whole union\n            // would be nullable. `mapNullableOfArray` would place it where it belongs.\n            // Therefor we are stripping the additional nullables from the inner schemas\n            // See https://github.com/asteasolutions/zod-to-openapi/issues/149\n            const optionToGenerate = this.unwrapNullable(schema);\n            return mapItem(optionToGenerate);\n        });\n        return {\n            anyOf: mapNullableOfArray(schemas),\n        };\n    }\n    flattenUnionTypes(schema) {\n        if (!isZodType(schema, 'ZodUnion')) {\n            return [schema];\n        }\n        const options = schema._def.options;\n        return options.flatMap(option => this.flattenUnionTypes(option));\n    }\n    unwrapNullable(schema) {\n        if (isZodType(schema, 'ZodNullable')) {\n            return this.unwrapNullable(schema.unwrap());\n        }\n        return schema;\n    }\n}\n\nclass OpenApiTransformer {\n    constructor(versionSpecifics) {\n        this.versionSpecifics = versionSpecifics;\n        this.objectTransformer = new ObjectTransformer();\n        this.stringTransformer = new StringTransformer();\n        this.numberTransformer = new NumberTransformer();\n        this.bigIntTransformer = new BigIntTransformer();\n        this.literalTransformer = new LiteralTransformer();\n        this.enumTransformer = new EnumTransformer();\n        this.nativeEnumTransformer = new NativeEnumTransformer();\n        this.arrayTransformer = new ArrayTransformer();\n        this.unionTransformer = new UnionTransformer();\n        this.discriminatedUnionTransformer = new DiscriminatedUnionTransformer();\n        this.intersectionTransformer = new IntersectionTransformer();\n        this.recordTransformer = new RecordTransformer();\n        this.tupleTransformer = new TupleTransformer(versionSpecifics);\n    }\n    transform(zodSchema, isNullable, mapItem, generateSchemaRef, defaultValue) {\n        if (isZodType(zodSchema, 'ZodNull')) {\n            return this.versionSpecifics.nullType;\n        }\n        if (isZodType(zodSchema, 'ZodUnknown') || isZodType(zodSchema, 'ZodAny')) {\n            return this.versionSpecifics.mapNullableType(undefined, isNullable);\n        }\n        if (isZodType(zodSchema, 'ZodObject')) {\n            return this.objectTransformer.transform(zodSchema, defaultValue, // verified on TS level from input\n            // verified on TS level from input\n            _ => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);\n        }\n        const schema = this.transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef);\n        return Object.assign(Object.assign({}, schema), { default: defaultValue });\n    }\n    transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef) {\n        if (isZodType(zodSchema, 'ZodUnknown') || isZodType(zodSchema, 'ZodAny')) {\n            return this.versionSpecifics.mapNullableType(undefined, isNullable);\n        }\n        if (isZodType(zodSchema, 'ZodString')) {\n            return this.stringTransformer.transform(zodSchema, schema => this.versionSpecifics.mapNullableType(schema, isNullable));\n        }\n        if (isZodType(zodSchema, 'ZodNumber')) {\n            return this.numberTransformer.transform(zodSchema, schema => this.versionSpecifics.mapNullableType(schema, isNullable), _ => this.versionSpecifics.getNumberChecks(_));\n        }\n        if (isZodType(zodSchema, 'ZodBigInt')) {\n            return this.bigIntTransformer.transform(schema => this.versionSpecifics.mapNullableType(schema, isNullable));\n        }\n        if (isZodType(zodSchema, 'ZodBoolean')) {\n            return this.versionSpecifics.mapNullableType('boolean', isNullable);\n        }\n        if (isZodType(zodSchema, 'ZodLiteral')) {\n            return this.literalTransformer.transform(zodSchema, schema => this.versionSpecifics.mapNullableType(schema, isNullable));\n        }\n        if (isZodType(zodSchema, 'ZodEnum')) {\n            return this.enumTransformer.transform(zodSchema, schema => this.versionSpecifics.mapNullableType(schema, isNullable));\n        }\n        if (isZodType(zodSchema, 'ZodNativeEnum')) {\n            return this.nativeEnumTransformer.transform(zodSchema, schema => this.versionSpecifics.mapNullableType(schema, isNullable));\n        }\n        if (isZodType(zodSchema, 'ZodArray')) {\n            return this.arrayTransformer.transform(zodSchema, _ => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);\n        }\n        if (isZodType(zodSchema, 'ZodTuple')) {\n            return this.tupleTransformer.transform(zodSchema, _ => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);\n        }\n        if (isZodType(zodSchema, 'ZodUnion')) {\n            return this.unionTransformer.transform(zodSchema, _ => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);\n        }\n        if (isZodType(zodSchema, 'ZodDiscriminatedUnion')) {\n            return this.discriminatedUnionTransformer.transform(zodSchema, isNullable, _ => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem, generateSchemaRef);\n        }\n        if (isZodType(zodSchema, 'ZodIntersection')) {\n            return this.intersectionTransformer.transform(zodSchema, isNullable, _ => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);\n        }\n        if (isZodType(zodSchema, 'ZodRecord')) {\n            return this.recordTransformer.transform(zodSchema, _ => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);\n        }\n        if (isZodType(zodSchema, 'ZodDate')) {\n            return this.versionSpecifics.mapNullableType('string', isNullable);\n        }\n        const refId = Metadata.getRefId(zodSchema);\n        throw new UnknownZodTypeError({\n            currentSchema: zodSchema._def,\n            schemaName: refId,\n        });\n    }\n}\n\nclass OpenAPIGenerator {\n    constructor(definitions, versionSpecifics) {\n        this.definitions = definitions;\n        this.versionSpecifics = versionSpecifics;\n        this.schemaRefs = {};\n        this.paramRefs = {};\n        this.pathRefs = {};\n        this.rawComponents = [];\n        this.openApiTransformer = new OpenApiTransformer(versionSpecifics);\n        this.sortDefinitions();\n    }\n    generateDocumentData() {\n        this.definitions.forEach(definition => this.generateSingle(definition));\n        return {\n            components: this.buildComponents(),\n            paths: this.pathRefs,\n        };\n    }\n    generateComponents() {\n        this.definitions.forEach(definition => this.generateSingle(definition));\n        return {\n            components: this.buildComponents(),\n        };\n    }\n    buildComponents() {\n        var _a, _b;\n        const rawComponents = {};\n        this.rawComponents.forEach(({ componentType, name, component }) => {\n            var _a;\n            (_a = rawComponents[componentType]) !== null && _a !== void 0 ? _a : (rawComponents[componentType] = {});\n            rawComponents[componentType][name] = component;\n        });\n        return Object.assign(Object.assign({}, rawComponents), { schemas: Object.assign(Object.assign({}, ((_a = rawComponents.schemas) !== null && _a !== void 0 ? _a : {})), this.schemaRefs), parameters: Object.assign(Object.assign({}, ((_b = rawComponents.parameters) !== null && _b !== void 0 ? _b : {})), this.paramRefs) });\n    }\n    sortDefinitions() {\n        const generationOrder = [\n            'schema',\n            'parameter',\n            'component',\n            'route',\n        ];\n        this.definitions.sort((left, right) => {\n            // No type means \"plain zod schema\" => it comes as highest priority based on the array above\n            if (!('type' in left)) {\n                if (!('type' in right)) {\n                    return 0;\n                }\n                return -1;\n            }\n            if (!('type' in right)) {\n                return 1;\n            }\n            const leftIndex = generationOrder.findIndex(type => type === left.type);\n            const rightIndex = generationOrder.findIndex(type => type === right.type);\n            return leftIndex - rightIndex;\n        });\n    }\n    generateSingle(definition) {\n        if (!('type' in definition)) {\n            this.generateSchemaWithRef(definition);\n            return;\n        }\n        switch (definition.type) {\n            case 'parameter':\n                this.generateParameterDefinition(definition.schema);\n                return;\n            case 'schema':\n                this.generateSchemaWithRef(definition.schema);\n                return;\n            case 'route':\n                this.generateSingleRoute(definition.route);\n                return;\n            case 'component':\n                this.rawComponents.push(definition);\n                return;\n        }\n    }\n    generateParameterDefinition(zodSchema) {\n        const refId = Metadata.getRefId(zodSchema);\n        const result = this.generateParameter(zodSchema);\n        if (refId) {\n            this.paramRefs[refId] = result;\n        }\n        return result;\n    }\n    getParameterRef(schemaMetadata, external) {\n        var _a, _b, _c, _d, _e;\n        const parameterMetadata = (_a = schemaMetadata === null || schemaMetadata === void 0 ? void 0 : schemaMetadata.metadata) === null || _a === void 0 ? void 0 : _a.param;\n        const existingRef = ((_b = schemaMetadata === null || schemaMetadata === void 0 ? void 0 : schemaMetadata._internal) === null || _b === void 0 ? void 0 : _b.refId)\n            ? this.paramRefs[(_c = schemaMetadata._internal) === null || _c === void 0 ? void 0 : _c.refId]\n            : undefined;\n        if (!((_d = schemaMetadata === null || schemaMetadata === void 0 ? void 0 : schemaMetadata._internal) === null || _d === void 0 ? void 0 : _d.refId) || !existingRef) {\n            return undefined;\n        }\n        if ((parameterMetadata && existingRef.in !== parameterMetadata.in) ||\n            ((external === null || external === void 0 ? void 0 : external.in) && existingRef.in !== external.in)) {\n            throw new ConflictError(`Conflicting location for parameter ${existingRef.name}`, {\n                key: 'in',\n                values: compact([\n                    existingRef.in,\n                    external === null || external === void 0 ? void 0 : external.in,\n                    parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.in,\n                ]),\n            });\n        }\n        if ((parameterMetadata && existingRef.name !== parameterMetadata.name) ||\n            ((external === null || external === void 0 ? void 0 : external.name) && existingRef.name !== (external === null || external === void 0 ? void 0 : external.name))) {\n            throw new ConflictError(`Conflicting names for parameter`, {\n                key: 'name',\n                values: compact([\n                    existingRef.name,\n                    external === null || external === void 0 ? void 0 : external.name,\n                    parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.name,\n                ]),\n            });\n        }\n        return {\n            $ref: `#/components/parameters/${(_e = schemaMetadata._internal) === null || _e === void 0 ? void 0 : _e.refId}`,\n        };\n    }\n    generateInlineParameters(zodSchema, location) {\n        var _a;\n        const metadata = Metadata.getMetadata(zodSchema);\n        const parameterMetadata = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) === null || _a === void 0 ? void 0 : _a.param;\n        const referencedSchema = this.getParameterRef(metadata, { in: location });\n        if (referencedSchema) {\n            return [referencedSchema];\n        }\n        if (isZodType(zodSchema, 'ZodObject')) {\n            const propTypes = zodSchema._def.shape();\n            const parameters = Object.entries(propTypes).map(([key, schema]) => {\n                var _a, _b;\n                const innerMetadata = Metadata.getMetadata(schema);\n                const referencedSchema = this.getParameterRef(innerMetadata, {\n                    in: location,\n                    name: key,\n                });\n                if (referencedSchema) {\n                    return referencedSchema;\n                }\n                const innerParameterMetadata = (_a = innerMetadata === null || innerMetadata === void 0 ? void 0 : innerMetadata.metadata) === null || _a === void 0 ? void 0 : _a.param;\n                if ((innerParameterMetadata === null || innerParameterMetadata === void 0 ? void 0 : innerParameterMetadata.name) &&\n                    innerParameterMetadata.name !== key) {\n                    throw new ConflictError(`Conflicting names for parameter`, {\n                        key: 'name',\n                        values: [key, innerParameterMetadata.name],\n                    });\n                }\n                if ((innerParameterMetadata === null || innerParameterMetadata === void 0 ? void 0 : innerParameterMetadata.in) &&\n                    innerParameterMetadata.in !== location) {\n                    throw new ConflictError(`Conflicting location for parameter ${(_b = innerParameterMetadata.name) !== null && _b !== void 0 ? _b : key}`, {\n                        key: 'in',\n                        values: [location, innerParameterMetadata.in],\n                    });\n                }\n                return this.generateParameter(schema.openapi({ param: { name: key, in: location } }));\n            });\n            return parameters;\n        }\n        if ((parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.in) && parameterMetadata.in !== location) {\n            throw new ConflictError(`Conflicting location for parameter ${parameterMetadata.name}`, {\n                key: 'in',\n                values: [location, parameterMetadata.in],\n            });\n        }\n        return [\n            this.generateParameter(zodSchema.openapi({ param: { in: location } })),\n        ];\n    }\n    generateSimpleParameter(zodSchema) {\n        var _a;\n        const metadata = Metadata.getParamMetadata(zodSchema);\n        const paramMetadata = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) === null || _a === void 0 ? void 0 : _a.param;\n        // TODO: Why are we not unwrapping here for isNullable as well?\n        const required = !Metadata.isOptionalSchema(zodSchema) && !zodSchema.isNullable();\n        const schema = this.generateSchemaWithRef(zodSchema);\n        return Object.assign({ schema,\n            required }, (paramMetadata ? Metadata.buildParameterMetadata(paramMetadata) : {}));\n    }\n    generateParameter(zodSchema) {\n        var _a;\n        const metadata = Metadata.getMetadata(zodSchema);\n        const paramMetadata = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) === null || _a === void 0 ? void 0 : _a.param;\n        const paramName = paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.name;\n        const paramLocation = paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.in;\n        if (!paramName) {\n            throw new MissingParameterDataError({ missingField: 'name' });\n        }\n        if (!paramLocation) {\n            throw new MissingParameterDataError({\n                missingField: 'in',\n                paramName,\n            });\n        }\n        const baseParameter = this.generateSimpleParameter(zodSchema);\n        return Object.assign(Object.assign({}, baseParameter), { in: paramLocation, name: paramName });\n    }\n    generateSchemaWithMetadata(zodSchema) {\n        var _a;\n        const innerSchema = Metadata.unwrapChained(zodSchema);\n        const metadata = Metadata.getMetadata(zodSchema);\n        const defaultValue = Metadata.getDefaultValue(zodSchema);\n        const result = ((_a = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) === null || _a === void 0 ? void 0 : _a.type)\n            ? { type: metadata === null || metadata === void 0 ? void 0 : metadata.metadata.type }\n            : this.toOpenAPISchema(innerSchema, zodSchema.isNullable(), defaultValue);\n        return (metadata === null || metadata === void 0 ? void 0 : metadata.metadata)\n            ? Metadata.applySchemaMetadata(result, metadata.metadata)\n            : omitBy(result, isUndefined);\n    }\n    /**\n     * Same as above but applies nullable\n     */\n    constructReferencedOpenAPISchema(zodSchema) {\n        var _a;\n        const metadata = Metadata.getMetadata(zodSchema);\n        const innerSchema = Metadata.unwrapChained(zodSchema);\n        const defaultValue = Metadata.getDefaultValue(zodSchema);\n        const isNullableSchema = zodSchema.isNullable();\n        if ((_a = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) === null || _a === void 0 ? void 0 : _a.type) {\n            return this.versionSpecifics.mapNullableType(metadata.metadata.type, isNullableSchema);\n        }\n        return this.toOpenAPISchema(innerSchema, isNullableSchema, defaultValue);\n    }\n    /**\n     * Generates an OpenAPI SchemaObject or a ReferenceObject with all the provided metadata applied\n     */\n    generateSimpleSchema(zodSchema) {\n        var _a;\n        const metadata = Metadata.getMetadata(zodSchema);\n        const refId = Metadata.getRefId(zodSchema);\n        if (!refId || !this.schemaRefs[refId]) {\n            return this.generateSchemaWithMetadata(zodSchema);\n        }\n        const schemaRef = this.schemaRefs[refId];\n        const referenceObject = {\n            $ref: this.generateSchemaRef(refId),\n        };\n        // Metadata provided from .openapi() that is new to what we had already registered\n        const newMetadata = omitBy(Metadata.buildSchemaMetadata((_a = metadata === null || metadata === void 0 ? void 0 : metadata.metadata) !== null && _a !== void 0 ? _a : {}), (value, key) => value === undefined || objectEquals(value, schemaRef[key]));\n        // Do not calculate schema metadata overrides if type is provided in .openapi\n        // https://github.com/asteasolutions/zod-to-openapi/pull/52/files/8ff707fe06e222bc573ed46cf654af8ee0b0786d#r996430801\n        if (newMetadata.type) {\n            return {\n                allOf: [referenceObject, newMetadata],\n            };\n        }\n        // New metadata from ZodSchema properties.\n        const newSchemaMetadata = omitBy(this.constructReferencedOpenAPISchema(zodSchema), (value, key) => value === undefined || objectEquals(value, schemaRef[key]));\n        const appliedMetadata = Metadata.applySchemaMetadata(newSchemaMetadata, newMetadata);\n        if (Object.keys(appliedMetadata).length > 0) {\n            return {\n                allOf: [referenceObject, appliedMetadata],\n            };\n        }\n        return referenceObject;\n    }\n    /**\n     * Same as `generateSchema` but if the new schema is added into the\n     * referenced schemas, it would return a ReferenceObject and not the\n     * whole result.\n     *\n     * Should be used for nested objects, arrays, etc.\n     */\n    generateSchemaWithRef(zodSchema) {\n        const refId = Metadata.getRefId(zodSchema);\n        const result = this.generateSimpleSchema(zodSchema);\n        if (refId && this.schemaRefs[refId] === undefined) {\n            this.schemaRefs[refId] = result;\n            return { $ref: this.generateSchemaRef(refId) };\n        }\n        return result;\n    }\n    generateSchemaRef(refId) {\n        return `#/components/schemas/${refId}`;\n    }\n    getRequestBody(requestBody) {\n        if (!requestBody) {\n            return;\n        }\n        const { content } = requestBody, rest = __rest(requestBody, [\"content\"]);\n        const requestBodyContent = this.getBodyContent(content);\n        return Object.assign(Object.assign({}, rest), { content: requestBodyContent });\n    }\n    getParameters(request) {\n        if (!request) {\n            return [];\n        }\n        const { headers } = request;\n        const query = this.cleanParameter(request.query);\n        const params = this.cleanParameter(request.params);\n        const cookies = this.cleanParameter(request.cookies);\n        const queryParameters = enhanceMissingParametersError(() => (query ? this.generateInlineParameters(query, 'query') : []), { location: 'query' });\n        const pathParameters = enhanceMissingParametersError(() => (params ? this.generateInlineParameters(params, 'path') : []), { location: 'path' });\n        const cookieParameters = enhanceMissingParametersError(() => (cookies ? this.generateInlineParameters(cookies, 'cookie') : []), { location: 'cookie' });\n        const headerParameters = enhanceMissingParametersError(() => {\n            if (Array.isArray(headers)) {\n                return headers.flatMap(header => this.generateInlineParameters(header, 'header'));\n            }\n            const cleanHeaders = this.cleanParameter(headers);\n            return cleanHeaders\n                ? this.generateInlineParameters(cleanHeaders, 'header')\n                : [];\n        }, { location: 'header' });\n        return [\n            ...pathParameters,\n            ...queryParameters,\n            ...headerParameters,\n            ...cookieParameters,\n        ];\n    }\n    cleanParameter(schema) {\n        if (!schema) {\n            return undefined;\n        }\n        return isZodType(schema, 'ZodEffects')\n            ? this.cleanParameter(schema._def.schema)\n            : schema;\n    }\n    generatePath(route) {\n        const { method, path, request, responses } = route, pathItemConfig = __rest(route, [\"method\", \"path\", \"request\", \"responses\"]);\n        const generatedResponses = mapValues(responses, response => {\n            return this.getResponse(response);\n        });\n        const parameters = enhanceMissingParametersError(() => this.getParameters(request), { route: `${method} ${path}` });\n        const requestBody = this.getRequestBody(request === null || request === void 0 ? void 0 : request.body);\n        const routeDoc = {\n            [method]: Object.assign(Object.assign(Object.assign(Object.assign({}, pathItemConfig), (parameters.length > 0\n                ? {\n                    parameters: [...(pathItemConfig.parameters || []), ...parameters],\n                }\n                : {})), (requestBody ? { requestBody } : {})), { responses: generatedResponses }),\n        };\n        return routeDoc;\n    }\n    generateSingleRoute(route) {\n        const routeDoc = this.generatePath(route);\n        this.pathRefs[route.path] = Object.assign(Object.assign({}, this.pathRefs[route.path]), routeDoc);\n        return routeDoc;\n    }\n    getResponse(response) {\n        if (this.isReferenceObject(response)) {\n            return response;\n        }\n        const { content, headers } = response, rest = __rest(response, [\"content\", \"headers\"]);\n        const responseContent = content\n            ? { content: this.getBodyContent(content) }\n            : {};\n        if (!headers) {\n            return Object.assign(Object.assign({}, rest), responseContent);\n        }\n        const responseHeaders = isZodType(headers, 'ZodObject')\n            ? this.getResponseHeaders(headers)\n            : // This is input data so it is okay to cast in the common generator\n                // since this is the user's responsibility to keep it correct\n                headers;\n        return Object.assign(Object.assign(Object.assign({}, rest), { headers: responseHeaders }), responseContent);\n    }\n    isReferenceObject(schema) {\n        return '$ref' in schema;\n    }\n    getResponseHeaders(headers) {\n        const schemaShape = headers._def.shape();\n        const responseHeaders = mapValues(schemaShape, _ => this.generateSimpleParameter(_));\n        return responseHeaders;\n    }\n    getBodyContent(content) {\n        return mapValues(content, config => {\n            if (!config || !isAnyZodType(config.schema)) {\n                return config;\n            }\n            const { schema: configSchema } = config, rest = __rest(config, [\"schema\"]);\n            const schema = this.generateSchemaWithRef(configSchema);\n            return Object.assign({ schema }, rest);\n        });\n    }\n    toOpenAPISchema(zodSchema, isNullable, defaultValue) {\n        return this.openApiTransformer.transform(zodSchema, isNullable, _ => this.generateSchemaWithRef(_), _ => this.generateSchemaRef(_), defaultValue);\n    }\n}\n\nclass OpenApiGeneratorV30Specifics {\n    get nullType() {\n        return { nullable: true };\n    }\n    mapNullableOfArray(objects, isNullable) {\n        if (isNullable) {\n            return [...objects, this.nullType];\n        }\n        return objects;\n    }\n    mapNullableType(type, isNullable) {\n        return Object.assign(Object.assign({}, (type ? { type } : undefined)), (isNullable ? this.nullType : undefined));\n    }\n    mapTupleItems(schemas) {\n        const uniqueSchemas = uniq(schemas);\n        return {\n            items: uniqueSchemas.length === 1\n                ? uniqueSchemas[0]\n                : { anyOf: uniqueSchemas },\n            minItems: schemas.length,\n            maxItems: schemas.length,\n        };\n    }\n    getNumberChecks(checks) {\n        return Object.assign({}, ...checks.map(check => {\n            switch (check.kind) {\n                case 'min':\n                    return check.inclusive\n                        ? { minimum: Number(check.value) }\n                        : { minimum: Number(check.value), exclusiveMinimum: true };\n                case 'max':\n                    return check.inclusive\n                        ? { maximum: Number(check.value) }\n                        : { maximum: Number(check.value), exclusiveMaximum: true };\n                default:\n                    return {};\n            }\n        }));\n    }\n}\n\nclass OpenApiGeneratorV3 {\n    constructor(definitions) {\n        const specifics = new OpenApiGeneratorV30Specifics();\n        this.generator = new OpenAPIGenerator(definitions, specifics);\n    }\n    generateDocument(config) {\n        const baseData = this.generator.generateDocumentData();\n        return Object.assign(Object.assign({}, config), baseData);\n    }\n    generateComponents() {\n        return this.generator.generateComponents();\n    }\n}\n\nclass OpenApiGeneratorV31Specifics {\n    get nullType() {\n        return { type: 'null' };\n    }\n    mapNullableOfArray(objects, isNullable) {\n        if (isNullable) {\n            return [...objects, this.nullType];\n        }\n        return objects;\n    }\n    mapNullableType(type, isNullable) {\n        if (!type) {\n            // 'null' is considered a type in Open API 3.1.0 => not providing a type includes null\n            return {};\n        }\n        // Open API 3.1.0 made the `nullable` key invalid and instead you use type arrays\n        if (isNullable) {\n            return {\n                type: Array.isArray(type) ? [...type, 'null'] : [type, 'null'],\n            };\n        }\n        return {\n            type,\n        };\n    }\n    mapTupleItems(schemas) {\n        return {\n            prefixItems: schemas,\n        };\n    }\n    getNumberChecks(checks) {\n        return Object.assign({}, ...checks.map(check => {\n            switch (check.kind) {\n                case 'min':\n                    return check.inclusive\n                        ? { minimum: Number(check.value) }\n                        : { exclusiveMinimum: Number(check.value) };\n                case 'max':\n                    return check.inclusive\n                        ? { maximum: Number(check.value) }\n                        : { exclusiveMaximum: Number(check.value) };\n                default:\n                    return {};\n            }\n        }));\n    }\n}\n\nfunction isWebhookDefinition(definition) {\n    return 'type' in definition && definition.type === 'webhook';\n}\nclass OpenApiGeneratorV31 {\n    constructor(definitions) {\n        this.definitions = definitions;\n        this.webhookRefs = {};\n        const specifics = new OpenApiGeneratorV31Specifics();\n        this.generator = new OpenAPIGenerator(this.definitions, specifics);\n    }\n    generateDocument(config) {\n        const baseDocument = this.generator.generateDocumentData();\n        this.definitions\n            .filter(isWebhookDefinition)\n            .forEach(definition => this.generateSingleWebhook(definition.webhook));\n        return Object.assign(Object.assign(Object.assign({}, config), baseDocument), { webhooks: this.webhookRefs });\n    }\n    generateComponents() {\n        return this.generator.generateComponents();\n    }\n    generateSingleWebhook(route) {\n        const routeDoc = this.generator.generatePath(route);\n        this.webhookRefs[route.path] = Object.assign(Object.assign({}, this.webhookRefs[route.path]), routeDoc);\n        return routeDoc;\n    }\n}\n\nexport { OpenAPIRegistry, OpenApiGeneratorV3, OpenApiGeneratorV31, extendZodWithOpenApi, getOpenApiMetadata };\n","/**\n * @fileoverview Zod OpenAPI Extension Initialization\n *\n * This module ensures that Zod is extended with OpenAPI functionality before\n * any schemas are created. All schema files should import `z` from this module\n * instead of directly from 'zod' to ensure the `.openapi()` method is available.\n *\n * This fixes the issue where schemas created before `extendZodWithOpenApi()` was\n * called don't have the `.openapi()` method, preventing proper schema registration\n * in OpenAPI specifications.\n */\n\nimport { extendZodWithOpenApi } from \"@asteasolutions/zod-to-openapi\";\nimport { z } from \"zod\";\n\n// Extend Zod with OpenAPI support BEFORE any schemas are created\n// This must be called before any imports that create Zod schemas\nextendZodWithOpenApi(z);\n\n// Re-export z so all schema files can import from this module\nexport { z };\n"]}