camera.ui3 0.0.30-alpha.0 → 0.0.30-alpha.1

package/dist/server/src/polyglot/node/plugins/schema.js

@@ -1,740 +0,0 @@
-import { z } from 'zod';
-const isISO8601 = (value) => {
-    const iso8601Regex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
-    return iso8601Regex.test(value);
-};
-const isTime = (value, options) => {
-    const timeRegex = options.mode === 'withSeconds' ? /^([01]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/ : /^([01]?[0-9]|2[0-3]):([0-5][0-9])$/;
-    return timeRegex.test(value);
-};
-const isEmail = (value) => {
-    const emailRegex = /^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b$/;
-    return emailRegex.test(value);
-};
-const isUUID = (value) => {
-    const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
-    return uuidRegex.test(value);
-};
-const isIP = (value, version) => {
-    const ipRegex = version === 4 ? /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/ : /^\s*([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4})\s*$/;
-    return ipRegex.test(value);
-};
-/**
- * Generate root JSON schema from value.
- *
- * @param value - Value.
- * @returns - Root JSON schema.
- */
-export const generateRootSchema = (value) => {
-    const schema = {};
-    Object.entries(value).forEach(([key, subValue]) => {
-        schema[key] = generateSchema(subValue);
-    });
-    return { schema };
-};
-/**
- * Generate JSON schema from value.
- *
- * @param value - Value.
- * @returns - JSON schema.
- */
-export const generateSchema = (value) => {
-    switch (true) {
-        case value === undefined:
-        case typeof value === 'undefined':
-        case typeof value === 'function':
-        case typeof value === 'symbol':
-        case value instanceof Date:
-            throw new TypeError(`Invalid JSON value: ${String(value)}`);
-        // /**
-        //  * @see https://json-schema.org/understanding-json-schema/reference/null.html
-        //  */
-        // case value === null:
-        //   return { type: 'null' };
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/numeric.html
-         */
-        case typeof value === 'number':
-            return generateNumberSchema();
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/boolean.html
-         */
-        case typeof value === 'boolean':
-            return genereateBooleanSchema();
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/string.html
-         */
-        case typeof value === 'string':
-            return generateStringSchema(value);
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/array.html
-         */
-        case Array.isArray(value):
-            const allPrimitives = value.every((item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean');
-            if (allPrimitives) {
-                return generateEnumSchema(value);
-            }
-            else {
-                return generateArraySchema(value);
-            }
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/object.html
-         */
-        case value instanceof Object:
-            return generateObjectSchema(value);
-        default:
-            throw new TypeError(`Invalid JSON value: ${value}`);
-    }
-};
-/**
- * Generate a JSON object from a given Root JSON schema.
- *
- * @param rootSchema - The Root JSON schema.
- * @returns - The generated JSON object.
- */
-export const generateJsonFromRootSchema = (rootSchema) => {
-    const jsonObject = {};
-    Object.entries(rootSchema.schema).forEach(([key, jsonSchema]) => {
-        jsonObject[key] = generateJsonFromSchema(jsonSchema);
-    });
-    return jsonObject;
-};
-/**
- * Generate a JSON object from a JSON schema.
- *
- * @param jsonSchema - The JSON schema.
- * @returns - The generated JSON object.
- */
-export const generateJsonFromSchema = (jsonSchema) => {
-    switch (jsonSchema.type) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-            if (isEnumType(jsonSchema)) {
-                if (jsonSchema.multiple) {
-                    return jsonSchema.defaultValue !== undefined ? [jsonSchema.defaultValue] : undefined;
-                }
-                else {
-                    return jsonSchema.defaultValue !== undefined ? jsonSchema.defaultValue : jsonSchema.required ? jsonSchema.enum[0] : undefined;
-                }
-            }
-            else {
-                return jsonSchema.defaultValue;
-            }
-        case 'object':
-            if (jsonSchema.properties) {
-                return Object.entries(jsonSchema.properties).reduce((obj, [key, value]) => {
-                    obj[key] = generateJsonFromSchema(value);
-                    return obj;
-                }, {});
-            }
-            return {};
-        case 'array':
-            if (jsonSchema.items) {
-                return [generateJsonFromSchema(jsonSchema.items)];
-            }
-            return [];
-        default:
-            return undefined;
-    }
-};
-/**
- * Generate a JSON object from a given JSON schema and use values from a config file.
- *
- * @param jsonSchema - The JSON schema.
- * @param config - The config file with values to use.
- * @returns - The generated JSON object.
- */
-export const generateJsonFromSchemaWithConfig = (jsonSchema, config, path = '') => {
-    switch (jsonSchema.type) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-            const value = getValueByPath(config, path);
-            return value !== undefined ? value : generateJsonFromSchema(jsonSchema);
-        case 'object':
-            if (jsonSchema.properties) {
-                return Object.entries(jsonSchema.properties).reduce((obj, [key, schema]) => {
-                    const newPath = path + (path.length > 0 ? '.' : '') + key;
-                    obj[key] = generateJsonFromSchemaWithConfig(schema, config, newPath);
-                    return obj;
-                }, {});
-            }
-            return {};
-        case 'array':
-            if (jsonSchema.items) {
-                const items = jsonSchema.items;
-                const arrayConfig = getValueByPath(config, path) ?? [];
-                return arrayConfig.map((itemConfig, index) => generateJsonFromSchemaWithConfig(items, itemConfig, path + `[${index}]`));
-            }
-            return [];
-        default:
-            return undefined;
-    }
-};
-/**
- * Generate a new config object from a given JSON schema and use values from a config file.
- * Contains only storable values.
- *
- * @param jsonSchema - The JSON schema.
- * @param config - The config file with values to use.
- * @param path - The path to the current JSON schema.
- */
-export const generateStorableConfig = (jsonSchema, config) => {
-    const newConfig = {};
-    const processSchema = (schema, value) => {
-        if (isObjectType(schema) && schema.properties) {
-            const result = {};
-            Object.entries(schema.properties).forEach(([key, propSchema]) => {
-                const propValue = processSchema(propSchema, value?.[key]);
-                if (propValue !== undefined) {
-                    result[key] = propValue;
-                }
-            });
-            return Object.keys(result).length > 0 ? result : undefined;
-        }
-        else if (isArrayType(schema) && schema.items && Array.isArray(value)) {
-            const result = value.map((item) => processSchema(schema.items, item)).filter((item) => item !== undefined);
-            return result.length > 0 ? result : undefined;
-        }
-        else if (schema.store) {
-            return value;
-        }
-        return undefined;
-    };
-    Object.entries(jsonSchema).forEach(([key, schema]) => {
-        const result = processSchema(schema, config[key]);
-        if (result !== undefined) {
-            newConfig[key] = result;
-        }
-    });
-    return newConfig;
-};
-/**
- * Removes all functions from a given Plugin JSON schema form.
- *
- * @param schemaForm - The Plugin JSON schema form from which the functions should be removed.
- * @returns - The Plugin JSON schema form without functions.
- */
-export const removeFunctionsFromSchemaForm = (schemaForm) => {
-    const filteredSchemaForm = {};
-    Object.keys(schemaForm).forEach((key) => {
-        filteredSchemaForm[key] = removeFunctionsFromSchema(schemaForm[key]);
-    });
-    return filteredSchemaForm;
-};
-/**
- * Removes all functions from a given Plugin JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the functions should be removed.
- * @returns - The JSON schema without functions.
- */
-export const removeFunctionsFromSchema = (jsonSchema) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { onSet, onGet, ...rest } = jsonSchema;
-    if (isObjectType(rest) && rest.properties) {
-        rest.properties = removeFunctionsFromSchemaForm(rest.properties);
-    }
-    else if (isArrayType(rest) && rest.items) {
-        rest.items = removeFunctionsFromSchema(rest.items);
-    }
-    return rest;
-};
-/**
- * Checks if a given JSON schema is readonly.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is readonly, false otherwise.
- */
-export const schemaIsReadonly = (jsonSchema) => {
-    return Boolean(jsonSchema.readonly ||
-        (isObjectType(jsonSchema) && jsonSchema.properties && Object.values(jsonSchema.properties).every((property) => schemaIsReadonly(property))) ||
-        (isArrayType(jsonSchema) && jsonSchema.items && schemaIsReadonly(jsonSchema.items)));
-};
-export const schemaIsStorable = (jsonSchema) => {
-    return Boolean(jsonSchema.store ||
-        (isObjectType(jsonSchema) && jsonSchema.properties && Object.values(jsonSchema.properties).some((property) => schemaIsStorable(property))) ||
-        (isArrayType(jsonSchema) && jsonSchema.items && schemaIsStorable(jsonSchema.items)));
-};
-/**
- * Converts a config path to a schema path.
- *
- * @param configPath - The config path to be converted.
- * @returns - The converted schema path.
- */
-export const configPathToSchemaPath = (configPath) => {
-    const pathParts = configPath.split('.');
-    const schemaPathParts = [];
-    pathParts.forEach((part, index) => {
-        const isNumericIndex = /^\d+$/.test(part);
-        const isLastPart = index === pathParts.length - 1;
-        if (isNumericIndex) {
-            schemaPathParts.push('items', 'properties');
-        }
-        else {
-            schemaPathParts.push(part);
-            const isNumericIndex = /^\d+$/.test(pathParts[index + 1]);
-            // if (!isLastPart && isNaN(parseInt(pathParts[index + 1]))) {
-            if (!isLastPart && !isNumericIndex) {
-                schemaPathParts.push('properties');
-            }
-        }
-    });
-    return schemaPathParts.join('.');
-};
-/**
- * Converts a schema path to a config path.
- *
- * @param schemaPath - The schema path to be converted.
- * @returns - The converted config path.
- */
-export const schemaPathToConfigPath = (schemaPath) => {
-    const pathParts = schemaPath.split('.');
-    const configPathParts = [];
-    pathParts.forEach((part) => {
-        // Exclude 'properties' and 'items' keywords from the path
-        if (part !== 'properties' && part !== 'items') {
-            // Check if the part is a numeric index and format it as an array index
-            const isNumericIndex = /^\d+$/.test(part);
-            if (isNumericIndex) {
-                configPathParts.push(`[${part}]`);
-            }
-            else {
-                configPathParts.push(part);
-            }
-        }
-    });
-    return configPathParts.join('.');
-};
-/**
- * Recursively searches a JSON object for a specific, potentially nested key path and returns its value.
- *
- * @param obj - The JSON object to be searched.
- * @param path - The key path to search for.
- * @returns - The value of the searched key path, if found, otherwise undefined.
- */
-export const getValueByPath = (obj = {}, path) => {
-    const keys = path.split('.').reduce((acc, key) => {
-        if (key.includes('[')) {
-            const [pathKey, index] = key.split('[');
-            acc.push(pathKey, index.slice(0, -1));
-        }
-        else {
-            acc.push(key);
-        }
-        return acc;
-    }, []);
-    let current = obj;
-    for (const key of keys) {
-        if (current === undefined) {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-};
-/**
- * Generates a Zod schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be generated.
- * @returns - The generated Zod schema.
- */
-export const generateZodSchemaFromRoot = (rootSchema) => {
-    const zodObjectSchema = {};
-    Object.entries(rootSchema.schema).forEach(([key, jsonSchema]) => {
-        zodObjectSchema[key] = generateZodSchema(jsonSchema);
-    });
-    return z.object(zodObjectSchema).strict();
-};
-/**
- * Generates a Zod schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be generated.
- * @param initial - A boolean indicating whether this is the initial call to the function.
- *                  This is used for handling nested schemas.
- * @returns - The generated Zod schema.
- */
-export const generateZodSchema = (jsonSchema) => {
-    switch (jsonSchema.type) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-            if (isEnumType(jsonSchema)) {
-                return createEnumSchema(jsonSchema);
-            }
-            else if (isStringType(jsonSchema)) {
-                return createZodStringSchema(jsonSchema);
-            }
-            else if (isNumberType(jsonSchema)) {
-                return createZodNumberSchema(jsonSchema);
-            }
-            else {
-                return createZodBooleanSchema(jsonSchema);
-            }
-        case 'object':
-            return createZodObjectSchema(jsonSchema);
-        case 'array':
-            return createZodArraySchema(jsonSchema);
-        case 'button':
-            return z.any();
-    }
-};
-/**
- * Generates a JSON schema for a number.
- *
- * @param value - The number for which the JSON schema should be generated.
- * @returns - The generated JSON schema for the number.
- */
-export const generateNumberSchema = () => {
-    // return { type: Number.isInteger(value) ? 'integer' : 'number' };
-    return { type: 'number' };
-};
-/**
- * Generates a JSON schema for a boolean.
- *
- * @param value - The boolean for which the JSON schema should be generated.
- * @returns - The generated JSON schema for the boolean.
- */
-export const genereateBooleanSchema = () => {
-    return { type: 'boolean' };
-};
-/**
- * Generates a JSON schema for a string.
- *
- * @param value - The string for which the JSON schema should be generated.
- * @returns - The generated JSON schema for the string.
- */
-export const generateStringSchema = (value) => {
-    const stringObject = { type: 'string' };
-    if (isISO8601(value)) {
-        stringObject.format = value.includes('T') ? 'date-time' : 'date';
-    }
-    if (isTime(value.split('+')[0], { mode: 'withSeconds' })) {
-        stringObject.format = 'time';
-    }
-    if (isEmail(value)) {
-        stringObject.format = 'email';
-    }
-    if (isUUID(value)) {
-        stringObject.format = 'uuid';
-    }
-    if (isIP(value, 4)) {
-        stringObject.format = 'ipv4';
-    }
-    if (isIP(value, 6)) {
-        stringObject.format = 'ipv6';
-    }
-    return stringObject;
-};
-/**
- * Generates a JSON schema for an enum.
- *
- * @param value - The enum for which the JSON schema should be generated.
- * @param type - The type of the enum.
- * @returns - The generated JSON schema for the enum.
- */
-export const generateEnumSchema = (value) => {
-    return { type: 'string', enum: value.map((item) => item.toString()) };
-};
-/**
- * Generates a JSON schema for an object.
- *
- * @param value - The object for which the JSON schema should be generated.
- * @returns - The generated JSON schema for the object.
- */
-export const generateObjectSchema = (value) => {
-    if (!Object.keys(value).length) {
-        return { type: 'object' };
-    }
-    const properties = {};
-    Object.entries(value).forEach(([key, value]) => {
-        const schema = generateSchema(value);
-        schema.key = key;
-        schema.description = schema.description || `Description for ${key}`;
-        schema.required = schema.required === undefined ? true : schema.required;
-        schema.readonly = schema.readonly || false;
-        properties[key] = schema;
-    });
-    return { type: 'object', properties };
-};
-/**
- * Generates a JSON schema for an object including up to two buttons.
- *
- * @param value - The object for which the JSON schema should be generated.
- * @param buttons - Array of min one button and up to two buttons to be included in the schema.
- * @returns - The generated JSON schema for the object.
- */
-export const generateObjectSchemaWithButtons = (value, buttons) => {
-    const baseSchema = {
-        ...generateObjectSchema(value),
-        buttons: buttons,
-    };
-    return baseSchema;
-};
-/**
- * Generates a JSON schema for an array.
- *
- * @param array - The array for which the JSON schema should be generated.
- * @returns - The generated JSON schema for the array.
- */
-export const generateArraySchema = (array) => {
-    if (array.length === 0) {
-        return { type: 'array' };
-    }
-    const allObjects = array.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item));
-    const allStrings = array.every((item) => typeof item === 'string');
-    const allNumbers = array.every((item) => typeof item === 'number');
-    if (allObjects) {
-        const schemaProperties = {};
-        const keyPresenceCount = {};
-        // Gather all keys and their presence count
-        array.forEach((obj) => {
-            Object.keys(obj).forEach((key) => {
-                keyPresenceCount[key] = (keyPresenceCount[key] || 0) + 1;
-            });
-        });
-        array.forEach((obj) => {
-            Object.entries(obj).forEach(([key, value]) => {
-                if (!schemaProperties[key]) {
-                    const isRequired = keyPresenceCount[key] === array.length;
-                    schemaProperties[key] = {
-                        ...generateSchema(value),
-                        required: isRequired,
-                        title: key,
-                        description: `Description for ${key}`,
-                        readonly: false,
-                    };
-                }
-            });
-        });
-        return {
-            type: 'array',
-            items: { type: 'object', properties: schemaProperties },
-        };
-    }
-    else if (allStrings) {
-        return { type: 'array', items: { type: 'string' } };
-    }
-    else if (allNumbers) {
-        return { type: 'array', items: { type: 'number' } };
-    }
-    else {
-        return { type: 'array', items: { type: 'boolean' } };
-    }
-};
-/**
- * Checks if the given JSON schema is of string type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of string type, false otherwise.
- */
-export const isStringType = (jsonSchema) => {
-    return jsonSchema.type === 'string' && !('enum' in jsonSchema);
-};
-/**
- * Checks if the given JSON schema is of number type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of number type, false otherwise.
- */
-export const isNumberType = (jsonSchema) => {
-    return jsonSchema.type === 'number' && !('enum' in jsonSchema);
-};
-/**
- * Checks if the given JSON schema is of boolean type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of boolean type, false otherwise.
- */
-export const isBooleanType = (jsonSchema) => {
-    return jsonSchema.type === 'boolean' && !('enum' in jsonSchema);
-};
-/**
- * Checks if the given JSON schema is of enum type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of enum type, false otherwise.
- */
-export const isEnumType = (jsonSchema) => {
-    return 'enum' in jsonSchema;
-};
-/**
- * Checks if the given JSON schema is of object type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of object type, false otherwise.
- */
-export const isObjectType = (jsonSchema) => {
-    return jsonSchema.type === 'object';
-};
-/**
- * Checks if the given JSON schema is of object type with buttons.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of object type with buttons, false otherwise.
- */
-export const isObjectTypeWithButtons = (jsonSchema) => {
-    return isObjectType(jsonSchema) && 'buttons' in jsonSchema;
-};
-/**
- * Checks if the given JSON schema is of array type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of array type, false otherwise.
- */
-export const isArrayType = (jsonSchema) => {
-    return jsonSchema.type === 'array';
-};
-/**
- * Checks if the given JSON schema is of button type.
- *
- * @param jsonSchema - The JSON schema to check.
- * @returns - True if the JSON schema is of button type, false otherwise.
- */
-export const isButtonType = (jsonSchema) => {
-    return jsonSchema.type === 'button';
-};
-/**
- * Checks if the given value is a JSON schema.
- *
- * @param value - The value to check.
- * @returns - True if the value is a JSON schema, false otherwise.
- */
-export const isJsonSchema = (value) => {
-    return isStringType(value) || isNumberType(value) || isBooleanType(value) || isEnumType(value) || isObjectType(value) || isArrayType(value);
-};
-/**
- * Checks if the given value is a JSON Primitive schema.
- *
- * @param value - The value to check.
- * @returns - True if the value is a JSON schema, false otherwise.
- */
-export const isPrimitiveType = (value) => {
-    return 'onGet' in value || 'onSet' in value;
-};
-/**
- * Creates a Zod string schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be created.
- * @returns - The created Zod string schema.
- */
-export const createZodStringSchema = (jsonSchema) => {
-    let schema = z.string();
-    if (jsonSchema.required)
-        schema = schema.nonempty('Required');
-    if (jsonSchema.minLength !== undefined)
-        schema = schema.min(jsonSchema.minLength);
-    if (jsonSchema.maxLength !== undefined)
-        schema = schema.max(jsonSchema.maxLength);
-    if (jsonSchema.format) {
-        switch (jsonSchema.format) {
-            case 'date-time':
-                schema = schema.refine((value) => isISO8601(value) && value.includes('T'), { message: 'Invalid date-time' });
-                break;
-            case 'date':
-                schema = schema.refine((value) => isISO8601(value), { message: 'Invalid date' });
-                break;
-            case 'time':
-                schema = schema.refine((value) => isTime(value.split('+')[0], { mode: 'withSeconds' }), { message: 'Invalid time' });
-                break;
-            case 'email':
-                schema = schema.refine((value) => isEmail(value), { message: 'Invalid email' });
-                break;
-            case 'uuid':
-                schema = schema.refine((value) => isUUID(value), { message: 'Invalid uuid' });
-                break;
-            case 'ipv4':
-                schema = schema.refine((value) => isIP(value, 4), { message: 'Invalid ipv4' });
-                break;
-            case 'ipv6':
-                schema = schema.refine((value) => isIP(value, 6), { message: 'Invalid ipv6' });
-                break;
-            // case 'password':
-            //   schema = schema.refine((value) => isStrongPassword(value), { message: 'Invalid password' });
-            //   break;
-            // case 'qrCode':
-            //   schema = schema.refine((value) => isBase64(value), { message: 'Invalid qrCode' });
-            //   break;
-        }
-    }
-    return jsonSchema.required ? schema : schema.optional();
-};
-/**
- * Creates a Zod number schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be created.
- * @returns - The created Zod number schema.
- */
-export const createZodNumberSchema = (jsonSchema) => {
-    let schema = z.number();
-    if (jsonSchema.minimum !== undefined)
-        schema = schema.min(jsonSchema.minimum);
-    if (jsonSchema.maximum !== undefined)
-        schema = schema.max(jsonSchema.maximum);
-    if (jsonSchema.required)
-        schema = schema.refine((value) => value !== undefined && typeof value === 'number', { message: 'Required' });
-    return jsonSchema.required ? schema : schema.optional();
-};
-/**
- * Creates a Zod boolean schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be created.
- * @returns - The created Zod boolean schema.
- */
-export const createZodBooleanSchema = (jsonSchema) => {
-    const schema = z.boolean();
-    return jsonSchema.required ? schema : schema.optional();
-};
-/**
- * Creates a Zod union schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be created.
- * @returns - The created Zod union schema.
- */
-export const createEnumSchema = (jsonSchema) => {
-    const enumValues = jsonSchema.enum.map((item) => (jsonSchema.required ? z.literal(item) : z.literal(item).optional()));
-    const schema = jsonSchema.required
-        ? z.union(enumValues)
-        : z.any().transform((val) => (!val || val === '' || !jsonSchema.enum.some((v) => v === val) ? undefined : val));
-    if (jsonSchema.multiple) {
-        return jsonSchema.required ? schema.array() : schema.array().optional();
-    }
-    return jsonSchema.required ? schema : schema.optional();
-};
-/**
- * Creates a Zod object schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be created.
- * @returns - The created Zod object schema.
- */
-export const createZodObjectSchema = (jsonSchema) => {
-    let schema;
-    if (jsonSchema.properties) {
-        const zodObjectProperties = Object.entries(jsonSchema.properties).reduce((acc, [key, value]) => {
-            acc[key] = generateZodSchema(value);
-            return acc;
-        }, {});
-        schema = z.object(zodObjectProperties).strict();
-    }
-    else {
-        schema = z.record(z.any());
-    }
-    return jsonSchema.required ? schema : schema.optional();
-};
-/**
- * Creates a Zod array schema from a given JSON schema.
- *
- * @param jsonSchema - The JSON schema from which the Zod schema should be created.
- * @returns - The created Zod array schema.
- */
-export const createZodArraySchema = (jsonSchema) => {
-    let schema;
-    if (jsonSchema.items) {
-        schema = generateZodSchema(jsonSchema.items).array();
-    }
-    else {
-        schema = z.any().array();
-    }
-    return jsonSchema.required ? schema : schema.optional();
-};
-//# sourceMappingURL=schema.js.map