@atom8n/json-schema-to-zod 1.6.9 → 1.7.0

package/dist/cjs/parsers/parse-schema.js

@@ -0,0 +1,159 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchema = void 0;
+const z = __importStar(require("zod"));
+const parse_all_of_1 = require("./parse-all-of");
+const parse_any_of_1 = require("./parse-any-of");
+const parse_array_1 = require("./parse-array");
+const parse_boolean_1 = require("./parse-boolean");
+const parse_const_1 = require("./parse-const");
+const parse_default_1 = require("./parse-default");
+const parse_enum_1 = require("./parse-enum");
+const parse_if_then_else_1 = require("./parse-if-then-else");
+const parse_multiple_type_1 = require("./parse-multiple-type");
+const parse_not_1 = require("./parse-not");
+const parse_null_1 = require("./parse-null");
+const parse_nullable_1 = require("./parse-nullable");
+const parse_number_1 = require("./parse-number");
+const parse_object_1 = require("./parse-object");
+const parse_one_of_1 = require("./parse-one-of");
+const parse_string_1 = require("./parse-string");
+const its_1 = require("../utils/its");
+const addDescribes = (jsonSchema, zodSchema) => {
+    if (jsonSchema.description) {
+        zodSchema = zodSchema.describe(jsonSchema.description);
+    }
+    return zodSchema;
+};
+const addDefaults = (jsonSchema, zodSchema) => {
+    if (jsonSchema.default !== undefined) {
+        zodSchema = zodSchema.default(jsonSchema.default);
+    }
+    return zodSchema;
+};
+const addAnnotations = (jsonSchema, zodSchema) => {
+    if (jsonSchema.readOnly) {
+        zodSchema = zodSchema.readonly();
+    }
+    return zodSchema;
+};
+const selectParser = (schema, refs) => {
+    if (its_1.its.a.nullable(schema)) {
+        return (0, parse_nullable_1.parseNullable)(schema, refs);
+    }
+    else if (its_1.its.an.object(schema)) {
+        return (0, parse_object_1.parseObject)(schema, refs);
+    }
+    else if (its_1.its.an.array(schema)) {
+        return (0, parse_array_1.parseArray)(schema, refs);
+    }
+    else if (its_1.its.an.anyOf(schema)) {
+        return (0, parse_any_of_1.parseAnyOf)(schema, refs);
+    }
+    else if (its_1.its.an.allOf(schema)) {
+        return (0, parse_all_of_1.parseAllOf)(schema, refs);
+    }
+    else if (its_1.its.a.oneOf(schema)) {
+        return (0, parse_one_of_1.parseOneOf)(schema, refs);
+    }
+    else if (its_1.its.a.not(schema)) {
+        return (0, parse_not_1.parseNot)(schema, refs);
+    }
+    else if (its_1.its.an.enum(schema)) {
+        return (0, parse_enum_1.parseEnum)(schema); //<-- needs to come before primitives
+    }
+    else if (its_1.its.a.const(schema)) {
+        return (0, parse_const_1.parseConst)(schema);
+    }
+    else if (its_1.its.a.multipleType(schema)) {
+        return (0, parse_multiple_type_1.parseMultipleType)(schema, refs);
+    }
+    else if (its_1.its.a.primitive(schema, 'string')) {
+        return (0, parse_string_1.parseString)(schema);
+    }
+    else if (its_1.its.a.primitive(schema, 'number') || its_1.its.a.primitive(schema, 'integer')) {
+        return (0, parse_number_1.parseNumber)(schema);
+    }
+    else if (its_1.its.a.primitive(schema, 'boolean')) {
+        return (0, parse_boolean_1.parseBoolean)(schema);
+    }
+    else if (its_1.its.a.primitive(schema, 'null')) {
+        return (0, parse_null_1.parseNull)(schema);
+    }
+    else if (its_1.its.a.conditional(schema)) {
+        return (0, parse_if_then_else_1.parseIfThenElse)(schema, refs);
+    }
+    else {
+        return (0, parse_default_1.parseDefault)(schema);
+    }
+};
+const parseSchema = (jsonSchema, refs = { seen: new Map(), path: [] }, blockMeta) => {
+    if (typeof jsonSchema !== 'object')
+        return jsonSchema ? z.any() : z.never();
+    if (refs.parserOverride) {
+        const custom = refs.parserOverride(jsonSchema, refs);
+        if (custom instanceof z.ZodType) {
+            return custom;
+        }
+    }
+    let seen = refs.seen.get(jsonSchema);
+    if (seen) {
+        if (seen.r !== undefined) {
+            return seen.r;
+        }
+        if (refs.depth === undefined || seen.n >= refs.depth) {
+            return z.any();
+        }
+        seen.n += 1;
+    }
+    else {
+        seen = { r: undefined, n: 0 };
+        refs.seen.set(jsonSchema, seen);
+    }
+    let parsedZodSchema = selectParser(jsonSchema, refs);
+    if (!blockMeta) {
+        if (!refs.withoutDescribes) {
+            parsedZodSchema = addDescribes(jsonSchema, parsedZodSchema);
+        }
+        if (!refs.withoutDefaults) {
+            parsedZodSchema = addDefaults(jsonSchema, parsedZodSchema);
+        }
+        parsedZodSchema = addAnnotations(jsonSchema, parsedZodSchema);
+    }
+    seen.r = parsedZodSchema;
+    return parsedZodSchema;
+};
+exports.parseSchema = parseSchema;

package/dist/cjs/parsers/parse-string.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseString = void 0;
+const zod_1 = require("zod");
+const extend_schema_1 = require("../utils/extend-schema");
+const parseString = (jsonSchema) => {
+    let zodSchema = zod_1.z.string();
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'format', (zs, format, errorMsg) => {
+        switch (format) {
+            case 'email':
+                return zs.email(errorMsg);
+            case 'ip':
+                return zs.ip(errorMsg);
+            case 'ipv4':
+                return zs.ip({ version: 'v4', message: errorMsg });
+            case 'ipv6':
+                return zs.ip({ version: 'v6', message: errorMsg });
+            case 'uri':
+                return zs.url(errorMsg);
+            case 'uuid':
+                return zs.uuid(errorMsg);
+            case 'date-time':
+                return zs.datetime({ offset: true, message: errorMsg });
+            case 'time':
+                return zs.time(errorMsg);
+            case 'date':
+                return zs.date(errorMsg);
+            case 'binary':
+                return zs.base64(errorMsg);
+            case 'duration':
+                return zs.duration(errorMsg);
+            default:
+                return zs;
+        }
+    });
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'contentEncoding', (zs, _, errorMsg) => zs.base64(errorMsg));
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'pattern', (zs, pattern, errorMsg) => zs.regex(new RegExp(pattern), errorMsg));
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'minLength', (zs, minLength, errorMsg) => zs.min(minLength, errorMsg));
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'maxLength', (zs, maxLength, errorMsg) => zs.max(maxLength, errorMsg));
+    return zodSchema;
+};
+exports.parseString = parseString;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/extend-schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendSchemaWithMessage = extendSchemaWithMessage;
+function extendSchemaWithMessage(zodSchema, jsonSchema, key, extend) {
+    const value = jsonSchema[key];
+    if (value !== undefined) {
+        const errorMessage = jsonSchema.errorMessage?.[key];
+        return extend(zodSchema, value, errorMessage);
+    }
+    return zodSchema;
+}

package/dist/cjs/utils/half.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.half = void 0;
+const half = (arr) => {
+    return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
+};
+exports.half = half;

package/dist/cjs/utils/its.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.its = void 0;
+exports.its = {
+    an: {
+        object: (x) => x.type === 'object',
+        array: (x) => x.type === 'array',
+        anyOf: (x) => x.anyOf !== undefined,
+        allOf: (x) => x.allOf !== undefined,
+        enum: (x) => x.enum !== undefined,
+    },
+    a: {
+        nullable: (x) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        x.nullable === true,
+        multipleType: (x) => Array.isArray(x.type),
+        not: (x) => x.not !== undefined,
+        const: (x) => x.const !== undefined,
+        primitive: (x, p) => x.type === p,
+        conditional: (x) => Boolean('if' in x && x.if && 'then' in x && 'else' in x && x.then && x.else),
+        oneOf: (x) => x.oneOf !== undefined,
+    },
+};

package/dist/cjs/utils/omit.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omit = void 0;
+const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
+    if (!keys.includes(key)) {
+        acc[key] = obj[key];
+    }
+    return acc;
+}, {});
+exports.omit = omit;

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { jsonSchemaToZod } from './json-schema-to-zod';

package/dist/esm/json-schema-to-zod.js

@@ -0,0 +1,8 @@
+import { parseSchema } from './parsers/parse-schema';
+export const jsonSchemaToZod = (schema, options = {}) => {
+    return parseSchema(schema, {
+        path: [],
+        seen: new Map(),
+        ...options,
+    });
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/parsers/parse-all-of.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+import { half } from '../utils/half';
+const originalIndex = Symbol('Original index');
+const ensureOriginalIndex = (arr) => {
+    const newArr = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item === 'boolean') {
+            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+        }
+        else if (originalIndex in item) {
+            return arr;
+        }
+        else {
+            newArr.push({ ...item, [originalIndex]: i });
+        }
+    }
+    return newArr;
+};
+export function parseAllOf(jsonSchema, refs) {
+    if (jsonSchema.allOf.length === 0) {
+        return z.never();
+    }
+    if (jsonSchema.allOf.length === 1) {
+        const item = jsonSchema.allOf[0];
+        return parseSchema(item, {
+            ...refs,
+            path: [...refs.path, 'allOf', item[originalIndex]],
+        });
+    }
+    const [left, right] = half(ensureOriginalIndex(jsonSchema.allOf));
+    return z.intersection(parseAllOf({ allOf: left }, refs), parseAllOf({ allOf: right }, refs));
+}

package/dist/esm/parsers/parse-any-of.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+export const parseAnyOf = (jsonSchema, refs) => {
+    return jsonSchema.anyOf.length
+        ? jsonSchema.anyOf.length === 1
+            ? parseSchema(jsonSchema.anyOf[0], {
+                ...refs,
+                path: [...refs.path, 'anyOf', 0],
+            })
+            : z.union(jsonSchema.anyOf.map((schema, i) => parseSchema(schema, { ...refs, path: [...refs.path, 'anyOf', i] })))
+        : z.any();
+};

package/dist/esm/parsers/parse-array.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+import { extendSchemaWithMessage } from '../utils/extend-schema';
+export const parseArray = (jsonSchema, refs) => {
+    if (Array.isArray(jsonSchema.items)) {
+        return z.tuple(jsonSchema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, 'items', i] })));
+    }
+    let zodSchema = !jsonSchema.items
+        ? z.array(z.any())
+        : z.array(parseSchema(jsonSchema.items, { ...refs, path: [...refs.path, 'items'] }));
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'minItems', (zs, minItems, errorMessage) => zs.min(minItems, errorMessage));
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'maxItems', (zs, maxItems, errorMessage) => zs.max(maxItems, errorMessage));
+    return zodSchema;
+};

package/dist/esm/parsers/parse-boolean.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const parseBoolean = (_jsonSchema) => {
+    return z.boolean();
+};

package/dist/esm/parsers/parse-const.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const parseConst = (jsonSchema) => {
+    return z.literal(jsonSchema.const);
+};

package/dist/esm/parsers/parse-default.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const parseDefault = (_jsonSchema) => {
+    return z.any();
+};

package/dist/esm/parsers/parse-enum.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const parseEnum = (jsonSchema) => {
+    if (jsonSchema.enum.length === 0) {
+        return z.never();
+    }
+    if (jsonSchema.enum.length === 1) {
+        // union does not work when there is only one element
+        return z.literal(jsonSchema.enum[0]);
+    }
+    if (jsonSchema.enum.every((x) => typeof x === 'string')) {
+        return z.enum(jsonSchema.enum);
+    }
+    return z.union(jsonSchema.enum.map((x) => z.literal(x)));
+};

package/dist/esm/parsers/parse-if-then-else.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+export const parseIfThenElse = (jsonSchema, refs) => {
+    const $if = parseSchema(jsonSchema.if, { ...refs, path: [...refs.path, 'if'] });
+    const $then = parseSchema(jsonSchema.then, {
+        ...refs,
+        path: [...refs.path, 'then'],
+    });
+    const $else = parseSchema(jsonSchema.else, {
+        ...refs,
+        path: [...refs.path, 'else'],
+    });
+    return z.union([$then, $else]).superRefine((value, ctx) => {
+        const result = $if.safeParse(value).success ? $then.safeParse(value) : $else.safeParse(value);
+        if (!result.success) {
+            result.error.errors.forEach((error) => ctx.addIssue(error));
+        }
+    });
+};

package/dist/esm/parsers/parse-multiple-type.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+export const parseMultipleType = (jsonSchema, refs) => {
+    return z.union(jsonSchema.type.map((type) => parseSchema({ ...jsonSchema, type }, refs)));
+};

package/dist/esm/parsers/parse-not.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+export const parseNot = (jsonSchema, refs) => {
+    return z.any().refine((value) => !parseSchema(jsonSchema.not, {
+        ...refs,
+        path: [...refs.path, 'not'],
+    }).safeParse(value).success, 'Invalid input: Should NOT be valid against schema');
+};

package/dist/esm/parsers/parse-null.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const parseNull = (_jsonSchema) => {
+    return z.null();
+};

package/dist/esm/parsers/parse-nullable.js

@@ -0,0 +1,8 @@
+import { parseSchema } from './parse-schema';
+import { omit } from '../utils/omit';
+/**
+ * For compatibility with open api 3.0 nullable
+ */
+export const parseNullable = (jsonSchema, refs) => {
+    return parseSchema(omit(jsonSchema, 'nullable'), refs, true).nullable();
+};

package/dist/esm/parsers/parse-number.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { extendSchemaWithMessage } from '../utils/extend-schema';
+export const parseNumber = (jsonSchema) => {
+    let zodSchema = z.number();
+    let isInteger = false;
+    if (jsonSchema.type === 'integer') {
+        isInteger = true;
+        zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'type', (zs, _, errorMsg) => zs.int(errorMsg));
+    }
+    else if (jsonSchema.format === 'int64') {
+        isInteger = true;
+        zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'format', (zs, _, errorMsg) => zs.int(errorMsg));
+    }
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'multipleOf', (zs, multipleOf, errorMsg) => {
+        if (multipleOf === 1) {
+            if (isInteger)
+                return zs;
+            return zs.int(errorMsg);
+        }
+        return zs.multipleOf(multipleOf, errorMsg);
+    });
+    if (typeof jsonSchema.minimum === 'number') {
+        if (jsonSchema.exclusiveMinimum === true) {
+            zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'minimum', (zs, minimum, errorMsg) => zs.gt(minimum, errorMsg));
+        }
+        else {
+            zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'minimum', (zs, minimum, errorMsg) => zs.gte(minimum, errorMsg));
+        }
+    }
+    else if (typeof jsonSchema.exclusiveMinimum === 'number') {
+        zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'exclusiveMinimum', (zs, exclusiveMinimum, errorMsg) => zs.gt(exclusiveMinimum, errorMsg));
+    }
+    if (typeof jsonSchema.maximum === 'number') {
+        if (jsonSchema.exclusiveMaximum === true) {
+            zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'maximum', (zs, maximum, errorMsg) => zs.lt(maximum, errorMsg));
+        }
+        else {
+            zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'maximum', (zs, maximum, errorMsg) => zs.lte(maximum, errorMsg));
+        }
+    }
+    else if (typeof jsonSchema.exclusiveMaximum === 'number') {
+        zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'exclusiveMaximum', (zs, exclusiveMaximum, errorMsg) => zs.lt(exclusiveMaximum, errorMsg));
+    }
+    return zodSchema;
+};

package/dist/esm/parsers/parse-object.js

@@ -0,0 +1,170 @@
+import * as z from 'zod';
+import { parseAllOf } from './parse-all-of';
+import { parseAnyOf } from './parse-any-of';
+import { parseOneOf } from './parse-one-of';
+import { parseSchema } from './parse-schema';
+import { its } from '../utils/its';
+function parseObjectProperties(objectSchema, refs) {
+    if (!objectSchema.properties) {
+        return undefined;
+    }
+    const propertyKeys = Object.keys(objectSchema.properties);
+    if (propertyKeys.length === 0) {
+        return z.object({});
+    }
+    const properties = {};
+    for (const key of propertyKeys) {
+        const propJsonSchema = objectSchema.properties[key];
+        const propZodSchema = parseSchema(propJsonSchema, {
+            ...refs,
+            path: [...refs.path, 'properties', key],
+        });
+        const hasDefault = typeof propJsonSchema === 'object' && propJsonSchema.default !== undefined;
+        const required = Array.isArray(objectSchema.required)
+            ? objectSchema.required.includes(key)
+            : typeof propJsonSchema === 'object' && propJsonSchema.required === true;
+        const isOptional = !hasDefault && !required;
+        properties[key] = isOptional ? propZodSchema.optional() : propZodSchema;
+    }
+    return z.object(properties);
+}
+export function parseObject(objectSchema, refs) {
+    const hasPatternProperties = Object.keys(objectSchema.patternProperties ?? {}).length > 0;
+    const propertiesSchema = parseObjectProperties(objectSchema, refs);
+    let zodSchema = propertiesSchema;
+    const additionalProperties = objectSchema.additionalProperties !== undefined
+        ? parseSchema(objectSchema.additionalProperties, {
+            ...refs,
+            path: [...refs.path, 'additionalProperties'],
+        })
+        : undefined;
+    if (objectSchema.patternProperties) {
+        const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
+            return [
+                key,
+                parseSchema(value, {
+                    ...refs,
+                    path: [...refs.path, 'patternProperties', key],
+                }),
+            ];
+        }));
+        const patternPropertyValues = Object.values(parsedPatternProperties);
+        if (propertiesSchema) {
+            if (additionalProperties) {
+                zodSchema = propertiesSchema.catchall(z.union([...patternPropertyValues, additionalProperties]));
+            }
+            else if (Object.keys(parsedPatternProperties).length > 1) {
+                zodSchema = propertiesSchema.catchall(z.union(patternPropertyValues));
+            }
+            else {
+                zodSchema = propertiesSchema.catchall(patternPropertyValues[0]);
+            }
+        }
+        else {
+            if (additionalProperties) {
+                zodSchema = z.record(z.union([...patternPropertyValues, additionalProperties]));
+            }
+            else if (patternPropertyValues.length > 1) {
+                zodSchema = z.record(z.union(patternPropertyValues));
+            }
+            else {
+                zodSchema = z.record(patternPropertyValues[0]);
+            }
+        }
+        const objectPropertyKeys = new Set(Object.keys(objectSchema.properties ?? {}));
+        zodSchema = zodSchema.superRefine((value, ctx) => {
+            for (const key in value) {
+                let wasMatched = objectPropertyKeys.has(key);
+                for (const patternPropertyKey in objectSchema.patternProperties) {
+                    const regex = new RegExp(patternPropertyKey);
+                    if (key.match(regex)) {
+                        wasMatched = true;
+                        const result = parsedPatternProperties[patternPropertyKey].safeParse(value[key]);
+                        if (!result.success) {
+                            ctx.addIssue({
+                                path: [...ctx.path, key],
+                                code: 'custom',
+                                message: `Invalid input: Key matching regex /${key}/ must match schema`,
+                                params: {
+                                    issues: result.error.issues,
+                                },
+                            });
+                        }
+                    }
+                }
+                if (!wasMatched && additionalProperties) {
+                    const result = additionalProperties.safeParse(value[key]);
+                    if (!result.success) {
+                        ctx.addIssue({
+                            path: [...ctx.path, key],
+                            code: 'custom',
+                            message: 'Invalid input: must match catchall schema',
+                            params: {
+                                issues: result.error.issues,
+                            },
+                        });
+                    }
+                }
+            }
+        });
+    }
+    let output;
+    if (propertiesSchema) {
+        if (hasPatternProperties) {
+            output = zodSchema;
+        }
+        else if (additionalProperties) {
+            if (additionalProperties instanceof z.ZodNever) {
+                output = propertiesSchema.strict();
+            }
+            else {
+                output = propertiesSchema.catchall(additionalProperties);
+            }
+        }
+        else {
+            output = zodSchema;
+        }
+    }
+    else {
+        if (hasPatternProperties) {
+            output = zodSchema;
+        }
+        else if (additionalProperties) {
+            output = z.record(additionalProperties);
+        }
+        else {
+            output = z.record(z.any());
+        }
+    }
+    if (its.an.anyOf(objectSchema)) {
+        output = output.and(parseAnyOf({
+            ...objectSchema,
+            anyOf: objectSchema.anyOf.map((x) => typeof x === 'object' &&
+                !x.type &&
+                (x.properties ?? x.additionalProperties ?? x.patternProperties)
+                ? { ...x, type: 'object' }
+                : x),
+        }, refs));
+    }
+    if (its.a.oneOf(objectSchema)) {
+        output = output.and(parseOneOf({
+            ...objectSchema,
+            oneOf: objectSchema.oneOf.map((x) => typeof x === 'object' &&
+                !x.type &&
+                (x.properties ?? x.additionalProperties ?? x.patternProperties)
+                ? { ...x, type: 'object' }
+                : x),
+        }, refs));
+    }
+    if (its.an.allOf(objectSchema)) {
+        output = output.and(parseAllOf({
+            ...objectSchema,
+            allOf: objectSchema.allOf.map((x) => typeof x === 'object' &&
+                !x.type &&
+                (x.properties ?? x.additionalProperties ?? x.patternProperties)
+                ? { ...x, type: 'object' }
+                : x),
+        }, refs));
+    }
+    return output;
+}