@wildo-ai/zod-decorators 1.0.0

package/dist/esm/zod-utils.shared.js

@@ -0,0 +1,2647 @@
+import { z } from 'zod';
+import { ForeignKeyDisplayMode, FieldSchemaType, FormFieldComponent, RangeType, SCHEMA_METADATA, ZodDecorator } from './zod-decorators.types.js';
+import { z_range } from './zod-range.js';
+import { addDecorators, getMetadataRecursive } from './zod.module-override.js';
+// Type guard to check if a schema has Zod v4 internals
+// Zod v4 can have two structures:
+// - Legacy: schema._zod.def.type (older Zod v4 builds)
+// - Current: schema.def.type with schema.type at root (newer Zod v4 builds)
+export function hasZodInternals(schema) {
+    if (!schema || typeof schema !== 'object')
+        return false;
+    // First check for legacy structure: schema._zod.def.type
+    if ('_zod' in schema) {
+        const schemaObj = schema;
+        const zodProp = schemaObj._zod;
+        if (typeof zodProp === 'object' && zodProp !== null && 'def' in zodProp) {
+            const zodObj = zodProp;
+            const defProp = zodObj.def;
+            if (typeof defProp === 'object' && defProp !== null && 'type' in defProp) {
+                return true;
+            }
+        }
+    }
+    // Check for current structure: schema.def.type (with schema.type at root)
+    if ('def' in schema) {
+        const schemaObj = schema;
+        const defProp = schemaObj.def;
+        if (typeof defProp === 'object' && defProp !== null && 'type' in defProp) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a schema has a specific decorator.
+ * Note: getCustomFieldMetadata already handles recursive unwrapping for all wrapper types
+ * including pipe (from refine/superRefine), optional, nullable, default, etc.
+ */
+export function hasDecorator(schema, decorator) {
+    const metadata = getCustomFieldMetadata(schema);
+    const value = metadata[decorator];
+    // Handle different value types properly
+    if (value !== undefined) {
+        // For strings: non-empty = has decorator, empty = no decorator (defensive guard)
+        if (typeof value === 'string') {
+            return value.length > 0;
+        }
+        // For numbers: any number including 0 = has decorator
+        if (typeof value === 'number') {
+            return true;
+        }
+        // For booleans: true = has decorator, false = no decorator
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'object' && value === null) {
+            return false;
+        }
+        // For other types: truthy = has decorator
+        return Boolean(value);
+    }
+    return false;
+}
+// =============================================================================
+// SCHEMA UNWRAPPING
+// =============================================================================
+/**
+ * Unwrap optional, nullable, default, and other wrapper schemas
+ * to get the underlying base schema
+ */
+export function unwrapSchema(schema) {
+    const type = getZodType(schema);
+    switch (type) {
+        case 'optional':
+        case 'nullable': {
+            const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+            return innerSchema ? unwrapSchema(innerSchema) : schema;
+        }
+        case 'default': {
+            const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+            return innerSchema ? unwrapSchema(innerSchema) : schema;
+        }
+        case 'pipe': {
+            const inSchema = getZodDefSchemaProperty(schema, 'in');
+            return inSchema ? unwrapSchema(inSchema) : schema;
+        }
+        case 'readonly': {
+            const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+            return innerSchema ? unwrapSchema(innerSchema) : schema;
+        }
+        case 'catch': {
+            const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+            return innerSchema ? unwrapSchema(innerSchema) : schema;
+        }
+        default:
+            return schema;
+    }
+}
+// =============================================================================
+// ZOD TYPE DETECTION HELPERS
+//
+// Helper function to safely get the type from a Zod v4 schema
+// Supports both structures:
+// - Legacy: schema._zod.def.type
+// - Current: schema.def.type (or schema.type at root)
+// Type values are lowercase strings like "object", "array", "string", etc.
+// =============================================================================
+export function getZodType(schema) {
+    // Guard against null/undefined schemas
+    if (!schema || typeof schema !== 'object') {
+        return undefined;
+    }
+    const def = getZodDef(schema);
+    if (def?.type)
+        return def.type;
+    // Fallback: check schema.type at root level
+    if ('type' in schema && typeof schema.type === 'string') {
+        return schema.type;
+    }
+    return undefined;
+}
+/**
+ * Type guard to check if a schema has a specific type
+ * Uses Zod v4's type system where types are lowercase strings
+ */
+export function hasZodType(schema, type) {
+    return getZodType(schema) === type;
+}
+export function isZodObject(schema) {
+    return hasZodType(schema, 'object');
+}
+export function isZodArray(schema) {
+    return hasZodType(schema, 'array');
+}
+export function isZodOptional(schema) {
+    return hasZodType(schema, 'optional');
+}
+export function isZodNullable(schema) {
+    return hasZodType(schema, 'nullable');
+}
+export function isZodDefault(schema) {
+    return hasZodType(schema, 'default');
+}
+export function isZodUnion(schema) {
+    return hasZodType(schema, 'union');
+}
+export function isZodIntersection(schema) {
+    return hasZodType(schema, 'intersection');
+}
+export function isZodLiteral(schema) {
+    return hasZodType(schema, 'literal');
+}
+export function isZodLazy(schema) {
+    return hasZodType(schema, 'lazy');
+}
+export function isZodTuple(schema) {
+    return hasZodType(schema, 'tuple');
+}
+export function isZodRecord(schema) {
+    return hasZodType(schema, 'record');
+}
+export function isZodSet(schema) {
+    return hasZodType(schema, 'set');
+}
+export function isZodPipe(schema) {
+    return hasZodType(schema, 'pipe');
+}
+export function isZodTransform(schema) {
+    const type = getZodType(schema);
+    if (type === 'transform')
+        return true;
+    // In Zod v4, `.transform()` returns a pipe schema whose output is a transform schema.
+    if (type === 'pipe') {
+        const outSchema = getZodDefSchemaProperty(schema, 'out');
+        return outSchema ? getZodType(outSchema) === 'transform' : false;
+    }
+    return false;
+}
+export function isZodCustom(schema) {
+    return hasZodType(schema, 'custom');
+}
+export function isArray(value) {
+    return Array.isArray(value);
+}
+export function isZodTypeAny(value) {
+    return value !== null &&
+        value !== undefined &&
+        typeof value === 'object' &&
+        hasZodInternals(value);
+}
+/**
+ * Check if a union is discriminated (has discriminator property)
+ * In Zod v4, discriminated unions have type: "union" with a discriminator property
+ */
+export function isDiscriminatedUnion(schema) {
+    if (!isZodUnion(schema))
+        return false;
+    return getZodDefStringProperty(schema, 'discriminator') !== undefined;
+}
+/**
+ * Check if a schema is optional (can be undefined)
+ */
+export function isOptional(schema) {
+    const type = getZodType(schema);
+    if (type === 'optional')
+        return true;
+    if (type === 'default')
+        return true; // Has default, so not required from user
+    if (type === 'nullable' || type === 'pipe' || type === 'readonly' || type === 'catch') {
+        const innerSchema = getZodDefSchemaProperty(schema, 'innerType') ?? getZodDefSchemaProperty(schema, 'in');
+        return innerSchema ? isOptional(innerSchema) : false;
+    }
+    return false;
+}
+/**
+ * Check if a schema has refine/superRefine transformations
+ * This triggers onChange validation mode
+ */
+export function hasRefine(schema) {
+    const type = getZodType(schema);
+    // Check for pipe with refinement effect
+    if (type === 'pipe') {
+        const outSchema = getZodDefSchemaProperty(schema, 'out');
+        if (outSchema) {
+            const outType = getZodType(outSchema);
+            if (outType === 'custom') {
+                // Custom type in pipe output usually indicates refinement
+                return true;
+            }
+        }
+        const inSchema = getZodDefSchemaProperty(schema, 'in');
+        return inSchema ? hasRefine(inSchema) : false;
+    }
+    // Check for custom type (refine creates these)
+    if (type === 'custom') {
+        return true;
+    }
+    // Unwrap wrappers and check inner
+    if (type === 'optional' || type === 'nullable' || type === 'default' || type === 'readonly' || type === 'catch') {
+        const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+        return innerSchema ? hasRefine(innerSchema) : false;
+    }
+    return false;
+}
+// =============================================================================
+// SCHEMA TYPE DETECTION
+// =============================================================================
+/**
+ * Get the schema type category for component selection.
+ *
+ * Important: RANGE schemas (created by z_range()) are detected by their
+ * SCHEMA_METADATA.rangeConfig before checking for object type. This allows range schemas
+ * to be rendered with appropriate range components instead of as composite objects.
+ */
+export function getSchemaType(schema) {
+    // Check for range schema FIRST (before object check)
+    // Range schemas are z.object({from, to}) with SCHEMA_METADATA.rangeConfig
+    // isRangeSchema and getRangeType now handle unwrapping internally
+    if (isRangeSchema(schema)) {
+        // Return specialized range type based on the range's value type
+        const rangeType = getRangeType(schema);
+        switch (rangeType) {
+            case RangeType.NUMBER:
+                return FieldSchemaType.RANGE_NUMBER;
+            case RangeType.DATE:
+                return FieldSchemaType.RANGE_DATE;
+            case RangeType.DATETIME:
+                return FieldSchemaType.RANGE_DATETIME;
+            case RangeType.TIME:
+                return FieldSchemaType.RANGE_TIME;
+            case RangeType.BIGDECIMAL:
+                return FieldSchemaType.RANGE_BIGDECIMAL;
+            case RangeType.MONEY:
+                return FieldSchemaType.RANGE_MONEY;
+            default:
+                // z_range() only accepts valid RangeType values, so this should never happen
+                return FieldSchemaType.UNKNOWN;
+        }
+    }
+    // Check for money schemas (created by z_money())
+    // isMoneySchema now handles unwrapping internally
+    if (isMoneySchema(schema)) {
+        return FieldSchemaType.MONEY;
+    }
+    // Check for bigdecimal schemas (created by z_bigdecimal())
+    // isBigDecimalSchema now handles unwrapping internally
+    if (isBigDecimalSchema(schema)) {
+        return FieldSchemaType.BIGDECIMAL;
+    }
+    // Check for code schemas (created by z_code())
+    // isCodeSchema now handles unwrapping internally
+    if (isCodeSchema(schema)) {
+        return FieldSchemaType.CODE;
+    }
+    // Check for file schemas (created by z_file())
+    // isFileSchema now handles unwrapping internally
+    if (isFileSchema(schema)) {
+        return FieldSchemaType.FILE;
+    }
+    // Check for duration schemas (created by z_duration())
+    if (isDurationSchema(schema)) {
+        return FieldSchemaType.DURATION;
+    }
+    // Check for phone schemas (created by z_phone())
+    if (isPhoneSchema(schema)) {
+        return FieldSchemaType.PHONE;
+    }
+    // Check for versioned foreign key schemas (created by z_foreignKeyVersioned())
+    if (isVersionedForeignKeySchema(schema)) {
+        return FieldSchemaType.VERSIONED_FOREIGN_KEY;
+    }
+    // Check for versioned object schemas (created by versioned())
+    if (isVersionedObjectSchema(schema)) {
+        return FieldSchemaType.VERSIONED_OBJECT;
+    }
+    const unwrapped = unwrapSchema(schema);
+    const type = getZodType(unwrapped);
+    switch (type) {
+        case 'string': {
+            // Check for datetime/time formats (z.iso.datetime(), z.iso.time())
+            const format = getStringFormat(unwrapped);
+            if (format === 'datetime')
+                return FieldSchemaType.DATETIME;
+            if (format === 'time')
+                return FieldSchemaType.TIME;
+            return FieldSchemaType.STRING;
+        }
+        case 'number':
+        case 'int': return FieldSchemaType.NUMBER;
+        case 'bigint': return FieldSchemaType.BIGINT;
+        case 'boolean': return FieldSchemaType.BOOLEAN;
+        case 'enum':
+            return FieldSchemaType.ENUM;
+        case 'literal': {
+            // In Zod v4, literal values are stored in def.values as an array
+            const values = getZodDefProperty(unwrapped, 'values');
+            const literalValue = values?.[0];
+            if (literalValue === null || literalValue === undefined) {
+                return FieldSchemaType.UNKNOWN;
+            }
+            // Infer type based on the value type
+            switch (typeof literalValue) {
+                case 'string':
+                    // String literals are treated as single-value enums (for select fields)
+                    return FieldSchemaType.ENUM;
+                case 'number':
+                case 'bigint':
+                    return FieldSchemaType.NUMBER;
+                case 'boolean':
+                    return FieldSchemaType.BOOLEAN;
+                default:
+                    return FieldSchemaType.UNKNOWN;
+            }
+        }
+        case 'date': return FieldSchemaType.DATE;
+        case 'object': return FieldSchemaType.OBJECT;
+        case 'array': return FieldSchemaType.ARRAY;
+        case 'set': return FieldSchemaType.SET;
+        case 'tuple': return FieldSchemaType.TUPLE;
+        case 'record': return FieldSchemaType.RECORD;
+        case 'map': return FieldSchemaType.MAP;
+        case 'union': {
+            // For unions, try to infer type from options
+            // If all options are enums, treat as ENUM (combined values)
+            // Otherwise, use the type of the first option
+            const options = getZodDefArrayProperty(unwrapped, 'options') ?? [];
+            if (options.length === 0)
+                return FieldSchemaType.UNKNOWN;
+            // Check if all options are enums or string literals (treat as combined enum)
+            const allEnumLike = options.every((opt) => {
+                if (!isZodTypeAny(opt))
+                    return false;
+                const optType = getZodType(opt);
+                return optType === 'enum' || optType === 'literal';
+            });
+            if (allEnumLike) {
+                return FieldSchemaType.ENUM;
+            }
+            // Otherwise, infer from the first option
+            const firstOption = options[0];
+            if (isZodTypeAny(firstOption)) {
+                return getSchemaType(firstOption);
+            }
+            return FieldSchemaType.UNKNOWN;
+        }
+        default: return FieldSchemaType.UNKNOWN;
+    }
+}
+// =============================================================================
+// ZOD HELPER GETTER
+// =============================================================================
+/**
+ * Get the type string from a Zod v4 schema's internal structure.
+ * Returns undefined if schema is not a valid Zod 4 schema.
+ */
+function getZodTypeInternal(schema) {
+    if (!schema || typeof schema !== 'object')
+        return undefined;
+    const zodProp = schema._zod;
+    if (!zodProp || typeof zodProp !== 'object')
+        return undefined;
+    const def = zodProp.def;
+    if (!def || typeof def !== 'object')
+        return undefined;
+    return typeof def.type === 'string' ? def.type : undefined;
+}
+/**
+ * Get the shape of a Zod object schema.
+ *
+ * IMPORTANT: This function only returns valid Zod schema instances, not definitions.
+ * In Zod 4, `def.shape` contains JSON-serializable definitions, not schema instances
+ * with methods like safeParse.
+ *
+ * Prefer using getObjectShape() which handles unwrapping and validation.
+ */
+export function getZodObjectShape(schema) {
+    if (!isZodObject(schema)) {
+        return {};
+    }
+    // Use the improved getObjectShape which validates schema instances
+    const shape = getObjectShape(schema);
+    return shape ?? {};
+}
+export function getZodDef(schema) {
+    if (!hasZodInternals(schema))
+        return undefined;
+    // First check legacy structure: schema._zod.def
+    if ('_zod' in schema) {
+        const zodProp = schema._zod;
+        if (typeof zodProp === 'object' && zodProp !== null && 'def' in zodProp) {
+            return zodProp.def;
+        }
+    }
+    // Use current structure: schema.def directly
+    return schema.def;
+}
+export function getZodDefSchemaProperty(schema, property) {
+    const def = getZodDef(schema);
+    const value = def?.[property];
+    return isZodTypeAny(value) ? value : undefined;
+}
+export function getZodDefArrayProperty(schema, property) {
+    const def = getZodDef(schema);
+    const value = def?.[property];
+    return isArray(value) ? value : undefined;
+}
+export function getZodDefStringProperty(schema, property) {
+    const def = getZodDef(schema);
+    const value = def?.[property];
+    return typeof value === 'string' ? value : undefined;
+}
+export function getZodDefFunctionProperty(schema, property) {
+    const def = getZodDef(schema);
+    const value = def?.[property];
+    if (typeof value === 'function') {
+        return value;
+    }
+    return undefined;
+}
+export function getZodDefProperty(schema, property) {
+    const def = getZodDef(schema);
+    return def?.[property];
+}
+/**
+ * Get the inner schema from a pipe type (for transforms/refinements)
+ * In Zod v4, pipe types have def.in and def.out
+ * For most cases, we want def.in (the input schema before transformation)
+ */
+export function getPipeInputSchema(schema) {
+    if (!isZodPipe(schema))
+        return undefined;
+    return getZodDefSchemaProperty(schema, 'in');
+}
+/**
+ * Get all custom field metadata from a schema, traversing through wrapper types
+ * (optional, nullable, default, pipe, readonly, catch, array, effects).
+ * Always returns an object (never undefined) — empty `{}` if no metadata found.
+ *
+ * Delegates to the unified getMetadataRecursive from zod.module-override.ts.
+ */
+export function getCustomFieldMetadata(schema) {
+    if (!schema) {
+        return {};
+    }
+    return getMetadataRecursive(schema) ?? {};
+}
+// =============================================================================
+// GENERIC {primitive}UI CROSS-CUTTING READERS
+// =============================================================================
+/**
+ * All `*_UI` decorator keys. Used by cross-cutting readers to extract
+ * base params (`edit`, `display`) from whichever primitive UI decorator
+ * is present on a schema, without needing to know the concrete primitive.
+ */
+const UI_DECORATOR_KEYS = [
+    ZodDecorator.BOOLEAN_UI, ZodDecorator.STRING_UI, ZodDecorator.NUMBER_UI,
+    ZodDecorator.ENUM_UI, ZodDecorator.DATE_UI, ZodDecorator.DATETIME_UI,
+    ZodDecorator.TIME_UI, ZodDecorator.MONEY_UI, ZodDecorator.CODE_UI,
+    ZodDecorator.FILE_UI, ZodDecorator.DURATION_UI, ZodDecorator.PHONE_UI,
+    ZodDecorator.BIGDECIMAL_UI, ZodDecorator.FOREIGN_KEY_UI,
+    ZodDecorator.ARRAY_UI, ZodDecorator.OBJECT_UI,
+];
+/**
+ * Extract the edit-context base params from whichever `{primitive}UI` decorator
+ * is present on the schema. Works generically because all `*UIEditParams`
+ * extend `PrimitiveUIBaseEditParams`.
+ *
+ * Use this for cross-cutting concerns (validationMode, autosave, tooltip, etc.)
+ * where the consumer doesn't know the concrete primitive type.
+ */
+export function getFieldUIEditConfig(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    for (const key of UI_DECORATOR_KEYS) {
+        const params = metadata[key];
+        if (params && typeof params === 'object' && 'edit' in params) {
+            return params.edit;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract the display-context base params from whichever `{primitive}UI` decorator
+ * is present on the schema. Works generically because all `*UIDisplayParams`
+ * extend `PrimitiveUIBaseDisplayParams`.
+ *
+ * Use this for cross-cutting concerns (tooltip, inlineEditable, etc.)
+ * where the consumer doesn't know the concrete primitive type.
+ */
+export function getFieldUIDisplayConfig(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    for (const key of UI_DECORATOR_KEYS) {
+        const params = metadata[key];
+        if (params && typeof params === 'object' && 'display' in params) {
+            return params.display;
+        }
+    }
+    return undefined;
+}
+// =============================================================================
+// TOOLTIP DECORATOR UTILITIES
+// =============================================================================
+/**
+ * Check if a field should show a tooltip in display mode.
+ * Reads from `{primitive}UI.display.tooltip` (boolean flag).
+ * The actual tooltip text comes from the i18n label system, NOT from the decorator.
+ */
+export function hasTooltipForDisplay(schema) {
+    return getFieldUIDisplayConfig(schema)?.tooltip === true;
+}
+/**
+ * Check if a field should show a tooltip in edit mode.
+ * Reads from `{primitive}UI.edit.tooltip` (boolean flag).
+ * The actual tooltip text comes from the i18n label system, NOT from the decorator.
+ */
+export function hasTooltipForEdit(schema) {
+    return getFieldUIEditConfig(schema)?.tooltip === true;
+}
+/**
+ * Check if a field is marked as draft-relaxed (validation is relaxed in draft mode).
+ *
+ * @param schema - Zod schema to check
+ * @returns true if the field is draft-relaxed
+ *
+ * @example
+ * if (isDraftRelaxed(schema) && isDraftMode) {
+ *   // Skip strict validation for this field
+ * }
+ */
+export function isDraftRelaxed(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    return metadata[ZodDecorator.IS_DRAFT_RELAXED] === true;
+}
+/**
+ * FIX-P5-H1: Get showWhen parameters from a field schema.
+ * Returns the conditional visibility configuration if present.
+ *
+ * @param schema - The field schema to get showWhen params from
+ * @returns ShowWhenParams if decorator was applied, undefined otherwise
+ *
+ * @example
+ * const showWhenParams = getShowWhenParams(fieldSchema);
+ * if (showWhenParams) {
+ *   // Evaluate visibility based on conditions
+ *   const isVisible = evaluateShowWhenConditions(showWhenParams, formValues);
+ * }
+ */
+export function getShowWhenParams(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    return metadata[ZodDecorator.SHOW_WHEN];
+}
+/**
+ * Get string format from schema checks (email, url, etc.)
+ */
+export function getStringFormat(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'string') {
+        return null;
+    }
+    const checks = getZodDefArrayProperty(unwrapped, 'checks') ?? [];
+    for (const check of checks) {
+        if (typeof check !== 'object' || check === null)
+            continue;
+        const kind = check.kind;
+        switch (kind) {
+            case 'email': return 'email';
+            case 'url': return 'url';
+            case 'uuid': return 'uuid';
+            case 'cuid': return 'cuid';
+            case 'cuid2': return 'cuid2';
+            case 'ulid': return 'ulid';
+            case 'regex': return 'regex';
+            case 'datetime': return 'datetime';
+            case 'time': return 'time';
+            case 'ip': return 'ip';
+        }
+    }
+    return null;
+}
+/**
+ * Get min/max length constraints from string schema
+ */
+export function getStringConstraints(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'string') {
+        return {};
+    }
+    const checks = getZodDefArrayProperty(unwrapped, 'checks') ?? [];
+    const result = {};
+    for (const check of checks) {
+        if (typeof check !== 'object' || check === null)
+            continue;
+        const kind = check.kind;
+        const value = check.value;
+        if (typeof value !== 'number')
+            continue;
+        if (kind === 'min') {
+            result.minLength = value;
+        }
+        if (kind === 'max') {
+            result.maxLength = value;
+        }
+        if (kind === 'length') {
+            result.minLength = value;
+            result.maxLength = value;
+        }
+    }
+    return result;
+}
+// ------------------------------------------------------------
+// NUMBER SCHEMA UTILITIES
+// ------------------------------------------------------------
+/**
+ * Get min/max value constraints from number schema
+ */
+export function getNumberConstraints(schema) {
+    const unwrapped = unwrapSchema(schema);
+    const type = getZodType(unwrapped);
+    if (type !== 'number' && type !== 'int') {
+        return {};
+    }
+    const checks = getZodDefArrayProperty(unwrapped, 'checks') ?? [];
+    const result = {};
+    // int type in Zod v4
+    if (type === 'int') {
+        result.isInt = true;
+        result.step = 1;
+    }
+    for (const check of checks) {
+        if (typeof check !== 'object' || check === null)
+            continue;
+        const kind = check.kind;
+        const value = check.value;
+        if (kind === 'min' && typeof value === 'number') {
+            result.min = value;
+        }
+        if (kind === 'max' && typeof value === 'number') {
+            result.max = value;
+        }
+        if (kind === 'int') {
+            result.isInt = true;
+            result.step = 1;
+        }
+        if (kind === 'multipleOf' && typeof value === 'number') {
+            result.step = value;
+        }
+    }
+    return result;
+}
+// ------------------------------------------------------------
+// ENUM SCHEMA UTILITIES
+// ------------------------------------------------------------
+/**
+ * Extract enum values from z.enum (Zod 4)
+ * In Zod 4, both z.enum() and z.enum() create schemas with type 'enum'
+ * - z.enum(['a', 'b', 'c']) - def.entries is an object map (e.g. { a: 'a', b: 'b' })
+ * - z.enum(TypeScriptEnum) / z.enum(TypeScriptEnum) - def.entries is the enum object map
+ */
+export function getEnumValues(schema) {
+    const unwrapped = unwrapSchema(schema);
+    const type = getZodType(unwrapped);
+    // Handle string literal types (z.literal("value")) - return single value as array
+    // Only string literals are treated as enums (for select fields)
+    // In Zod v4, literal values are stored in def.values as an array
+    if (type === 'literal') {
+        const values = getZodDefProperty(unwrapped, 'values');
+        const literalValue = values?.[0];
+        // Only string literals are valid enum values
+        if (typeof literalValue === 'string') {
+            return [literalValue];
+        }
+        return [];
+    }
+    // Handle union types - combine enum values from all options
+    // This handles cases like z.union([z.enum(A), z.enum(B)])
+    if (type === 'union') {
+        const options = getZodDefArrayProperty(unwrapped, 'options') ?? [];
+        const allValues = [];
+        const seenValues = new Set();
+        for (const opt of options) {
+            if (isZodTypeAny(opt)) {
+                const optValues = getEnumValues(opt);
+                for (const val of optValues) {
+                    if (!seenValues.has(val)) {
+                        seenValues.add(val);
+                        allValues.push(val);
+                    }
+                }
+            }
+        }
+        return allValues;
+    }
+    if (type !== 'enum') {
+        return [];
+    }
+    // In Zod v4.1.x, enum values are stored in def.entries (object map).
+    const entries = getZodDefProperty(unwrapped, 'entries');
+    if (!entries || typeof entries !== 'object')
+        return [];
+    const values = [];
+    for (const key of Object.keys(entries)) {
+        const value = entries[key];
+        // For numeric enums, TypeScript creates reverse mappings: entries["0"] = "A", entries["A"] = 0
+        if (typeof value === 'string') {
+            // Skip reverse mapping values where key is numeric (e.g., "0" -> "A")
+            if (!Number.isNaN(Number(key)))
+                continue;
+            values.push(value);
+        }
+        else if (typeof value === 'number') {
+            values.push(String(value));
+        }
+    }
+    return values;
+}
+// ------------------------------------------------------------
+// OBJECT SCHEMA UTILITIES
+// ------------------------------------------------------------
+/**
+ * Validates that an object contains actual Zod schema instances (not definitions).
+ * A valid Zod 4 schema instance has either:
+ * - _zod property (internal structure)
+ * - safeParse method (public API)
+ */
+function isValidSchemaShape(shape) {
+    // Skip $-prefixed keys (Zod v4 internals like $id, $brand) when picking
+    // the representative entry to validate — their values are primitives, not schemas.
+    const keys = Object.keys(shape);
+    const firstUserKey = keys.find(k => !k.startsWith('$'));
+    if (!firstUserKey)
+        return keys.length === 0; // Only internal keys or empty → valid if empty
+    const firstValue = shape[firstUserKey];
+    if (!firstValue || typeof firstValue !== 'object')
+        return false;
+    const hasZodInternals = '_zod' in firstValue;
+    const hasSafeParse = 'safeParse' in firstValue && typeof firstValue.safeParse === 'function';
+    return hasZodInternals || hasSafeParse;
+}
+/**
+ * Strips Zod v4 internal properties (e.g. $id, $brand) from a shape record.
+ * These are runtime metadata, not user-defined fields, and leak into
+ * Object.entries() when iterating the raw .shape object.
+ *
+ * Uses warn-once to avoid log flooding (same pattern as _warnedStorageProviders in zod-file.ts).
+ * This is a low-level shared lib used by both frontend and backend — console.warn
+ * is the only available logging primitive here (no injected logger).
+ */
+const _warnedInternalKeys = new Set();
+function stripZodInternalKeys(shape) {
+    const keys = Object.keys(shape);
+    const internalKeys = keys.filter(k => k.startsWith('$'));
+    if (internalKeys.length === 0)
+        return shape;
+    const warnKey = internalKeys.sort().join(',');
+    if (!_warnedInternalKeys.has(warnKey)) {
+        _warnedInternalKeys.add(warnKey);
+        console.warn(`[getObjectShape] Stripping Zod internal keys from shape: [${internalKeys.join(', ')}]. ` +
+            `If a legitimate user-defined field starts with '$', this filter is incorrect. ` +
+            `Stripped keys had values: ${internalKeys.map(k => `${k}=${typeof shape[k] === 'object' ? 'object' : shape[k]}`).join(', ')}`);
+    }
+    const clean = {};
+    for (const k of keys) {
+        if (!k.startsWith('$'))
+            clean[k] = shape[k];
+    }
+    return clean;
+}
+/**
+ * Get the shape of an object schema.
+ *
+ * IMPORTANT: In Zod 4, `def.shape` contains schema DEFINITIONS (JSON-serializable),
+ * NOT schema instances with methods. This function validates that returned shapes
+ * contain actual Zod schema instances.
+ *
+ * If the schema is wrapped (e.g., with .default()), it will be unwrapped first.
+ */
+export function getObjectShape(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'object') {
+        return null;
+    }
+    // Try public .shape property - this should contain actual schema instances
+    if ('shape' in unwrapped && typeof unwrapped.shape === 'object' && unwrapped.shape !== null) {
+        const shape = unwrapped.shape;
+        // Validate that the shape contains actual Zod schemas, not definitions
+        if (isValidSchemaShape(shape)) {
+            return stripZodInternalKeys(shape);
+        }
+        // Shape exists but contains corrupted definitions - will be caught by fail-fast below
+    }
+    // Try accessing shape through _zod internals (Zod 4 structure)
+    // In some Zod 4 versions, _zod.def.shape might still contain actual schema instances
+    if ('_zod' in unwrapped) {
+        const zodInternals = unwrapped._zod;
+        if (zodInternals?.def?.shape && typeof zodInternals.def.shape === 'object') {
+            const shape = zodInternals.def.shape;
+            // Validate that it contains actual schema instances
+            if (isValidSchemaShape(shape)) {
+                return stripZodInternalKeys(shape);
+            }
+        }
+    }
+    // FAIL-FAST: Do NOT return corrupted schemas silently
+    // Throw with diagnostic info to identify the corruption source
+    if ('shape' in unwrapped && typeof unwrapped.shape === 'object' && unwrapped.shape !== null) {
+        const shape = unwrapped.shape;
+        const firstKey = Object.keys(shape)[0];
+        const firstValue = shape[firstKey];
+        const firstValueKeys = firstValue && typeof firstValue === 'object'
+            ? Object.keys(firstValue).slice(0, 10).join(', ')
+            : 'N/A';
+        throw new Error(`[getObjectShape] Schema shape contains corrupted objects (not valid Zod schemas). ` +
+            `First field "${firstKey}" is missing safeParse method. ` +
+            `Keys on corrupted object: [${firstValueKeys}]. ` +
+            `This usually means the schema was JSON.stringify/parsed or incorrectly cloned.`);
+    }
+    // Also check _zod.def.shape - same fail-fast approach
+    if ('_zod' in unwrapped) {
+        const zodInternals = unwrapped._zod;
+        if (zodInternals?.def?.shape && typeof zodInternals.def.shape === 'object') {
+            const shape = zodInternals.def.shape;
+            const firstKey = Object.keys(shape)[0];
+            const firstValue = shape[firstKey];
+            const firstValueKeys = firstValue && typeof firstValue === 'object'
+                ? Object.keys(firstValue).slice(0, 10).join(', ')
+                : 'N/A';
+            throw new Error(`[getObjectShape] _zod.def.shape contains corrupted objects (not valid Zod schemas). ` +
+                `First field "${firstKey}" is missing safeParse. ` +
+                `Keys: [${firstValueKeys}]. ` +
+                `This usually means the schema was JSON.stringify/parsed or incorrectly cloned.`);
+        }
+    }
+    return null;
+}
+/**
+ * Get the keys of an object schema shape
+ */
+export function getObjectKeys(schema) {
+    const shape = getObjectShape(schema);
+    return shape ? Object.keys(shape) : [];
+}
+/**
+ * Extract all flattened paths from a Zod schema.
+ * Recursively traverses object schemas to build dot-notation paths (e.g., 'field.nestedField').
+ * Handles optional, nullable, array, and union types.
+ *
+ * @param zodSchema - The Zod schema to extract paths from
+ * @param prefix - Current path prefix (used for recursion)
+ * @param schemaDepthCounters - Map to track depth per schema instance (prevents infinite recursion)
+ * @param maxDepthPerSchema - Maximum depth to traverse per schema instance (default: 3)
+ * @returns Array of flattened dot-notation paths
+ */
+export function extractFlattenedPathsFromZodSchema(zodSchema, prefix = '', schemaDepthCounters = new Map(), maxDepthPerSchema = 3) {
+    const paths = [];
+    if (!zodSchema) {
+        return paths;
+    }
+    // Check depth for this specific schema instance to prevent infinite recursion
+    const currentDepth = schemaDepthCounters.get(zodSchema) || 0;
+    if (currentDepth >= maxDepthPerSchema) {
+        return paths;
+    }
+    // Increment depth counter for this schema
+    schemaDepthCounters.set(zodSchema, currentDepth + 1);
+    try {
+        const zodType = getZodType(zodSchema);
+        switch (zodType) {
+            case 'object': {
+                // Extract shape from zod object using public API
+                const shape = getZodObjectShape(zodSchema);
+                Object.entries(shape).forEach(([fieldName, fieldSchema]) => {
+                    const currentPath = prefix ? `${prefix}.${fieldName}` : fieldName;
+                    // Add the current path
+                    paths.push(currentPath);
+                    // Recursively process nested objects
+                    const nestedPaths = extractFlattenedPathsFromZodSchema(fieldSchema, currentPath, new Map(schemaDepthCounters) // Pass a copy to avoid shared state issues
+                    );
+                    paths.push(...nestedPaths);
+                });
+                break;
+            }
+            case 'optional': {
+                // Process the inner type for optional fields
+                const innerType = getZodDefSchemaProperty(zodSchema, 'innerType');
+                if (innerType) {
+                    const innerPaths = extractFlattenedPathsFromZodSchema(innerType, prefix, new Map(schemaDepthCounters));
+                    paths.push(...innerPaths);
+                }
+                break;
+            }
+            case 'nullable': {
+                // Process the inner type for nullable fields
+                const innerType = getZodDefSchemaProperty(zodSchema, 'innerType');
+                if (innerType) {
+                    const innerPaths = extractFlattenedPathsFromZodSchema(innerType, prefix, new Map(schemaDepthCounters));
+                    paths.push(...innerPaths);
+                }
+                break;
+            }
+            case 'array': {
+                // For arrays, extract paths from the element type
+                // This allows finding nested fields in array elements (e.g., "items.organizationId")
+                const element = getZodDefSchemaProperty(zodSchema, 'element');
+                if (element) {
+                    const elementPaths = extractFlattenedPathsFromZodSchema(element, prefix, new Map(schemaDepthCounters));
+                    paths.push(...elementPaths);
+                }
+                break;
+            }
+            case 'union': {
+                // For unions, try to extract paths from all possible schemas
+                const options = getZodDefArrayProperty(zodSchema, 'options') || [];
+                options.forEach((option) => {
+                    if (option && typeof option === 'object' && hasZodInternals(option)) {
+                        const unionPaths = extractFlattenedPathsFromZodSchema(option, prefix, new Map(schemaDepthCounters));
+                        paths.push(...unionPaths);
+                    }
+                });
+                break;
+            }
+            default: {
+                // For primitive types (string, number, boolean, etc.), no nested paths
+                break;
+            }
+        }
+    }
+    catch (error) {
+        // Silently handle errors - return paths collected so far
+    }
+    // Decrement depth counter when done processing this schema
+    schemaDepthCounters.set(zodSchema, currentDepth);
+    return paths;
+}
+// ------------------------------------------------------------
+// ARRAY SCHEMA UTILITIES
+// ------------------------------------------------------------
+/**
+ * Get the item schema from an array schema
+ */
+export function getArrayItemSchema(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'array') {
+        return null;
+    }
+    const element = getZodDefSchemaProperty(unwrapped, 'element');
+    return element ?? null;
+}
+/**
+ * Get min/max constraints for array
+ */
+export function getArrayConstraints(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'array') {
+        return {};
+    }
+    const result = {};
+    const minLength = getZodDefProperty(unwrapped, 'minLength');
+    const maxLength = getZodDefProperty(unwrapped, 'maxLength');
+    if (minLength && typeof minLength === 'object' && 'value' in minLength) {
+        const value = minLength.value;
+        if (typeof value === 'number')
+            result.minLength = value;
+    }
+    if (maxLength && typeof maxLength === 'object' && 'value' in maxLength) {
+        const value = maxLength.value;
+        if (typeof value === 'number')
+            result.maxLength = value;
+    }
+    return result;
+}
+// ------------------------------------------------------------
+// RECORD/MAP SCHEMA UTILITIES
+// ------------------------------------------------------------
+/**
+ * Get the value schema from a record schema
+ */
+export function getRecordValueSchema(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'record') {
+        return null;
+    }
+    const valueSchema = getZodDefSchemaProperty(unwrapped, 'valueType');
+    return valueSchema ?? null;
+}
+/**
+ * Get the key and value schemas from a map schema
+ */
+export function getMapSchemas(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (getZodType(unwrapped) !== 'map') {
+        return null;
+    }
+    const keySchema = getZodDefSchemaProperty(unwrapped, 'keyType');
+    const valueSchema = getZodDefSchemaProperty(unwrapped, 'valueType');
+    if (keySchema && valueSchema) {
+        return { keySchema, valueSchema };
+    }
+    return null;
+}
+// ------------------------------------------------------------
+// DEFAULT VALUE UTILITIES
+// ------------------------------------------------------------
+/**
+ * Get the default value from a schema if it has one
+ */
+export function getDefaultValue(schema) {
+    const type = getZodType(schema);
+    if (type === 'default') {
+        const defaultValue = getZodDefProperty(schema, 'defaultValue');
+        if (typeof defaultValue === 'function') {
+            return defaultValue();
+        }
+        return defaultValue;
+    }
+    if (type === 'optional' || type === 'nullable') {
+        const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+        return innerSchema ? getDefaultValue(innerSchema) : undefined;
+    }
+    return undefined;
+}
+// =============================================================================
+// DB related
+// =============================================================================
+export function isDBIndexed(schema) {
+    return hasDecorator(schema, ZodDecorator.IS_DB_INDEXED);
+}
+/** @see isForeignKeyField — alias for backward compatibility */
+export function isForeignKey(schema) {
+    return isForeignKeyField(schema);
+}
+/** @see isUniqueField — alias for backward compatibility */
+export function isUnique(schema) {
+    return isUniqueField(schema);
+}
+/** @see getUniqueFieldParams — alias for backward compatibility */
+export function getUniqueParams(schema) {
+    return getUniqueFieldParams(schema);
+}
+/**
+ * Check if a field is a primary key.
+ * Primary keys are automatically: excludeFromCreate, isHidden, isUnique, isDBIndexed
+ * @see isPrimaryKeyField — alias for backward compatibility
+ */
+export function isPrimaryKey(schema) {
+    return isPrimaryKeyField(schema);
+}
+/**
+ * Check if a field has a TTL (Time To Live) decorator.
+ * TTL fields are used for MongoDB document expiration.
+ */
+export function hasTtl(schema) {
+    return hasDecorator(schema, ZodDecorator.TTL);
+}
+/**
+ * Get TTL field params from a schema.
+ * Returns undefined if the schema is not a TTL field.
+ */
+export function getTtlParams(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    return metadata[ZodDecorator.TTL];
+}
+// =============================================================================
+// DECORATOR READER FUNCTIONS (using getMetadataRecursive — recursive unwrapping)
+// These handle .optional(), .nullable(), .default(), .refine(), array wrappers etc.
+// =============================================================================
+/**
+ * Get the structural FK params (polymorphicVariants) from `IS_FOREIGN_KEY`.
+ * Returns undefined if the schema is not a foreign key.
+ */
+export function getForeignKeyParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_FOREIGN_KEY];
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return {};
+    return value;
+}
+/**
+ * Get FK UI display params from `FOREIGN_KEY_UI.display`. Returns mode, linkable, displayPresetOverride.
+ * Falls back to default `mode: LABEL` if the FK exists but has no explicit UI config.
+ */
+export function getForeignKeyUIDisplay(schema) {
+    if (!isForeignKeyField(schema))
+        return undefined;
+    const metadata = getCustomFieldMetadata(schema);
+    const uiParams = metadata[ZodDecorator.FOREIGN_KEY_UI];
+    const display = uiParams?.display;
+    return { mode: ForeignKeyDisplayMode.LABEL, ...display };
+}
+/**
+ * Get the polymorphic variants from a foreign key field.
+ * Returns the array of PolymorphicFkVariant if the FK is polymorphic, or undefined.
+ */
+export function getPolymorphicFkVariants(schema) {
+    const params = getForeignKeyParams(schema);
+    return params?.polymorphicVariants;
+}
+/**
+ * Check if a schema field is a foreign key (recursive traversal through wrappers).
+ */
+export function isForeignKeyField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_FOREIGN_KEY] !== undefined;
+}
+/**
+ * Check if a schema field has the isSummaryField decorator.
+ */
+export function isSummaryField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_SUMMARY_FIELD] !== undefined;
+}
+/**
+ * Get the isSummaryField decorator parameters.
+ * @returns SummaryFieldParams or default empty object if decorator is used without params
+ */
+export function getSummaryFieldParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_SUMMARY_FIELD];
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return {}; // Default params when decorator is used without params
+    return value;
+}
+/**
+ * Check if a schema field has the isBackendOnly decorator.
+ */
+export function isBackendOnlyField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_BACKEND_ONLY] !== undefined;
+}
+/**
+ * Get the isBackendOnly decorator parameters.
+ */
+export function getBackendOnlyParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_BACKEND_ONLY];
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return {}; // Default params when decorator is used without params
+    return value;
+}
+/**
+ * Check if a field has auditAccess enabled via `.isBackendOnly({ auditAccess: true })`.
+ * Fields with this flag generate FIELD_ACCESS audit events when included in API responses.
+ */
+export function isAuditAccessField(schema) {
+    return getBackendOnlyParams(schema)?.auditAccess === true;
+}
+/**
+ * Check if a schema field has the isDiscriminator decorator.
+ */
+export function isDiscriminatorField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_DISCRIMINATOR] !== undefined;
+}
+/**
+ * Get the isDiscriminator decorator parameters.
+ */
+export function getDiscriminatorParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_DISCRIMINATOR];
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return {}; // Default params when decorator is used without params
+    return value;
+}
+/**
+ * Check if a schema field has the excludeFromCreate decorator.
+ */
+export function isExcludedFromCreate(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.EXCLUDE_FROM_CREATE] !== undefined;
+}
+/**
+ * Check if a schema field has the excludeFromUpdate decorator.
+ */
+export function isExcludedFromUpdate(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.EXCLUDE_FROM_UPDATE] !== undefined;
+}
+/**
+ * Check if a schema field is hidden (recursive traversal through wrappers).
+ */
+export function isHiddenField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_HIDDEN] !== undefined;
+}
+/**
+ * Get the isHidden decorator parameters.
+ * Returns default params (hidden in both display and edit) when decorator is used without params.
+ */
+export function getHiddenFieldParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_HIDDEN];
+    if (value === undefined)
+        return undefined;
+    // Default: hidden in both display and edit mode when decorator is used without params
+    if (value === true)
+        return { display: true, edit: true };
+    return value;
+}
+/**
+ * Check if a schema field is not editable (recursive traversal through wrappers).
+ */
+export function isNotEditableField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_NOT_EDITABLE] !== undefined;
+}
+/**
+ * Get the isNotEditable decorator parameters.
+ */
+export function getNotEditableFieldParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_NOT_EDITABLE];
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return {}; // Default params when decorator is used without params
+    return value;
+}
+/**
+ * Check if a schema field has the isUnique decorator (recursive traversal through wrappers).
+ */
+export function isUniqueField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_UNIQUE] !== undefined;
+}
+/**
+ * Get the isUnique decorator parameters (recursive traversal through wrappers).
+ * Returns default params { scope: 'global', sparse: true } when decorator is used without params.
+ */
+export function getUniqueFieldParams(schema) {
+    const metadata = getMetadataRecursive(schema);
+    const value = metadata?.[ZodDecorator.IS_UNIQUE];
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return { scope: 'global', sparse: true }; // Default params from original getUniqueParams
+    return value;
+}
+/**
+ * Check if a schema field has the isPrimaryKey decorator (recursive traversal through wrappers).
+ */
+export function isPrimaryKeyField(schema) {
+    const metadata = getMetadataRecursive(schema);
+    return metadata?.[ZodDecorator.IS_PRIMARY_KEY] === true;
+}
+/**
+ * Get all metadata for a schema field (non-recursive, direct access only).
+ */
+export function getFieldMetadata(schema) {
+    return schema[SCHEMA_METADATA];
+}
+/**
+ * Get all metadata for a schema field, traversing through wrapper types.
+ */
+export function getFieldMetadataRecursive(schema) {
+    return getMetadataRecursive(schema);
+}
+// =============================================================================
+// RANGE SCHEMA HELPERS
+// =============================================================================
+/**
+ * Check if a schema is a range schema (created by z_range()).
+ * Detects by the presence of rangeConfig in SCHEMA_METADATA.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isRangeSchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.rangeConfig?.isRange === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.rangeConfig?.isRange === true;
+    }
+    return false;
+}
+/**
+ * Get the range metadata from a schema.
+ * Returns undefined if not a range schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getRangeMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.rangeConfig?.isRange) {
+        return schemaMetadata.rangeConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.rangeConfig?.isRange) {
+            return unwrappedMetadata.rangeConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get the range type from a schema.
+ * Returns undefined if not a range schema.
+ */
+export function getRangeType(schema) {
+    return getRangeMetadata(schema)?.type;
+}
+// =============================================================================
+// CURRENCY SCHEMA HELPERS
+// =============================================================================
+/**
+ * Check if a schema is a money schema (created by z_money()).
+ * Detects by the presence of moneyConfig in SCHEMA_METADATA.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isMoneySchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.moneyConfig?.isMoney === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.moneyConfig?.isMoney === true;
+    }
+    return false;
+}
+/**
+ * Get the money metadata from a schema.
+ * Returns undefined if not a money schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getMoneyMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.moneyConfig?.isMoney) {
+        return schemaMetadata.moneyConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.moneyConfig?.isMoney) {
+            return unwrappedMetadata.moneyConfig;
+        }
+    }
+    return undefined;
+}
+// =============================================================================
+// BIGDECIMAL SCHEMA HELPERS
+// =============================================================================
+/**
+ * Check if a schema is a bigdecimal schema (created by z_bigdecimal()).
+ * Detects by the presence of bigDecimalConfig in SCHEMA_METADATA.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isBigDecimalSchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.bigDecimalConfig?.isBigDecimal === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.bigDecimalConfig?.isBigDecimal === true;
+    }
+    return false;
+}
+/**
+ * Get the bigdecimal metadata from a schema.
+ * Returns undefined if not a bigdecimal schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getBigDecimalMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.bigDecimalConfig?.isBigDecimal) {
+        return schemaMetadata.bigDecimalConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.bigDecimalConfig?.isBigDecimal) {
+            return unwrappedMetadata.bigDecimalConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get bigdecimal constraints from schema metadata.
+ * Returns min, max, precision from the bigdecimal schema configuration.
+ */
+export function getBigDecimalConstraints(schema) {
+    const metadata = getBigDecimalMetadata(schema);
+    if (!metadata) {
+        return {};
+    }
+    return {
+        min: metadata.min,
+        max: metadata.max,
+        precision: metadata.precision,
+    };
+}
+// =============================================================================
+// DURATION SCHEMA HELPERS
+// =============================================================================
+/**
+ * Check if a schema is a duration schema (created by z_duration()).
+ * Detects by the presence of durationConfig in SCHEMA_METADATA.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isDurationSchema(schema) {
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.durationConfig?.isDuration === true) {
+        return true;
+    }
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.durationConfig?.isDuration === true;
+    }
+    return false;
+}
+/**
+ * Get the duration metadata from a schema.
+ * Returns undefined if not a duration schema.
+ */
+export function getDurationMetadata(schema) {
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.durationConfig?.isDuration) {
+        return schemaMetadata.durationConfig;
+    }
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.durationConfig?.isDuration) {
+            return unwrappedMetadata.durationConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get duration constraints from schema metadata.
+ */
+export function getDurationConstraints(schema) {
+    const metadata = getDurationMetadata(schema);
+    if (!metadata) {
+        return {};
+    }
+    return {
+        minValue: metadata.minValue,
+        maxValue: metadata.maxValue,
+        allowedUnits: metadata.allowedUnits,
+    };
+}
+/**
+ * Check if a schema is a phone schema (created by z_phone()).
+ * Detects by the presence of phoneConfig in SCHEMA_METADATA.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isPhoneSchema(schema) {
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.phoneConfig?.isPhone === true) {
+        return true;
+    }
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.phoneConfig?.isPhone === true;
+    }
+    return false;
+}
+/**
+ * Get the phone metadata from a schema.
+ * Returns undefined if not a phone schema.
+ */
+export function getPhoneMetadata(schema) {
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.phoneConfig?.isPhone) {
+        return schemaMetadata.phoneConfig;
+    }
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.phoneConfig?.isPhone) {
+            return unwrappedMetadata.phoneConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a schema is a code schema created by z_code().
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isCodeSchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.codeConfig?.isCode === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.codeConfig?.isCode === true;
+    }
+    return false;
+}
+/**
+ * Get code schema metadata if this is a code schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getCodeMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.codeConfig?.isCode) {
+        return schemaMetadata.codeConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.codeConfig?.isCode) {
+            return unwrappedMetadata.codeConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a schema is a file schema created by z_file().
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isFileSchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.fileConfig?.isFile === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.fileConfig?.isFile === true;
+    }
+    return false;
+}
+/**
+ * Get file schema metadata if this is a file schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getFileMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.fileConfig?.isFile) {
+        return schemaMetadata.fileConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.fileConfig?.isFile) {
+            return unwrappedMetadata.fileConfig;
+        }
+    }
+    return undefined;
+}
+// -----------------------------------------------------------------------------
+// VERSIONED SCHEMA HELPERS
+// -----------------------------------------------------------------------------
+/**
+ * Check if a schema is a versioned foreign key schema created by z_foreignKeyVersioned().
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isVersionedForeignKeySchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.versionedForeignKeyConfig?.isVersionedForeignKey === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.versionedForeignKeyConfig?.isVersionedForeignKey === true;
+    }
+    return false;
+}
+/**
+ * Get versioned foreign key schema metadata if this is a versioned foreign key schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getVersionedForeignKeyMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.versionedForeignKeyConfig?.isVersionedForeignKey) {
+        return schemaMetadata.versionedForeignKeyConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.versionedForeignKeyConfig?.isVersionedForeignKey) {
+            return unwrappedMetadata.versionedForeignKeyConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a schema is a versioned object schema created by versioned().
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function isVersionedObjectSchema(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.versionedConfig?.isVersioned === true) {
+        return true;
+    }
+    // Also check the unwrapped schema (metadata might be on inner schema)
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        return unwrappedMetadata?.versionedConfig?.isVersioned === true;
+    }
+    return false;
+}
+/**
+ * Get versioned schema metadata if this is a versioned object schema.
+ * Checks both the schema directly and the unwrapped inner schema.
+ */
+export function getVersionedObjectMetadata(schema) {
+    // Check the schema directly first
+    const schemaMetadata = schema[SCHEMA_METADATA];
+    if (schemaMetadata?.versionedConfig?.isVersioned) {
+        return schemaMetadata.versionedConfig;
+    }
+    // Also check the unwrapped schema
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped !== schema) {
+        const unwrappedMetadata = unwrapped[SCHEMA_METADATA];
+        if (unwrappedMetadata?.versionedConfig?.isVersioned) {
+            return unwrappedMetadata.versionedConfig;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if the 'from' field is optional in a range schema.
+ */
+export function isRangeFromOptional(schema) {
+    return getRangeMetadata(schema)?.fromOptional;
+}
+/**
+ * Check if the 'to' field is optional in a range schema.
+ */
+export function isRangeToOptional(schema) {
+    return getRangeMetadata(schema)?.toOptional;
+}
+/**
+ * Get the min constraint from a range schema.
+ */
+export function getRangeMin(schema) {
+    return getRangeMetadata(schema)?.min;
+}
+/**
+ * Get the max constraint from a range schema.
+ */
+export function getRangeMax(schema) {
+    return getRangeMetadata(schema)?.max;
+}
+// =============================================================================
+// FORM FIELD DECORATOR UTILITIES
+// =============================================================================
+/**
+ * Get the form component from `{primitive}UI.edit.component`.
+ * Returns undefined if no form component is specified.
+ */
+export function getFormFieldComponent(schema) {
+    return getFieldUIEditConfig(schema)?.component;
+}
+/**
+ * Check if a field should be hidden based on the current context.
+ * @param schema - The Zod schema to check
+ * @param context - Optional context with mode ('display' | 'edit') and operation name
+ */
+export function shouldHideField(schema, context) {
+    if (!hasHiddenDecorator(schema)) {
+        return false;
+    }
+    const hidden = getHiddenFieldMetadata(schema);
+    // If hidden is true, always hide
+    if (hidden === true) {
+        return true;
+    }
+    // Check mode-specific hiding
+    if (context?.mode === 'display' && hidden?.display) {
+        return true;
+    }
+    if (context?.mode === 'edit' && hidden?.edit) {
+        return true;
+    }
+    // Check operation-specific hiding
+    if (context?.operation && hidden?.operations?.includes(context.operation)) {
+        return true;
+    }
+    return false;
+}
+// -----------------------------------------------------------------------------
+// Form Component Check Functions (isFormXX)
+// -----------------------------------------------------------------------------
+export function isFormInput(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.INPUT;
+}
+export function isFormTextarea(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.TEXTAREA;
+}
+export function isFormSelect(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.SELECT;
+}
+export function isFormRadioGroup(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.RADIO_GROUP;
+}
+export function isFormCheckbox(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.CHECKBOX;
+}
+export function isFormCheckboxGroup(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.CHECKBOX_GROUP;
+}
+export function isFormSwitch(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.SWITCH;
+}
+export function isFormSlider(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.SLIDER;
+}
+export function isFormDate(schema) {
+    return getFormFieldComponent(schema) === FormFieldComponent.DATE;
+}
+// =============================================================================
+// HIDDEN FIELD DECORATOR UTILITIES
+// =============================================================================
+/**
+ * Get the hidden field metadata from schema decorator.
+ * Returns undefined if no hidden decorator is set.
+ * Returns true if field is hidden in all cases.
+ * Returns HiddenFieldParams if conditional hiding is configured.
+ * Note: getCustomFieldMetadata already handles recursive unwrapping for all wrapper types
+ * including pipe (from refine/superRefine), optional, nullable, default, etc.
+ */
+export function getHiddenFieldMetadata(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    return metadata[ZodDecorator.IS_HIDDEN];
+}
+/**
+ * Check if a schema has a hidden decorator.
+ */
+export function hasHiddenDecorator(schema) {
+    return getHiddenFieldMetadata(schema) !== undefined;
+}
+/**
+ * Check if a field should be hidden for display mode.
+ * @param schema - The Zod schema to check
+ * @returns true if the field should be hidden in display mode
+ */
+export function isHiddenForDisplay(schema) {
+    const hidden = getHiddenFieldMetadata(schema);
+    if (hidden === undefined)
+        return false;
+    if (hidden === true)
+        return true;
+    return hidden.display === true;
+}
+/**
+ * Check if a field should be hidden for edit mode.
+ * @param schema - The Zod schema to check
+ * @returns true if the field should be hidden in edit mode
+ */
+export function isHiddenForEdit(schema) {
+    const hidden = getHiddenFieldMetadata(schema);
+    if (hidden === undefined)
+        return false;
+    if (hidden === true)
+        return true;
+    return hidden.edit === true;
+}
+/**
+ * Check if a field should be hidden for a specific operation.
+ * @param schema - The Zod schema to check
+ * @param operation - The operation identifier (e.g., 'create', 'update')
+ * @returns true if the field should be hidden for the given operation
+ */
+export function isHiddenForOperation(schema, operation) {
+    const hidden = getHiddenFieldMetadata(schema);
+    if (hidden === undefined)
+        return false;
+    if (hidden === true)
+        return true;
+    return hidden.operations?.includes(operation) ?? false;
+}
+// =============================================================================
+// NOT EDITABLE FIELD DECORATOR UTILITIES
+// =============================================================================
+/**
+ * Get the not editable field metadata from schema decorator.
+ * Returns undefined if no isNotEditable decorator is set.
+ * Returns true if field is not editable for all operations.
+ * Returns NotEditableFieldParams if operation-specific.
+ * Note: getCustomFieldMetadata already handles recursive unwrapping for all wrapper types
+ * including pipe (from refine/superRefine), optional, nullable, default, etc.
+ */
+export function getNotEditableFieldMetadata(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    return metadata[ZodDecorator.IS_NOT_EDITABLE];
+}
+/**
+ * Check if a schema has a isNotEditable decorator.
+ */
+export function hasNotEditableDecorator(schema) {
+    return getNotEditableFieldMetadata(schema) !== undefined;
+}
+/**
+ * Check if a field is not editable for a specific operation (or all operations).
+ * @param schema - The Zod schema to check
+ * @param operation - Optional operation identifier. If not provided, checks if not editable for all operations.
+ * @returns true if the field is not editable
+ */
+export function isNotEditableForOperation(schema, operation) {
+    const notEditable = getNotEditableFieldMetadata(schema);
+    if (notEditable === undefined)
+        return false;
+    // If true, not editable for all operations
+    if (notEditable === true)
+        return true;
+    // If no operations specified in params, not editable for all operations
+    if (!notEditable.operations || notEditable.operations.length === 0)
+        return true;
+    // If operation is provided, check if it matches
+    if (operation) {
+        return notEditable.operations.includes(operation);
+    }
+    // Operation not provided but params have specific operations - not editable only for those
+    return false;
+}
+/**
+ * Check if a schema has inline editable configuration.
+ * Reads from `{primitive}UI.display.inlineEditable`.
+ */
+export function hasInlineEditableDecorator(schema) {
+    return getFieldUIDisplayConfig(schema)?.inlineEditable != null;
+}
+/**
+ * Get the resolved inline editable params from `{primitive}UI.display.inlineEditable`.
+ * Handles both `true` shorthand and full object config.
+ */
+export function getInlineEditableParams(schema) {
+    const config = getFieldUIDisplayConfig(schema)?.inlineEditable;
+    if (config == null)
+        return undefined;
+    if (config === true) {
+        return { mode: 'direct', saveOn: 'blur', showSaveButton: false, showCancelButton: true };
+    }
+    if (config === false)
+        return undefined;
+    const saveOn = config.saveOn ?? 'blur';
+    const showSaveButton = config.showSaveButton ?? (saveOn === 'explicit');
+    return {
+        mode: config.mode ?? 'direct',
+        saveOn,
+        showSaveButton,
+        showCancelButton: config.showCancelButton ?? true,
+    };
+}
+// ============================================================================
+// ZOD .describe() UTILITY (NOT for UI descriptions — developer/AI/API docs only)
+// ============================================================================
+/**
+ * Extract the `.describe()` text from a Zod schema, unwrapping optional/nullable/default wrappers.
+ * Returns undefined if no `.describe("...")` is set.
+ *
+ * **IMPORTANT**: Zod `.describe("...")` is for developer documentation, AI prompting systems,
+ * and API documentation generation. It is NOT used for UI field descriptions — those are
+ * managed through `{primitive}UI.display.showDescription` + i18n system.
+ *
+ * In Zod 4, `.describe("...")` sets the `.description` property on the schema.
+ * When `.optional()`, `.nullable()`, or `.default()` wrap the schema, the description
+ * may live on the inner schema. We check both levels.
+ */
+export function getZodDescription(schema) {
+    // Check outer schema first
+    if (schema.description)
+        return schema.description;
+    // Unwrap optional/nullable/default to check inner schema
+    const inner = schema._zod?.innerType ?? schema.unwrap?.();
+    if (inner?.description)
+        return inner.description;
+    return undefined;
+}
+// ============================================================================
+// FIELD DESCRIPTION HELPERS (opt-in i18n key generation, mirrors tooltip pattern)
+// ============================================================================
+/**
+ * Check if a field should have a description i18n key generated for **display** mode.
+ *
+ * Reads from `{primitive}UI.display.showDescription` (boolean flag).
+ * This follows the same opt-in pattern as tooltips: only generate i18n keys for
+ * fields that explicitly declare intent via a decorator.
+ *
+ * **NOTE**: Zod `.describe("...")` is NOT an opt-in signal for UI descriptions.
+ * `.describe()` serves a different purpose (developer docs, AI prompting, API docs).
+ * UI field descriptions are purely decorator-driven + i18n-resolved.
+ *
+ * @param schema - The Zod schema to check
+ * @returns true if a description i18n key should be generated for display mode
+ */
+export function hasDescriptionForDisplay(schema) {
+    return getFieldUIDisplayConfig(schema)?.showDescription === true;
+}
+/**
+ * Check if a field should have a description i18n key generated for **edit** mode.
+ *
+ * Reads from `{primitive}UI.edit.showDescription` (boolean flag).
+ * If a field declares it wants a description, both display AND edit i18n keys are generated
+ * so translators can provide mode-appropriate text.
+ *
+ * @param schema - The Zod schema to check
+ * @returns true if a description i18n key should be generated for edit mode
+ */
+export function hasDescriptionForEdit(schema) {
+    return getFieldUIEditConfig(schema)?.showDescription === true;
+}
+// ============================================================================
+// BOOLEAN DISPLAY POLICY HELPERS
+// ============================================================================
+/**
+ * Check if a string schema should render as a password input.
+ * Checks IS_PASSWORD structural marker first, then STRING_UI editMode fallback.
+ */
+export function isPasswordField(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    if (metadata?.[ZodDecorator.IS_PASSWORD]) {
+        return true;
+    }
+    const stringUI = getStringUI(schema);
+    return stringUI?.edit?.editMode === 'password';
+}
+/**
+ * Check if a string schema should render as an OTP input.
+ * Checks IS_OTP structural marker first, then STRING_UI editMode fallback.
+ */
+export function isOtpField(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    if (metadata?.[ZodDecorator.IS_OTP]) {
+        return true;
+    }
+    const stringUI = getStringUI(schema);
+    return stringUI?.edit?.editMode === 'otp';
+}
+/**
+ * Check if a string schema should render as a color input.
+ * Checks IS_COLOR structural marker first, then STRING_UI editMode fallback.
+ */
+export function isColorField(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    if (metadata?.[ZodDecorator.IS_COLOR]) {
+        return true;
+    }
+    const stringUI = getStringUI(schema);
+    return stringUI?.edit?.editMode === 'color';
+}
+/**
+ * Get OTP field params from a schema.
+ * Returns the OTP params with defaults merged in if the decorator is present.
+ * Defaults: maxLength=6
+ */
+export function getOtpFieldParams(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    const otpParams = metadata?.[ZodDecorator.IS_OTP];
+    if (!otpParams) {
+        return undefined;
+    }
+    // If params is true (enabled without params), return defaults
+    if (otpParams === true) {
+        return { maxLength: 6 };
+    }
+    // Merge with defaults
+    return {
+        maxLength: 6,
+        ...otpParams,
+    };
+}
+/**
+ * Get the system enum name from a schema's metadata.
+ * Returns the name string (e.g. 'AvailableCurrency') if the .systemEnum() decorator is set,
+ * or undefined if the field is not a system enum.
+ */
+export function getSystemEnumName(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    return metadata[ZodDecorator.SYSTEM_ENUM];
+}
+//===============================================
+// SERIALIZATION (Zod 4)
+//===============================================
+/**
+ * Serialize a Zod schema to a JSON-serializable format.
+ * Uses Zod 4 internal structure (_zod.def.type).
+ */
+export function serializeZodSchema(schema, seen = new Set()) {
+    if (!schema)
+        return null;
+    // Avoid circular refs
+    if (seen.has(schema)) {
+        return { type: 'lazy' };
+    }
+    seen.add(schema);
+    // Helper to add optional/nullable flags
+    function withOptionals(base, optional, nullable) {
+        return {
+            ...base,
+            ...(optional ? { optional: true } : {}),
+            ...(nullable ? { nullable: true } : {})
+        };
+    }
+    // Unwrap wrappers and track optional/nullable state (Zod 4 structure)
+    const unwrapWithFlags = (s) => {
+        let cur = s;
+        let optional = false;
+        let nullable = false;
+        let type = getZodType(cur);
+        // Iteratively unwrap wrappers
+        while (type) {
+            switch (type) {
+                case 'optional':
+                    optional = true;
+                    cur = getZodDefSchemaProperty(cur, 'innerType') ?? cur;
+                    break;
+                case 'nullable':
+                    nullable = true;
+                    cur = getZodDefSchemaProperty(cur, 'innerType') ?? cur;
+                    break;
+                case 'default':
+                    cur = getZodDefSchemaProperty(cur, 'innerType') ?? cur;
+                    break;
+                case 'pipe':
+                    // For pipe/effects, prefer the output schema for serialization
+                    cur = getZodDefSchemaProperty(cur, 'out') ?? getZodDefSchemaProperty(cur, 'in') ?? cur;
+                    break;
+                case 'readonly':
+                    cur = getZodDefSchemaProperty(cur, 'innerType') ?? cur;
+                    break;
+                case 'catch':
+                    cur = getZodDefSchemaProperty(cur, 'innerType') ?? cur;
+                    break;
+                default:
+                    // Not a wrapper type, stop unwrapping
+                    return { inner: cur, optional, nullable };
+            }
+            type = getZodType(cur);
+        }
+        return { inner: cur, optional, nullable };
+    };
+    const { inner, optional, nullable } = unwrapWithFlags(schema);
+    // Get custom field metadata from the ORIGINAL schema (not inner)
+    // This ensures we find decorators at any wrapper level
+    const metadata = getCustomFieldMetadata(schema);
+    // Also check for range metadata (stored in SCHEMA_METADATA.rangeConfig)
+    const rangeMetadata = getRangeMetadata(schema) ?? getRangeMetadata(inner);
+    const withMeta = (o) => {
+        const hasMeta = metadata && Object.keys(metadata).length > 0;
+        const hasRangeMeta = rangeMetadata !== undefined;
+        if (!hasMeta && !hasRangeMeta)
+            return o;
+        // Merge custom field metadata with range metadata if present
+        const fullMetadata = {
+            ...metadata,
+            ...(hasRangeMeta ? { rangeType: rangeMetadata.type, rangeConfig: rangeMetadata } : {}),
+        };
+        return { ...o, metadata: fullMetadata };
+    };
+    // Get type from Zod 4 structure (_zod.def.type)
+    const type = getZodType(inner);
+    switch (type) {
+        case 'string': {
+            const description = inner.description;
+            return withOptionals(withMeta({ type: 'string', ...(description ? { description } : {}) }), optional, nullable);
+        }
+        case 'number':
+        case 'int':
+            return withOptionals(withMeta({ type: 'number' }), optional, nullable);
+        case 'bigint':
+            return withOptionals(withMeta({ type: 'bigint' }), optional, nullable);
+        case 'boolean':
+            return withOptionals(withMeta({ type: 'boolean' }), optional, nullable);
+        case 'date':
+            return withOptionals(withMeta({ type: 'date' }), optional, nullable);
+        case 'any':
+            return withOptionals(withMeta({ type: 'any' }), optional, nullable);
+        case 'unknown':
+            return withOptionals(withMeta({ type: 'unknown' }), optional, nullable);
+        case 'literal': {
+            const value = getZodDefProperty(inner, 'value');
+            return withOptionals(withMeta({ type: 'literal', value }), optional, nullable);
+        }
+        case 'enum': {
+            // In Zod 4, both z.enum() and z.enum() use type 'enum'
+            // Use the existing getEnumValues helper which handles both cases
+            const values = getEnumValues(inner);
+            return withOptionals(withMeta({ type: 'enum', values }), optional, nullable);
+        }
+        case 'array': {
+            const element = getZodDefSchemaProperty(inner, 'element');
+            return withOptionals(withMeta({
+                type: 'array',
+                element: serializeZodSchema(element, new Set(seen))
+            }), optional, nullable);
+        }
+        case 'set': {
+            const element = getZodDefSchemaProperty(inner, 'valueType');
+            return withOptionals(withMeta({
+                type: 'set',
+                element: serializeZodSchema(element, new Set(seen))
+            }), optional, nullable);
+        }
+        case 'tuple': {
+            const items = getZodDefArrayProperty(inner, 'items') ?? [];
+            return withOptionals(withMeta({
+                type: 'tuple',
+                items: items
+                    .filter((o) => isZodTypeAny(o))
+                    .map(o => serializeZodSchema(o, new Set(seen)))
+            }), optional, nullable);
+        }
+        case 'record': {
+            const keySchema = getZodDefSchemaProperty(inner, 'keyType');
+            const valueSchema = getZodDefSchemaProperty(inner, 'valueType');
+            return withOptionals(withMeta({
+                type: 'record',
+                key: serializeZodSchema(keySchema, new Set(seen)),
+                value: serializeZodSchema(valueSchema, new Set(seen))
+            }), optional, nullable);
+        }
+        case 'union': {
+            const options = getZodDefArrayProperty(inner, 'options') ?? [];
+            return withOptionals(withMeta({
+                type: 'union',
+                options: options
+                    .filter((o) => isZodTypeAny(o))
+                    .map(o => serializeZodSchema(o, new Set(seen)))
+            }), optional, nullable);
+        }
+        case 'object': {
+            // Use the existing getZodObjectShape helper (Zod 4 uses .shape property)
+            const shape = getZodObjectShape(inner);
+            const props = {};
+            for (const [k, v] of Object.entries(shape)) {
+                props[k] = serializeZodSchema(v, new Set(seen)) || { type: 'unknown' };
+            }
+            return withOptionals(withMeta({ type: 'object', properties: props }), optional, nullable);
+        }
+        case 'lazy':
+            return withOptionals(withMeta({ type: 'lazy' }), optional, nullable);
+        default:
+            return withOptionals(withMeta({ type: 'unknown' }), optional, nullable);
+    }
+}
+/**
+ * Deserialize a SerializableZodSchema back into a Zod schema.
+ * - Reconstructs approximate Zod types from the descriptor
+ * - Re-applies optional/nullable wrappers
+ * - Re-applies SCHEMA_METADATA as decorators when possible
+ */
+export function deserializeZodSchema(desc) {
+    if (!desc)
+        return undefined;
+    const applyOptionalNullable = (schema, d) => {
+        let s = schema;
+        if (d.optional)
+            s = s.optional();
+        if (d.nullable)
+            s = s.nullable();
+        return s;
+    };
+    const applyMetadata = (schema, metadata) => {
+        if (!metadata || Object.keys(metadata).length === 0)
+            return schema;
+        const decorators = [];
+        // Boolean decorators (no params)
+        if (metadata[ZodDecorator.IS_DB_INDEXED]) {
+            decorators.push(ZodDecorator.IS_DB_INDEXED);
+        }
+        if (metadata[ZodDecorator.IS_FOREIGN_KEY]) {
+            decorators.push(ZodDecorator.IS_FOREIGN_KEY);
+        }
+        // Hidden decorator (HiddenFieldParams | true)
+        const hidden = metadata[ZodDecorator.IS_HIDDEN];
+        if (hidden !== undefined) {
+            decorators.push({
+                ref: ZodDecorator.IS_HIDDEN,
+                params: hidden === true ? undefined : hidden
+            });
+        }
+        // Not editable decorator (NotEditableFieldParams | true)
+        const notEditable = metadata[ZodDecorator.IS_NOT_EDITABLE];
+        if (notEditable !== undefined) {
+            decorators.push({
+                ref: ZodDecorator.IS_NOT_EDITABLE,
+                params: notEditable === true ? undefined : notEditable
+            });
+        }
+        // Array UI decorator (ArrayUIParams) — also carries absorbed isSortable config
+        const arrayUI = metadata[ZodDecorator.ARRAY_UI];
+        if (arrayUI !== undefined) {
+            decorators.push({
+                ref: ZodDecorator.ARRAY_UI,
+                params: arrayUI
+            });
+        }
+        // Object UI decorator (ObjectUIParams)
+        const objectUI = metadata[ZodDecorator.OBJECT_UI];
+        if (objectUI !== undefined) {
+            decorators.push({
+                ref: ZodDecorator.OBJECT_UI,
+                params: objectUI
+            });
+        }
+        return (decorators.length > 0 ? addDecorators(schema, decorators) : schema);
+    };
+    const build = (d) => {
+        switch (d.type) {
+            case 'string': {
+                let s = z.string();
+                // Note: description is used for API docs; set if present
+                if (d.description)
+                    s = s.describe(d.description);
+                s = applyMetadata(s, d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'number': {
+                const s = applyMetadata(z.number(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'bigint': {
+                const s = applyMetadata(z.bigint(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'boolean': {
+                const s = applyMetadata(z.boolean(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'date': {
+                const s = applyMetadata(z.date(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'any': {
+                const s = applyMetadata(z.any(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'unknown': {
+                const s = applyMetadata(z.unknown(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'literal': {
+                const s = applyMetadata(z.literal(d.value), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'enum': {
+                const values = d.values;
+                // If values are missing/empty, fall back to string (cannot build z.enum([]))
+                const base = values && values.length > 0
+                    ? z.enum(values)
+                    : z.string();
+                const s = applyMetadata(base, d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'array': {
+                const el = build(d.element);
+                const s = applyMetadata(z.array(el), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'set': {
+                const el = build(d.element);
+                const s = applyMetadata(z.set(el), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'tuple': {
+                const items = d.items.map(build);
+                const s = applyMetadata(items.length >= 1
+                    ? z.tuple(items)
+                    : z.tuple([z.any()]), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'record': {
+                const val = build(d.value);
+                // Zod records only support string keys; fall back to string keys for non-string keys
+                const keyDesc = d.key;
+                const keySchema = keyDesc && keyDesc.type === 'string' ? z.string() : z.string();
+                const s = applyMetadata(z.record(keySchema, val), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'union': {
+                const options = d.options.map(build);
+                const s = applyMetadata(options.length >= 2 ? z.union(options) : (options[0] || z.any()), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'object': {
+                const metadata = d.metadata;
+                const rangeConfig = metadata?.rangeConfig;
+                // Check if this is a range schema (has rangeConfig metadata)
+                if (rangeConfig && rangeConfig.type) {
+                    const rangeSchema = z_range(rangeConfig.type, {
+                        fromOptional: rangeConfig.fromOptional,
+                        toOptional: rangeConfig.toOptional,
+                        min: rangeConfig.min,
+                        max: rangeConfig.max,
+                    });
+                    // Apply other decorators (excluding range-specific ones that are already applied)
+                    const metadataWithoutRange = { ...metadata };
+                    delete metadataWithoutRange.rangeType;
+                    delete metadataWithoutRange.rangeConfig;
+                    const s = applyMetadata(rangeSchema, metadataWithoutRange);
+                    return applyOptionalNullable(s, d);
+                }
+                // Regular object schema
+                const props = d.properties;
+                const shape = {};
+                for (const [k, v] of Object.entries(props || {})) {
+                    shape[k] = build(v) || z.unknown();
+                }
+                const s = applyMetadata(z.object(shape), metadata);
+                return applyOptionalNullable(s, d);
+            }
+            case 'lazy': {
+                // Cannot reconstruct true lazy structure; fallback
+                const s = applyMetadata(z.any(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+            default: {
+                const s = applyMetadata(z.unknown(), d.metadata);
+                return applyOptionalNullable(s, d);
+            }
+        }
+    };
+    return build(desc);
+}
+// =============================================================================
+// VIRTUAL FIELD UTILITIES
+// =============================================================================
+/**
+ * Check if a schema is marked as a virtual field.
+ * Virtual fields are computed at runtime and not stored in the database.
+ */
+export function isVirtualField(schema) {
+    return hasDecorator(schema, ZodDecorator.IS_VIRTUAL);
+}
+/**
+ * Get the virtual field parameters from a schema.
+ * Returns undefined if the field is not virtual.
+ */
+export function getVirtualFieldParams(schema) {
+    const metadata = getCustomFieldMetadata(schema);
+    const virtualMetadata = metadata[ZodDecorator.IS_VIRTUAL];
+    if (!virtualMetadata)
+        return undefined;
+    return virtualMetadata;
+}
+/**
+ * Get the dependencies declared for a virtual field.
+ * Returns an empty array if no dependencies are declared or the field is not virtual.
+ */
+export function getVirtualFieldDependencies(schema) {
+    const params = getVirtualFieldParams(schema);
+    return params?.dependencies ?? [];
+}
+/**
+ * Check if a virtual field needs object context (parents/children) for computation.
+ */
+export function virtualFieldNeedsObjectContext(schema) {
+    const params = getVirtualFieldParams(schema);
+    return params?.needsObjectContext ?? false;
+}
+/**
+ * Check if a virtual field needs user context for computation.
+ */
+export function virtualFieldNeedsUserContext(schema) {
+    const params = getVirtualFieldParams(schema);
+    return params?.needsUserContext ?? false;
+}
+/**
+ * Check if a field should be excluded from form validation based on its decorators.
+ */
+export function shouldExcludeFieldFromForm(fieldSchema, operationType) {
+    // Exclude virtual fields (computed at runtime)
+    if (hasDecorator(fieldSchema, ZodDecorator.IS_VIRTUAL)) {
+        return true;
+    }
+    // Exclude backend-only fields (never sent to frontend)
+    if (hasDecorator(fieldSchema, ZodDecorator.IS_BACKEND_ONLY)) {
+        return true;
+    }
+    // Exclude hidden fields (but respect edit: false param which means visible in edit mode)
+    const hiddenMetadata = getHiddenFieldMetadata(fieldSchema);
+    if (hiddenMetadata !== undefined) {
+        // If hiddenMetadata is true (no params), field is hidden everywhere
+        if (hiddenMetadata === true) {
+            return true;
+        }
+        // If hiddenMetadata has params, check the edit flag
+        // edit: false means "NOT hidden in edit mode" (visible in forms)
+        // edit: true or undefined means "hidden in edit mode"
+        if (hiddenMetadata.edit !== false) {
+            return true;
+        }
+        // edit: false - field is visible in forms, don't exclude
+    }
+    // Exclude excludeFromCreate fields for CREATE operations
+    if (operationType === 'CREATE' && hasDecorator(fieldSchema, ZodDecorator.EXCLUDE_FROM_CREATE)) {
+        return true;
+    }
+    // Exclude excludeFromUpdate fields for UPDATE operations
+    if (operationType === 'UPDATE' && hasDecorator(fieldSchema, ZodDecorator.EXCLUDE_FROM_UPDATE)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a field has isDraftRelaxed decorator.
+ */
+export function isDraftRelaxedField(fieldSchema) {
+    return hasDecorator(fieldSchema, ZodDecorator.IS_DRAFT_RELAXED);
+}
+/**
+ * Prepare a schema for form validation by filtering out fields that shouldn't be validated
+ * and adjusting optionality based on draft mode.
+ *
+ * This function:
+ * - Removes virtual fields
+ * - Removes backend-only fields
+ * - Removes hidden fields
+ * - Removes excludeFromCreate fields (for CREATE operations)
+ * - Removes excludeFromUpdate fields (for UPDATE operations)
+ * - Makes isDraftRelaxed fields optional when in draft mode
+ *
+ * **WARNING: Schema-level refinements (.refine(), .superRefine()) are NOT carried over.**
+ * The returned schema is a new z.object() with the filtered shape — any cross-field
+ * validation defined via refinements on the original schema will be silently lost.
+ * This is intentional for draft mode (draft = relaxed validation), but callers using
+ * this outside of draft mode should be aware that cross-field rules won't apply.
+ * For non-draft form validation, use the original schema (e.g., operation.requestDto) directly.
+ *
+ * @param schema - The original object schema
+ * @param options - Preparation options
+ * @returns A new schema suitable for form validation (without schema-level refinements)
+ */
+export function prepareFormSchema(schema, options) {
+    const { operationType, isDraftMode = false, operationLike } = options;
+    const effectiveOperationType = operationLike ?? operationType;
+    // Get the shape of the object schema
+    const shape = schema.shape;
+    const newShape = {};
+    // Process each field
+    for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+        // Skip fields that should be excluded
+        if (shouldExcludeFieldFromForm(fieldSchema, effectiveOperationType)) {
+            continue;
+        }
+        // If in draft mode and field is draft-relaxed, make it optional
+        if (isDraftMode && isDraftRelaxedField(fieldSchema)) {
+            // Wrap in optional if not already optional
+            if (!isOptional(fieldSchema)) {
+                newShape[fieldName] = fieldSchema.optional();
+            }
+            else {
+                newShape[fieldName] = fieldSchema;
+            }
+        }
+        else {
+            newShape[fieldName] = fieldSchema;
+        }
+    }
+    // Create new object schema with filtered shape
+    const newSchema = z.object(newShape);
+    const schemaAsAny = schema;
+    const originalMetadata = schemaAsAny[SCHEMA_METADATA];
+    if (originalMetadata && typeof originalMetadata === 'object') {
+        const newSchemaAsAny = newSchema;
+        newSchemaAsAny[SCHEMA_METADATA] = { ...originalMetadata };
+    }
+    // Note: We don't copy schema-level refinements in draft mode to avoid cross-field validation
+    // For non-draft mode, refinements should ideally be copied but that requires deeper schema introspection
+    return newSchema;
+}
+/**
+ * Check if a schema field is marked as ephemeral (transient response-only data).
+ * Ephemeral fields are shown once (e.g., API keys upon creation) and not persisted in the UI.
+ */
+export function isEphemeralField(schema) {
+    return hasDecorator(schema, ZodDecorator.IS_EPHEMERAL);
+}
+// =============================================================================
+// Unified {primitive}UI Reader Functions
+// =============================================================================
+// Return the full nested structure: { display?, summaryOverride?, edit? }.
+// Consumers access context-specific params via e.g. getStringUI(s)?.edit?.editMode.
+export function getBooleanUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.BOOLEAN_UI];
+}
+export function hasBooleanUI(schema) {
+    return hasDecorator(schema, ZodDecorator.BOOLEAN_UI);
+}
+export function getStringUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.STRING_UI];
+}
+export function hasStringUI(schema) {
+    return hasDecorator(schema, ZodDecorator.STRING_UI);
+}
+export function getNumberUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.NUMBER_UI];
+}
+export function hasNumberUI(schema) {
+    return hasDecorator(schema, ZodDecorator.NUMBER_UI);
+}
+export function getEnumUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.ENUM_UI];
+}
+export function hasEnumUI(schema) {
+    return hasDecorator(schema, ZodDecorator.ENUM_UI);
+}
+export function getDateUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.DATE_UI];
+}
+export function hasDateUI(schema) {
+    return hasDecorator(schema, ZodDecorator.DATE_UI);
+}
+export function getDateTimeUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.DATETIME_UI];
+}
+export function hasDateTimeUI(schema) {
+    return hasDecorator(schema, ZodDecorator.DATETIME_UI);
+}
+export function getTimeUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.TIME_UI];
+}
+export function hasTimeUI(schema) {
+    return hasDecorator(schema, ZodDecorator.TIME_UI);
+}
+export function getMoneyUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.MONEY_UI];
+}
+export function hasMoneyUI(schema) {
+    return hasDecorator(schema, ZodDecorator.MONEY_UI);
+}
+export function getCodeUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.CODE_UI];
+}
+export function hasCodeUI(schema) {
+    return hasDecorator(schema, ZodDecorator.CODE_UI);
+}
+export function getFileUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.FILE_UI];
+}
+export function hasFileUI(schema) {
+    return hasDecorator(schema, ZodDecorator.FILE_UI);
+}
+export function getDurationUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.DURATION_UI];
+}
+export function hasDurationUI(schema) {
+    return hasDecorator(schema, ZodDecorator.DURATION_UI);
+}
+export function getPhoneUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.PHONE_UI];
+}
+export function hasPhoneUI(schema) {
+    return hasDecorator(schema, ZodDecorator.PHONE_UI);
+}
+export function getBigDecimalUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.BIGDECIMAL_UI];
+}
+export function hasBigDecimalUI(schema) {
+    return hasDecorator(schema, ZodDecorator.BIGDECIMAL_UI);
+}
+export function getForeignKeyUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.FOREIGN_KEY_UI];
+}
+export function hasForeignKeyUI(schema) {
+    return hasDecorator(schema, ZodDecorator.FOREIGN_KEY_UI);
+}
+export function getArrayUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.ARRAY_UI];
+}
+export function hasArrayUI(schema) {
+    return hasDecorator(schema, ZodDecorator.ARRAY_UI);
+}
+export function getObjectUI(schema) {
+    return getCustomFieldMetadata(schema)[ZodDecorator.OBJECT_UI];
+}
+export function hasObjectUI(schema) {
+    return hasDecorator(schema, ZodDecorator.OBJECT_UI);
+}
+//# sourceMappingURL=zod-utils.shared.js.map