@rawan-temo/prisma-zod-generator 3.3.1-config-coercion.0

package/lib/transformer.js

@@ -0,0 +1,4436 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const typed_json_1 = require("./config/typed-json");
+const results_1 = require("./generators/results");
+const helpers_1 = require("./helpers");
+const decimal_helpers_1 = require("./helpers/decimal-helpers");
+const model_helpers_1 = require("./helpers/model-helpers");
+const zod_integration_1 = require("./helpers/zod-integration");
+const emission_1 = require("./typed-json/emission");
+const resolver_1 = require("./typed-json/resolver");
+const typed_field_update_operations_1 = require("./generators/typed-field-update-operations");
+const logger_1 = require("./utils/logger");
+const naming_resolver_1 = require("./utils/naming-resolver");
+const singleFileAggregator_1 = require("./utils/singleFileAggregator");
+const strict_mode_resolver_1 = require("./utils/strict-mode-resolver");
+const writeFileSafely_1 = require("./utils/writeFileSafely");
+const writeIndexFile_1 = require("./utils/writeIndexFile");
+/**
+ * Placeholder a typed-JSON replacement is swapped for while the optionality strips run
+ * over a composed property line. NUL cannot appear in a Zod expression the generator
+ * writes or a user configures, so the mask can never collide with real emitted text.
+ */
+const TYPED_JSON_MASK = '\u0000pzgTypedJson';
+/**
+ * A run of optionality markers at the very end of a typed-JSON replacement.
+ *
+ * Anchored at the end on purpose: where the marker sits is the whole boundary between
+ * one the emitter decides and one the annotation decides. See `typedJsonSlotExpression`.
+ */
+const TYPED_JSON_TRAILING_OPTIONALITY = /(?:\.(?:optional|nullable|nullish)\(\))+$/;
+class Transformer {
+    // Lightweight helpers to safely access optional JSON Schema compatibility settings
+    static isJsonSchemaModeEnabled() {
+        const cfg = this.getGeneratorConfig();
+        return !!(cfg === null || cfg === void 0 ? void 0 : cfg.jsonSchemaCompatible);
+    }
+    static getJsonSchemaOptions() {
+        var _a;
+        const cfg = this.getGeneratorConfig();
+        return ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.jsonSchemaOptions) !== null && _a !== void 0 ? _a : {});
+    }
+    constructor(params) {
+        var _a, _b, _c, _d, _e, _f;
+        this.schemaImports = new Set();
+        this.hasJson = false;
+        this.hasDecimal = false;
+        // Track excluded field names for current object generation to inform typed Omit
+        this.lastExcludedFieldNames = null;
+        this.name = (_a = params.name) !== null && _a !== void 0 ? _a : '';
+        this.fields = (_b = params.fields) !== null && _b !== void 0 ? _b : [];
+        this.models = (_c = params.models) !== null && _c !== void 0 ? _c : [];
+        this.modelOperations = (_d = params.modelOperations) !== null && _d !== void 0 ? _d : [];
+        this.enumTypes = (_e = params.enumTypes) !== null && _e !== void 0 ? _e : [];
+        // Process models with Zod integration on initialization
+        const generatorConfig = Transformer.getGeneratorConfig();
+        const zodVersion = ((_f = generatorConfig === null || generatorConfig === void 0 ? void 0 : generatorConfig.zodImportTarget) !== null && _f !== void 0 ? _f : 'auto');
+        this.enhancedModels = (0, zod_integration_1.processModelsWithZodIntegration)(this.models, {
+            enableZodAnnotations: true,
+            generateFallbackSchemas: true,
+            validateTypeCompatibility: true,
+            collectDetailedErrors: true,
+            zodVersion: zodVersion,
+        });
+    }
+    static setOutputPath(outPath) {
+        this.outputPath = outPath;
+    }
+    static setIsGenerateSelect(isGenerateSelect) {
+        this.isGenerateSelect = isGenerateSelect;
+    }
+    static setIsGenerateInclude(isGenerateInclude) {
+        this.isGenerateInclude = isGenerateInclude;
+    }
+    // Configuration setters
+    static setGeneratorConfig(config) {
+        this.generatorConfig = config;
+        this.strictModeResolver = (0, strict_mode_resolver_1.createStrictModeResolver)(config);
+    }
+    static getGeneratorConfig() {
+        return this.generatorConfig;
+    }
+    /**
+     * The `typedJson` block with its defaults filled in, or `null` when the user did not
+     * configure it.
+     *
+     * `null` is load-bearing: it is what keeps output byte-identical to 3.0.0 for every
+     * configuration that omits the key. Read it, never reconstruct it, so there is one
+     * place that decides whether the feature is on.
+     */
+    static getTypedJsonConfig() {
+        return (0, typed_json_1.resolveTypedJsonConfig)(this.generatorConfig);
+    }
+    static setTypedFieldUpdateOperationsPlan(plan) {
+        this.typedFieldUpdateOperationsPlan = plan;
+    }
+    static getStrictModeResolver() {
+        return this.strictModeResolver;
+    }
+    static escapeRegExp(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Check if a model should be generated based on configuration
+     */
+    static isModelEnabled(modelName) {
+        var _a;
+        const config = this.getGeneratorConfig();
+        // If no configuration is available, generate all models (default behavior)
+        if (!config) {
+            return true;
+        }
+        // Check if model has specific configuration
+        const modelConfig = (_a = config.models) === null || _a === void 0 ? void 0 : _a[modelName];
+        if (modelConfig) {
+            // If model config exists, check if it's explicitly enabled/disabled
+            return modelConfig.enabled !== false;
+        }
+        // In minimal mode, do NOT blanket-disable models.
+        // Default to enabling models unless explicitly disabled via config.models.
+        // This aligns minimal mode with full mode regarding model selection; other constraints
+        // (limited operations and pared-down object schemas) are handled elsewhere.
+        // Default: enable all models when no explicit model disabling is configured
+        return true;
+    }
+    /**
+     * Get list of enabled models for generation
+     */
+    static getEnabledModels(allModels) {
+        return allModels.filter((model) => this.isModelEnabled(model.name));
+    }
+    /**
+     * Log information about model filtering
+     */
+    static logModelFiltering(allModels) {
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        const enabledModels = this.getEnabledModels(allModels);
+        const disabledModels = allModels.filter((model) => !this.isModelEnabled(model.name));
+        if (disabledModels.length > 0) {
+            logger_1.logger.debug(`🚫 Models excluded from generation: ${disabledModels.map((m) => m.name).join(', ')}`);
+        }
+        if (config.mode === 'minimal' && enabledModels.length < allModels.length) {
+            logger_1.logger.debug(`⚡ Minimal mode: generating ${enabledModels.length}/${allModels.length} models`);
+        }
+    }
+    /**
+     * Check if a specific operation should be generated for a model
+     */
+    static isOperationEnabled(modelName, operationName) {
+        var _a, _b;
+        const config = this.getGeneratorConfig();
+        // If no configuration is available, generate all operations (default behavior)
+        if (!config) {
+            logger_1.logger.debug(`🔍 Operation check: ${modelName}.${operationName} = true (no config)`);
+            return true;
+        }
+        // Map operation names for backward compatibility
+        const operationMapping = {
+            findMany: ['findMany'],
+            findUnique: ['findUnique'],
+            findUniqueOrThrow: ['findUniqueOrThrow'],
+            findFirst: ['findFirst'],
+            findFirstOrThrow: ['findFirstOrThrow'],
+            createOne: ['create', 'createOne'],
+            createMany: ['create', 'createMany'],
+            createManyAndReturn: ['createManyAndReturn'],
+            updateOne: ['update', 'updateOne'],
+            updateMany: ['update', 'updateMany'],
+            updateManyAndReturn: ['updateManyAndReturn'],
+            deleteOne: ['delete', 'deleteOne'],
+            deleteMany: ['delete', 'deleteMany'],
+            upsertOne: ['upsert', 'upsertOne'],
+            aggregate: ['aggregate'],
+            groupBy: ['groupBy'],
+            count: ['count'],
+        };
+        // Check global operation exclusions first
+        if ((_a = config.globalExclusions) === null || _a === void 0 ? void 0 : _a.operations) {
+            const mappedOperationNames = operationMapping[operationName] || [operationName];
+            const isExcluded = mappedOperationNames.some((opName) => { var _a, _b, _c; return (_c = (_b = (_a = config.globalExclusions) === null || _a === void 0 ? void 0 : _a.operations) === null || _b === void 0 ? void 0 : _b.includes(opName)) !== null && _c !== void 0 ? _c : false; });
+            if (isExcluded) {
+                logger_1.logger.debug(`🔍 Operation check: ${modelName}.${operationName} = false (globally excluded: [${config.globalExclusions.operations.join(', ')}])`);
+                return false;
+            }
+        }
+        // Check if model has specific configuration
+        const modelConfig = (_b = config.models) === null || _b === void 0 ? void 0 : _b[modelName];
+        if (modelConfig && modelConfig.operations) {
+            const allowedOperationNames = operationMapping[operationName] || [operationName];
+            const isEnabled = allowedOperationNames.some((opName) => { var _a, _b; return (_b = (_a = modelConfig.operations) === null || _a === void 0 ? void 0 : _a.includes(opName)) !== null && _b !== void 0 ? _b : false; });
+            logger_1.logger.debug(`🔍 Operation check: ${modelName}.${operationName} = ${isEnabled} (configured ops: [${modelConfig.operations.join(', ')}])`);
+            return isEnabled;
+        }
+        // For minimal mode, only enable essential operations (no *Many, no upsert, no aggregate/groupBy)
+        if (config.mode === 'minimal') {
+            // Allow overrides via config.minimalOperations when present
+            const configured = config === null || config === void 0 ? void 0 : config.minimalOperations;
+            const baseAllowed = configured && Array.isArray(configured) && configured.length > 0
+                ? configured
+                : ['findMany', 'findUnique', 'findFirst', 'create', 'update', 'delete'];
+            // Map legacy op names used in model mappings to these canonical names
+            const opAliasMap = {
+                createOne: 'create',
+                updateOne: 'update',
+                deleteOne: 'delete',
+                upsertOne: 'upsert',
+            };
+            const canonical = opAliasMap[operationName] || operationName;
+            const isEnabled = baseAllowed.includes(canonical);
+            logger_1.logger.debug(`🔍 Operation check: ${modelName}.${operationName} -> ${canonical} = ${isEnabled} (minimal mode)`);
+            return isEnabled;
+        }
+        // Provider capability gating for AndReturn operations (not supported on all connectors)
+        if (operationName === 'createManyAndReturn' || operationName === 'updateManyAndReturn') {
+            const supportsAndReturn = ['postgresql', 'cockroachdb'].includes(this.provider);
+            if (!supportsAndReturn) {
+                logger_1.logger.debug(`🔍 Operation check: ${modelName}.${operationName} = false (provider=${this.provider} lacks AndReturn support)`);
+                return false;
+            }
+        }
+        // Default: enable all operations not explicitly disabled
+        logger_1.logger.debug(`🔍 Operation check: ${modelName}.${operationName} = true (default)`);
+        return true;
+    }
+    /**
+     * Get list of enabled operations for a model
+     */
+    static getEnabledOperations(modelName, allOperations) {
+        return allOperations.filter((operation) => this.isOperationEnabled(modelName, operation));
+    }
+    /**
+     * Log information about operation filtering for a model
+     */
+    static logOperationFiltering(modelName, allOperations) {
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        const enabledOperations = this.getEnabledOperations(modelName, allOperations);
+        const disabledOperations = allOperations.filter((op) => !this.isOperationEnabled(modelName, op));
+        if (disabledOperations.length > 0) {
+            logger_1.logger.debug(`   🔧 ${modelName}: excluded operations [${disabledOperations.join(', ')}]`);
+        }
+        if (config.mode === 'minimal' && enabledOperations.length < allOperations.length) {
+            logger_1.logger.debug(`   ⚡ ${modelName}: minimal mode - ${enabledOperations.length}/${allOperations.length} operations`);
+        }
+    }
+    /**
+     * Check if a field should be included in schema generation
+     */
+    static isFieldEnabled(fieldName, modelName, variant) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const config = this.getGeneratorConfig();
+        // If no configuration is available, include all fields (default behavior)
+        if (!config) {
+            return true;
+        }
+        // Start with a flag indicating whether the field should be excluded
+        let shouldExclude = false;
+        const debugReasons = [];
+        // Check global exclusions (basic format - array of strings)
+        if (config.globalExclusions && Array.isArray(config.globalExclusions)) {
+            if (this.isFieldMatchingPatterns(fieldName, config.globalExclusions)) {
+                shouldExclude = true;
+                debugReasons.push(`global array exclusion`);
+            }
+        }
+        // Check global exclusions for the specified variant
+        if (variant && ((_a = config.globalExclusions) === null || _a === void 0 ? void 0 : _a[variant])) {
+            if (this.isFieldMatchingPatterns(fieldName, config.globalExclusions[variant])) {
+                shouldExclude = true;
+                debugReasons.push(`global ${variant} exclusion`);
+            }
+        }
+        // Check model-specific field exclusions and includes
+        if (modelName) {
+            const modelConfig = (_b = config.models) === null || _b === void 0 ? void 0 : _b[modelName];
+            // Check model-specific includes FIRST - these OVERRIDE exclusions (highest precedence)
+            const legacyFields = modelConfig;
+            if ((_c = legacyFields === null || legacyFields === void 0 ? void 0 : legacyFields.fields) === null || _c === void 0 ? void 0 : _c.include) {
+                if (this.isFieldMatchingPatterns(fieldName, legacyFields.fields.include)) {
+                    logger_1.logger.debug(`🟢 Field enabled: ${modelName}.${fieldName} (${variant}) = true (model include override)`);
+                    return true; // Include overrides any previous or subsequent exclusion
+                }
+            }
+            // Check variant-specific exclusions (new format)
+            if ((_e = (_d = modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.variants) === null || _d === void 0 ? void 0 : _d[variant || 'pure']) === null || _e === void 0 ? void 0 : _e.excludeFields) {
+                const ex = ((_g = (_f = modelConfig.variants) === null || _f === void 0 ? void 0 : _f[variant || 'pure']) === null || _g === void 0 ? void 0 : _g.excludeFields) || [];
+                if (this.isFieldMatchingPatterns(fieldName, ex)) {
+                    shouldExclude = true;
+                    debugReasons.push(`model ${variant} variant exclusion`);
+                }
+            }
+            // Check legacy format: fields.exclude (for backward compatibility)
+            if ((_h = legacyFields === null || legacyFields === void 0 ? void 0 : legacyFields.fields) === null || _h === void 0 ? void 0 : _h.exclude) {
+                logger_1.logger.debug(`🔍 Checking legacy fields.exclude for ${modelName}.${fieldName}: patterns =`, legacyFields.fields.exclude);
+                if (this.isFieldMatchingPatterns(fieldName, legacyFields.fields.exclude)) {
+                    shouldExclude = true;
+                    debugReasons.push(`model fields.exclude`);
+                    logger_1.logger.debug(`🚫 Field excluded by legacy fields.exclude: ${modelName}.${fieldName}`);
+                }
+            }
+        }
+        const result = !shouldExclude;
+        if (debugReasons.length > 0 ||
+            (modelName && ['password', 'views', 'internalId', 'metadata'].includes(fieldName))) {
+            logger_1.logger.debug(`🔍 Field check: ${modelName || 'unknown'}.${fieldName} (${variant || 'unknown'}) = ${result} ${debugReasons.length > 0 ? `(${debugReasons.join(', ')})` : '(allowed)'}`);
+        }
+        // Return the opposite of shouldExclude (if should exclude, return false)
+        return result;
+    }
+    /**
+     * Check if a field name matches any pattern in the exclusion list
+     * Supports wildcards: *field, field*, *field*
+     */
+    static isFieldMatchingPatterns(fieldName, patterns) {
+        // Debug: Reduced verbosity for performance (uncomment for detailed debugging)
+        // console.log(`🔍 Pattern matching: fieldName='${fieldName}', patterns=`, patterns);
+        const result = patterns.some((pattern) => {
+            // Exact match (no wildcards)
+            if (!pattern.includes('*')) {
+                const match = fieldName === pattern;
+                // console.log(`   - Exact match '${pattern}': ${match}`);
+                return match;
+            }
+            // Convert pattern to regex
+            const regexPattern = pattern
+                .replace(/\./g, '\\.') // Escape dots FIRST
+                .replace(/\*/g, '.*'); // Then replace * with .*
+            const regex = new RegExp(`^${regexPattern}$`);
+            const match = regex.test(fieldName);
+            // console.log(`   - Regex match '${pattern}' -> /${regexPattern}/: ${match}`);
+            return match;
+        });
+        // console.log(`🔍 Pattern matching result: ${result}`);
+        return result;
+    }
+    /**
+     * Filter fields based on configuration and relationship preservation
+     */
+    static filterFields(fields, modelName, variant, models, schemaName) {
+        const config = (this.getGeneratorConfig() || {});
+        const strictCreateInputs = config.strictCreateInputs !== false; // default true
+        const preserveRequiredScalarsOnCreate = config.preserveRequiredScalarsOnCreate !== false; // default true
+        // Special case: WhereUniqueInput must retain unique identifier fields (e.g., id, unique columns)
+        // Do NOT apply variant-based exclusions to this schema type
+        const isWhereUniqueInput = !!schemaName && /WhereUniqueInput$/.test(schemaName);
+        // Do not apply variant-based field exclusions to base Prisma Create input object schemas when strictCreateInputs is true
+        // These must strictly match Prisma types to satisfy typed Zod bindings
+        const isBasePrismaCreateInputName = !!schemaName &&
+            [
+                /^(\w+)CreateInput$/,
+                /^(\w+)UncheckedCreateInput$/,
+                /^(\w+)CreateManyInput$/,
+                /^(\w+)CreateMany\w+Input$/,
+                /^(\w+)CreateWithout\w+Input$/,
+                /^(\w+)UncheckedCreateWithout\w+Input$/,
+                /^(\w+)CreateOrConnectWithout\w+Input$/,
+                /^(\w+)CreateNested(?:One|Many)Without\w+Input$/,
+            ].some((re) => re.test(schemaName));
+        const isBasePrismaCreateInput = isBasePrismaCreateInputName && strictCreateInputs;
+        const filtered = fields.filter((field) => {
+            // Check basic field inclusion rules first
+            if (!isWhereUniqueInput &&
+                !isBasePrismaCreateInput &&
+                !this.isFieldEnabled(field.name, modelName, variant)) {
+                return false;
+            }
+            // In minimal mode, suppress relation and nested object fields in input variants
+            // BUT preserve them for base Prisma create inputs to maintain type compatibility
+            if (config.mode === 'minimal' && variant === 'input' && !isBasePrismaCreateInput) {
+                if (this.isRelationFieldArg(field)) {
+                    return false;
+                }
+            }
+            // For relation fields, also check if the related model is enabled
+            // This is a safety check for schema args that might represent relation fields
+            if (this.isRelationFieldArg(field)) {
+                const relatedModelName = this.extractRelatedModelFromFieldArg(field);
+                if (relatedModelName && !this.isModelEnabled(relatedModelName)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        // Handle foreign key preservation when relation fields are excluded
+        const result = [...filtered];
+        if (modelName && variant === 'input' && !isBasePrismaCreateInput && models) {
+            const model = models.find((m) => m.name === modelName);
+            if (model) {
+                const excludedRelationFields = this.getExcludedRelationFields(fields, filtered, model);
+                const foreignKeyFields = this.getForeignKeyFieldsForExcludedRelations(excludedRelationFields, model);
+                // Add foreign key fields that aren't already present AND aren't explicitly excluded
+                for (const fkField of foreignKeyFields) {
+                    if (!result.some((field) => field.name === fkField.name)) {
+                        // Check if the foreign key field is explicitly excluded by configuration
+                        const isFieldAllowed = this.isFieldEnabled(fkField.name, modelName, variant);
+                        logger_1.logger.debug(`🔑 Foreign key preservation check: ${modelName}.${fkField.name} (${variant}) = ${isFieldAllowed}`);
+                        if (isFieldAllowed) {
+                            logger_1.logger.debug(`🔑 Adding foreign key field: ${modelName}.${fkField.name}`);
+                            result.push(fkField);
+                        }
+                        else {
+                            logger_1.logger.debug(`🚫 Skipping excluded foreign key field: ${modelName}.${fkField.name}`);
+                        }
+                    }
+                }
+            }
+        }
+        // If strictCreateInputs is false and this is a Create-like input, optionally re-add required non-auto scalars
+        if (!strictCreateInputs &&
+            isBasePrismaCreateInputName &&
+            preserveRequiredScalarsOnCreate &&
+            modelName &&
+            models) {
+            const model = models.find((m) => m.name === modelName);
+            if (model) {
+                const requiredScalars = model.fields.filter((f) => f.kind === 'scalar' &&
+                    f.isRequired === true &&
+                    f.hasDefaultValue !== true &&
+                    f.isUpdatedAt !== true);
+                for (const f of requiredScalars) {
+                    if (!result.some((arg) => arg.name === f.name)) {
+                        // Try to find the corresponding SchemaArg in original fields by name
+                        const original = fields.find((arg) => arg.name === f.name);
+                        if (original)
+                            result.push(original);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get excluded relation fields by comparing original and filtered fields
+     */
+    static getExcludedRelationFields(originalFields, filteredFields, model) {
+        const excludedFieldNames = originalFields
+            .filter((originalField) => !filteredFields.some((filteredField) => filteredField.name === originalField.name))
+            .map((field) => field.name);
+        return model.fields.filter((field) => excludedFieldNames.includes(field.name) &&
+            field.kind === 'object' &&
+            field.relationFromFields &&
+            field.relationFromFields.length > 0);
+    }
+    /**
+     * Get foreign key schema args for excluded relation fields
+     */
+    static getForeignKeyFieldsForExcludedRelations(excludedRelationFields, model) {
+        const foreignKeyFields = [];
+        for (const relationField of excludedRelationFields) {
+            if (!relationField.relationFromFields)
+                continue;
+            for (const fkFieldName of relationField.relationFromFields) {
+                const fkField = model.fields.find((f) => f.name === fkFieldName);
+                if (fkField && fkField.kind === 'scalar') {
+                    const inputTypes = [
+                        {
+                            type: fkField.type,
+                            location: 'scalar',
+                            isList: fkField.isList,
+                        },
+                    ];
+                    const schemaArg = {
+                        name: fkField.name,
+                        isRequired: fkField.isRequired,
+                        isNullable: !fkField.isRequired,
+                        inputTypes,
+                    };
+                    foreignKeyFields.push(schemaArg);
+                }
+            }
+        }
+        return foreignKeyFields;
+    }
+    /**
+     * Check if a schema arg represents a relation field
+     */
+    static isRelationFieldArg(field) {
+        // Heuristic: relation-shaped nested inputs and relation filters
+        // Detect a wide set of Prisma relation input object patterns
+        const relationTypePatterns = [
+            // Connect targets for nested relations
+            /\w+WhereUniqueInput$/,
+            // Nested relation operations
+            /\w+CreateNested(?:One|Many)Without\w+Input$/,
+            /\w+UpdateNested(?:One|Many)Without\w+Input$/,
+            /\w+UpsertNested(?:One|Many)Without\w+Input$/,
+            // Without-variants used in nested create/update
+            /\w+CreateOrConnectWithout\w+Input$/,
+            /\w+CreateWithout\w+Input$/,
+            /\w+UncheckedCreateWithout\w+Input$/,
+            /\w+UpdateWithout\w+Input$/,
+            /\w+UncheckedUpdateWithout\w+Input$/,
+            /\w+UpdateToOneWithWhereWithout\w+Input$/,
+            /\w+UpdateOneRequiredWithout\w+NestedInput$/,
+            /\w+UpdateWithWhereUniqueWithout\w+Input$/,
+            /\w+UpdateManyWithWhereWithout\w+Input$/,
+            /\w+UpsertWithWhereUniqueWithout\w+Input$/,
+            // Relation filter helpers
+            /\w+ListRelationFilter$/,
+            /\w+RelationFilter$/,
+            /\w+ScalarRelationFilter$/,
+            // Order by relation inputs
+            /OrderByRelation/,
+        ];
+        return field.inputTypes.some((inputType) => {
+            if (inputType.location !== 'inputObjectTypes')
+                return false;
+            const typeName = String(inputType.type);
+            return relationTypePatterns.some((re) => re.test(typeName));
+        });
+    }
+    /**
+     * Extract related model name from field arg
+     */
+    static extractRelatedModelFromFieldArg(field) {
+        for (const inputType of field.inputTypes) {
+            if (inputType.location === 'inputObjectTypes') {
+                const typeName = inputType.type;
+                // Handle specific relation filter patterns first
+                if (typeName.includes('ListRelationFilter')) {
+                    // Extract from "PostListRelationFilter" -> "Post"
+                    const match = typeName.match(/^(\w+)ListRelationFilter$/);
+                    if (match)
+                        return match[1];
+                }
+                // Extract model name from other types like "PostWhereInput", "UserCreateInput", etc.
+                const match = typeName.match(/^(\w+)(?:Where|Create|Update|OrderBy|RelationFilter|CreateNested|UpdateNested)/);
+                if (match) {
+                    return match[1];
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract model name from object schema context
+     */
+    static extractModelNameFromContext(schemaName) {
+        // Try to extract model name from common schema naming patterns
+        // More specific patterns should come first to avoid false matches
+        const patterns = [
+            // Basic input types - more specific patterns first
+            /^(\w+)UncheckedCreateInput$/,
+            /^(\w+)UncheckedUpdateInput$/,
+            /^(\w+)UncheckedUpdateManyInput$/,
+            /^(\w+)UpdateManyMutationInput$/,
+            /^(\w+)WhereUniqueInput$/,
+            /^(\w+)CreateManyInput$/,
+            /^(\w+)UpdateManyInput$/,
+            /^(\w+)WhereInput$/,
+            /^(\w+)CreateInput$/,
+            /^(\w+)UpdateInput$/,
+            // Order by inputs
+            /^(\w+)OrderByWithRelationInput$/,
+            /^(\w+)OrderByWithAggregationInput$/,
+            /^(\w+)OrderByRelationAggregateInput$/,
+            // Filter inputs
+            /^(\w+)ScalarWhereInput$/,
+            /^(\w+)ScalarWhereWithAggregatesInput$/,
+            /^(\w+)ListRelationFilter$/,
+            /^(\w+)RelationFilter$/,
+            /^(\w+)ScalarRelationFilter$/,
+            // Aggregate inputs
+            /^(\w+)CountAggregateInput$/,
+            /^(\w+)CountOrderByAggregateInput$/,
+            /^(\w+)AvgAggregateInput$/,
+            /^(\w+)AvgOrderByAggregateInput$/,
+            /^(\w+)MaxAggregateInput$/,
+            /^(\w+)MaxOrderByAggregateInput$/,
+            /^(\w+)MinAggregateInput$/,
+            /^(\w+)MinOrderByAggregateInput$/,
+            /^(\w+)SumAggregateInput$/,
+            /^(\w+)SumOrderByAggregateInput$/,
+            // Nested operation inputs
+            /^(\w+)CreateNestedOneWithout\w+Input$/,
+            /^(\w+)CreateNestedManyWithout\w+Input$/,
+            /^(\w+)UpdateNestedOneWithout\w+Input$/,
+            /^(\w+)UpdateNestedManyWithout\w+Input$/,
+            /^(\w+)UpsertNestedOneWithout\w+Input$/,
+            /^(\w+)UpsertNestedManyWithout\w+Input$/,
+            /^(\w+)CreateOrConnectWithout\w+Input$/,
+            /^(\w+)UpdateOneRequiredWithout\w+NestedInput$/,
+            /^(\w+)UpdateToOneWithWhereWithout\w+Input$/,
+            /^(\w+)UpsertWithout\w+Input$/,
+            /^(\w+)CreateWithout\w+Input$/,
+            /^(\w+)UpdateWithout\w+Input$/,
+            /^(\w+)UncheckedCreateWithout\w+Input$/,
+            /^(\w+)UncheckedUpdateWithout\w+Input$/,
+            /^(\w+)UncheckedCreateNestedManyWithout\w+Input$/,
+            /^(\w+)UncheckedUpdateManyWithout\w+Input$/,
+            /^(\w+)UncheckedUpdateManyWithout\w+NestedInput$/,
+            // Many-to-many relation inputs
+            /^(\w+)CreateManyAuthorInput$/,
+            /^(\w+)CreateManyAuthorInputEnvelope$/,
+            /^(\w+)UpdateManyWithWhereWithout\w+Input$/,
+            /^(\w+)UpdateWithWhereUniqueWithout\w+Input$/,
+            /^(\w+)UpsertWithWhereUniqueWithout\w+Input$/,
+            /^(\w+)UpdateManyWithout\w+NestedInput$/,
+            // Additional specific patterns found in generated schemas
+            /^(\w+)UncheckedUpdateManyInput$/,
+            // Args and other schemas
+            /^(\w+)Args$/,
+            // Pure model schemas (variant schemas)
+            /^(\w+)ModelSchema$/,
+            // Generic CreateMany relationship patterns (placed at end to avoid interference)
+            // Capture the owning model prefix (e.g. AccountCreateManyUserInputEnvelope -> Account)
+            /^(\w+)CreateMany\w+InputEnvelope$/,
+            /^(\w+)CreateMany\w+Input$/,
+        ];
+        for (const pattern of patterns) {
+            const match = schemaName.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    /**
+     * Determine schema variant from context
+     */
+    static determineSchemaVariant(schemaName) {
+        // Determine variant based on schema name patterns
+        if (schemaName.includes('Create') ||
+            schemaName.includes('Update') ||
+            schemaName.includes('Where')) {
+            return 'input';
+        }
+        if (schemaName.includes('Result') || schemaName.includes('Output')) {
+            return 'result';
+        }
+        return 'pure'; // Default variant
+    }
+    /**
+     * Log information about field filtering
+     */
+    static logFieldFiltering(originalCount, filteredCount, modelName, variant) {
+        if (originalCount !== filteredCount) {
+            const context = modelName ? `${modelName}${variant ? ` (${variant})` : ''}` : 'schema';
+            logger_1.logger.debug(`   🎯 ${context}: filtered ${originalCount - filteredCount} fields (${filteredCount}/${originalCount} remaining)`);
+        }
+    }
+    /**
+     * Check if a model has relationships to other ENABLED models
+     * This is a filtered version of checkModelHasModelRelation that only considers enabled models
+     */
+    static checkModelHasEnabledModelRelation(model) {
+        const { fields: modelFields } = model;
+        for (const modelField of modelFields) {
+            if (this.isEnabledRelationField(modelField)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a relation field points to an enabled model
+     */
+    static isEnabledRelationField(modelField) {
+        const { kind, relationName, type } = modelField;
+        // Must be an object relation field
+        if (kind !== 'object' || !relationName) {
+            return false;
+        }
+        // Check if the related model is enabled
+        const relatedModelName = type;
+        return this.isModelEnabled(relatedModelName);
+    }
+    /**
+     * Get list of enabled related models for a given model
+     */
+    static getEnabledRelatedModels(model) {
+        const relatedModels = new Set();
+        for (const field of model.fields) {
+            if (this.isEnabledRelationField(field)) {
+                relatedModels.add(field.type);
+            }
+        }
+        return Array.from(relatedModels);
+    }
+    /**
+     * Check if a model should have include schemas generated
+     * Only if it has relationships to other enabled models
+     */
+    static shouldGenerateIncludeSchema(model) {
+        const config = this.getGeneratorConfig();
+        if ((config === null || config === void 0 ? void 0 : config.mode) === 'minimal')
+            return false;
+        return Transformer.isGenerateInclude && this.checkModelHasEnabledModelRelation(model);
+    }
+    /**
+     * Check if a model should have select schemas generated
+     */
+    static shouldGenerateSelectSchema(_model) {
+        const config = this.getGeneratorConfig();
+        if ((config === null || config === void 0 ? void 0 : config.mode) === 'minimal')
+            return false;
+        return Transformer.isGenerateSelect;
+    }
+    /**
+     * Log relationship preservation information
+     */
+    static logRelationshipPreservation(model) {
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        const enabledRelatedModels = this.getEnabledRelatedModels(model);
+        const totalRelationFields = model.fields.filter((f) => f.kind === 'object' && f.relationName).length;
+        const enabledRelationFields = model.fields.filter((f) => this.isEnabledRelationField(f)).length;
+        if (totalRelationFields > enabledRelationFields) {
+            const disabledRelations = totalRelationFields - enabledRelationFields;
+            logger_1.logger.debug(`   🔗 ${model.name}: ${disabledRelations} disabled relation(s) to filtered models`);
+        }
+        if (enabledRelatedModels.length > 0) {
+            logger_1.logger.debug(`   ✅ ${model.name}: active relations to [${enabledRelatedModels.join(', ')}]`);
+        }
+    }
+    // Dual export setters
+    static setExportTypedSchemas(exportTypedSchemas) {
+        this.exportTypedSchemas = exportTypedSchemas;
+    }
+    static setExportZodSchemas(exportZodSchemas) {
+        this.exportZodSchemas = exportZodSchemas;
+    }
+    static setTypedSchemaSuffix(typedSchemaSuffix) {
+        this.typedSchemaSuffix = typedSchemaSuffix;
+    }
+    static setZodSchemaSuffix(zodSchemaSuffix) {
+        this.zodSchemaSuffix = zodSchemaSuffix;
+    }
+    /**
+     * Generate the correct object schema name based on export settings
+     */
+    static getObjectSchemaName(baseName) {
+        return this.exportTypedSchemas
+            ? `${baseName}ObjectSchema`
+            : `${baseName}Object${this.zodSchemaSuffix}`;
+    }
+    static getOutputPath() {
+        return this.outputPath;
+    }
+    static setCurrentManifest(manifest) {
+        this.currentManifest = manifest;
+    }
+    static getCurrentManifest() {
+        return this.currentManifest;
+    }
+    static setPrismaClientOutputPath(prismaClientCustomPath) {
+        this.prismaClientOutputPath = prismaClientCustomPath;
+        this.isCustomPrismaClientOutputPath = prismaClientCustomPath !== '@prisma/client';
+    }
+    /**
+     * Resolve the import specifier for Prisma Client relative to a target directory.
+     * Falls back to '@prisma/client' when user did not configure a custom output.
+     */
+    static resolvePrismaImportPath(targetDir) {
+        if (!this.isCustomPrismaClientOutputPath)
+            return '@prisma/client';
+        try {
+            let prismaClientImportTarget = this.prismaClientOutputPath;
+            // For the new Prisma generator (provider = 'prisma-client'), the public entrypoints
+            // live in generated `client.*` / `browser.*` files inside the configured output
+            // directory. The Prisma output config represents the directory, so we explicitly
+            // target a file. We target the browser-safe entrypoint: the server entry (client.*)
+            // hard-imports node: builtins (node:process/node:path/node:url/node:buffer) and
+            // breaks browser bundles, while browser.* exports everything the generated schemas
+            // need (the Prisma namespace with Decimal/DbNull/JsonNull values plus all types).
+            if (this.prismaClientProvider === 'prisma-client') {
+                const hasFileExtension = path_1.default.extname(prismaClientImportTarget) !== '';
+                if (!hasFileExtension) {
+                    prismaClientImportTarget = path_1.default.join(prismaClientImportTarget, this.resolvePrismaClientEntryBasename());
+                }
+            }
+            // Compute relative path from the file's directory to the custom client output path
+            let rel = path_1.default.relative(targetDir, prismaClientImportTarget).replace(/\\/g, '/');
+            if (!rel || rel === '')
+                return '@prisma/client';
+            // Add file extension if needed (for ESM with importFileExtension)
+            const extension = this.getImportFileExtension();
+            if (!extension || !/\.[a-z]+$/i.test(rel)) {
+                rel = `${rel}${extension}`;
+            }
+            // Ensure it is a valid relative module specifier (prefix with ./ when needed)
+            if (rel.startsWith('.') || rel.startsWith('/'))
+                return rel;
+            return `./${rel}`;
+        }
+        catch {
+            return '@prisma/client';
+        }
+    }
+    /**
+     * The `import type { Prisma }` line for CRUD operation schema files, or '' when
+     * typed exports are disabled — the typed exports are the only consumers of the
+     * Prisma namespace in those files, so the import would otherwise be unused.
+     */
+    static prismaTypeImportLine(prismaImportPath) {
+        return Transformer.exportTypedSchemas
+            ? `import type { Prisma } from '${prismaImportPath}';\n`
+            : '';
+    }
+    /**
+     * Determine which generated prisma-client entrypoint to import.
+     * Prefers the browser-safe `browser.*` entry so generated schemas can be bundled
+     * for client-side use. Falls back to the server `client.*` entry only when an
+     * older prisma-client output layout without a browser entry is positively
+     * detected on disk. When the client output has not been generated yet, assume
+     * the modern layout (browser entry present).
+     */
+    static resolvePrismaClientEntryBasename() {
+        const outputDir = this.prismaClientOutputPath;
+        const cached = this.prismaClientEntryBasenameCache.get(outputDir);
+        if (cached)
+            return cached;
+        // Default to the server entry: `client.*` is always present in a
+        // prisma-client output, whereas `browser.*` is not guaranteed. The
+        // generators can also run before the client output exists (the directory is
+        // then unreadable), and guessing `browser` there emits an import that does
+        // not resolve — strictly worse than the server entry, which merely is not
+        // browser-optimised. Prefer `browser` only when we can see it on disk.
+        let entry = 'client';
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports -- lazy require keeps fs out of the module top level
+            const fs = require('fs');
+            const entries = fs.readdirSync(outputDir);
+            const entryFileRegex = /^(browser|client)\.(ts|mts|cts|js|mjs|cjs)$/;
+            const hasBrowserEntry = entries.some((name) => { var _a; return ((_a = entryFileRegex.exec(name)) === null || _a === void 0 ? void 0 : _a[1]) === 'browser'; });
+            const hasClientEntry = entries.some((name) => { var _a; return ((_a = entryFileRegex.exec(name)) === null || _a === void 0 ? void 0 : _a[1]) === 'client'; });
+            if (hasBrowserEntry)
+                entry = 'browser';
+            else if (hasClientEntry)
+                entry = 'client';
+        }
+        catch {
+            // Output directory unreadable or not generated yet: keep the server entry.
+        }
+        this.prismaClientEntryBasenameCache.set(outputDir, entry);
+        return entry;
+    }
+    static setPrismaClientProvider(provider) {
+        this.prismaClientProvider = provider;
+    }
+    static setPrismaClientConfig(config) {
+        this.prismaClientConfig = config;
+    }
+    static getPrismaClientProvider() {
+        return this.prismaClientProvider;
+    }
+    static getPrismaClientConfig() {
+        return this.prismaClientConfig;
+    }
+    /**
+     * Determines the schemas directory path based on the output path.
+     * If the output path already ends with 'schemas', use it directly.
+     * Otherwise, append 'schemas' to the output path.
+     */
+    static getSchemasPath() {
+        const normalizedOutputPath = path_1.default.normalize(this.outputPath);
+        const pathSegments = normalizedOutputPath.split(path_1.default.sep);
+        const lastSegment = pathSegments[pathSegments.length - 1];
+        if (lastSegment === 'schemas') {
+            return this.outputPath;
+        }
+        return path_1.default.join(this.outputPath, 'schemas');
+    }
+    static async generateIndex() {
+        const indexPath = path_1.default.join(Transformer.getSchemasPath(), 'index.ts');
+        const importExtension = Transformer.getImportFileExtension();
+        await (0, writeIndexFile_1.writeIndexFile)(indexPath, importExtension);
+    }
+    async generateEnumSchemas() {
+        for (const enumType of this.enumTypes) {
+            const { name, values } = enumType;
+            // Filter out enum schemas for disabled models
+            if (this.isEnumSchemaEnabled(name)) {
+                // Use enum naming configuration
+                const enumNamingConfig = (0, naming_resolver_1.resolveEnumNaming)(Transformer.getGeneratorConfig());
+                // Normalize enum name for consistent file naming and exports
+                const normalizedEnumName = this.normalizeEnumName(name);
+                const enumName = normalizedEnumName || name;
+                const fileName = (0, naming_resolver_1.generateFileName)(enumNamingConfig.filePattern, enumName, // Use enum name as model name for naming pattern
+                undefined, // No operation
+                undefined, // No input type
+                enumName);
+                const schemaExportName = (0, naming_resolver_1.generateExportName)(enumNamingConfig.exportNamePattern, enumName, // Use enum name as model name for naming pattern
+                undefined, // No operation
+                undefined, // No input type
+                enumName);
+                await (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer.getSchemasPath(), `enums/${fileName}`), `${this.generateImportZodStatement()}\n` +
+                    `export const ${schemaExportName} = z.enum([${values
+                        .map((v) => `'${v}'`)
+                        .join(', ')}])\n\n` +
+                    `export type ${enumName} = z.infer<typeof ${schemaExportName}>;`);
+            }
+        }
+    }
+    /**
+     * Check if an enum schema should be generated based on enabled models
+     */
+    isEnumSchemaEnabled(enumName) {
+        // Always generate user-defined enums and Prisma built-in enums
+        // Only filter model-specific generated enums based on model configuration
+        // Check if this is a model-specific enum (like PostScalarFieldEnum)
+        const modelName = this.extractModelNameFromEnum(enumName);
+        if (modelName) {
+            // This is a model-specific enum, check if the model is enabled
+            return Transformer.isModelEnabled(modelName);
+        }
+        // For all other enums (user-defined enums like Status, Role, and Prisma built-ins),
+        // always generate them regardless of model configuration
+        return true;
+    }
+    /**
+     * Extract model name from enum name
+     */
+    extractModelNameFromEnum(enumName) {
+        for (const pattern of Transformer.modelEnumPatterns) {
+            const match = enumName.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    /**
+     * Normalize enum names to match import expectations
+     * For model-related enums, use Pascal case model names consistently
+     */
+    normalizeEnumName(enumName) {
+        // Use shared patterns to detect and normalize model-specific enums
+        for (const pattern of Transformer.modelEnumPatterns) {
+            const match = enumName.match(pattern);
+            if (match) {
+                const modelName = match[1];
+                const pascalModelName = this.getPascalCaseModelName(modelName);
+                // Rebuild enum name with normalized model name
+                return enumName.replace(modelName, pascalModelName);
+            }
+        }
+        // Return null for non-model-related enums to use original name
+        return null;
+    }
+    /**
+     * Convert model names to DMMF aggregate input names
+     * For doc_parser_agent model: matches Prisma's DMMF format Doc_parser_agentCountAggregateInput
+     */
+    getAggregateInputName(modelName, inputSuffix) {
+        // Prisma's DMMF uses original model name with first letter capitalized for aggregate inputs
+        // doc_parser_agent -> Doc_parser_agentCountAggregateInput (not DocParserAgentCountAggregateInput)
+        const capitalizedModelName = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+        return `${capitalizedModelName}${inputSuffix}`;
+    }
+    /**
+     * Get the correct Prisma type name for model types
+     * Prisma uses the original model name as-is (e.g., doc_parser_agent -> Prisma.doc_parser_agentSelect)
+     */
+    getPrismaTypeName(modelName, operationType) {
+        /* Special case: Aggregate operations capitalize the first letter of model names.
+        This applies to all naming conventions since kebab-case is not allowed in Prisma schemas.*/
+        if (operationType === 'Aggregate') {
+            return modelName.charAt(0).toUpperCase() + modelName.slice(1);
+        }
+        // All other operations use the original model name without any case transformation
+        return modelName;
+    }
+    /**
+     * Check if a model has numeric fields that support avg/sum operations
+     */
+    modelHasNumericFields(modelName) {
+        const dmmfModel = this.models.find((m) => m.name === modelName);
+        if (!dmmfModel)
+            return false;
+        return dmmfModel.fields.some((field) => ['Int', 'Float', 'Decimal', 'BigInt'].includes(field.type));
+    }
+    /**
+     * The module `z` is imported from, honouring `zodImportTarget` and `zodImportPath`.
+     *
+     * Extracted so the typed-JSON namespace file can import `z` from the same place the
+     * schemas do. Recomputing it there would make the module path two sources of truth,
+     * which is precisely the class of drift this feature exists to remove.
+     */
+    static resolveZodImportSpecifier() {
+        var _a;
+        const config = Transformer.getGeneratorConfig();
+        const target = ((_a = config === null || config === void 0 ? void 0 : config.zodImportTarget) !== null && _a !== void 0 ? _a : 'auto');
+        const defaultPath = target === 'v4' ? 'zod/v4' : target === 'v3' ? 'zod/v3' : 'zod';
+        // A custom module path (issue #370) lets users point z at their own
+        // re-export configured with an i18n error map, etc. The binding style still
+        // follows zodImportTarget, so the custom module must export z accordingly.
+        const custom = typeof (config === null || config === void 0 ? void 0 : config.zodImportPath) === 'string' ? config.zodImportPath.trim() : '';
+        if (!custom)
+            return defaultPath;
+        // Guard the generated string literal: a real module specifier never
+        // contains quotes/whitespace. Reject anything else and warn.
+        if (/^[a-zA-Z0-9_@./-]+$/.test(custom))
+            return custom;
+        logger_1.logger.warn(`[prisma-zod-generator] Ignoring invalid zodImportPath "${custom}"; falling back to '${defaultPath}'`);
+        return defaultPath;
+    }
+    generateImportZodStatement() {
+        var _a, _b;
+        // v3 binds a named export (import { z }); auto/v4 bind the namespace.
+        const target = ((_b = (_a = Transformer.getGeneratorConfig()) === null || _a === void 0 ? void 0 : _a.zodImportTarget) !== null && _b !== void 0 ? _b : 'auto');
+        const useNamedBinding = target === 'v3';
+        const path = Transformer.resolveZodImportSpecifier();
+        return useNamedBinding ? `import { z } from '${path}';\n` : `import * as z from '${path}';\n`;
+    }
+    /**
+     * Generate custom import statements from @zod.import() annotations
+     *
+     * @param customImports - Array of custom import objects
+     * @param outputPath - Current output path for relative import adjustment
+     * @returns Generated import statements string
+     */
+    generateCustomImportStatements(customImports, outputPath = '') {
+        if (!customImports || customImports.length === 0) {
+            return '';
+        }
+        const importStatements = [];
+        const seenImports = new Set();
+        for (const customImport of customImports) {
+            if (!customImport || !customImport.importStatement) {
+                continue;
+            }
+            let importStatement = customImport.importStatement;
+            // Adjust relative paths for multi-file output
+            if (outputPath && customImport.source.startsWith('.')) {
+                importStatement = this.adjustRelativeImportPath(importStatement, outputPath);
+            }
+            // Avoid duplicate imports
+            if (!seenImports.has(importStatement)) {
+                seenImports.add(importStatement);
+                importStatements.push(importStatement);
+            }
+        }
+        if (importStatements.length === 0) {
+            return '';
+        }
+        // Return imports with proper formatting and newline
+        return importStatements.join(';\n') + ';\n';
+    }
+    /**
+     * Get custom imports for a specific schema context
+     * This method is called AFTER the schema content is generated to determine which imports are actually needed
+     *
+     * @param modelName - Name of the model
+     * @param schemaContent - The generated schema content to analyze for import usage
+     * @returns Array of custom imports needed for this specific schema
+     */
+    getCustomImportsForModel(modelName, schemaContent) {
+        if (!modelName)
+            return [];
+        // Find the enhanced model data
+        const enhancedModel = this.enhancedModels.find((em) => em.model.name === modelName);
+        if (!enhancedModel)
+            return [];
+        const usedImports = [];
+        const usedImportSources = new Set();
+        // If schema content is provided, analyze it for actual usage
+        if (schemaContent) {
+            // Collect all potential imports from field-level and model-level
+            const allPotentialImports = [];
+            // Add field-level imports
+            for (const enhancedField of enhancedModel.enhancedFields) {
+                if (enhancedField.customImports) {
+                    allPotentialImports.push(...enhancedField.customImports);
+                }
+            }
+            // Add model-level imports
+            if (enhancedModel.modelCustomImports) {
+                allPotentialImports.push(...enhancedModel.modelCustomImports);
+            }
+            // Check which imports are actually used in the schema content
+            for (const potentialImport of allPotentialImports) {
+                if (potentialImport.importedItems) {
+                    // Check if any imported function/item is used in the schema content
+                    const isUsed = potentialImport.importedItems.some((item) => {
+                        if (!item) {
+                            return false;
+                        }
+                        const escaped = Transformer.escapeRegExp(item);
+                        const re = new RegExp(`\\b${escaped}\\b`);
+                        return re.test(schemaContent);
+                    });
+                    if (isUsed && !usedImportSources.has(potentialImport.importStatement)) {
+                        usedImports.push(potentialImport);
+                        usedImportSources.add(potentialImport.importStatement);
+                    }
+                }
+            }
+            return usedImports;
+        }
+        // Fallback to the old logic if no schema content is provided
+        // Check which fields in this schema actually use custom validation
+        for (const field of this.fields) {
+            const enhancedField = enhancedModel.enhancedFields.find((ef) => ef.field.name === field.name);
+            // Only add imports if the field has custom imports AND the field string contains custom validation logic
+            if (enhancedField && enhancedField.customImports && enhancedField.customImports.length > 0) {
+                // Check if this field actually contains custom validation by looking for function calls
+                const hasCustomValidation = this.fieldContainsCustomValidation(field, enhancedField);
+                if (hasCustomValidation) {
+                    for (const customImport of enhancedField.customImports) {
+                        // Deduplicate imports by source
+                        if (!usedImportSources.has(customImport.importStatement)) {
+                            usedImports.push(customImport);
+                            usedImportSources.add(customImport.importStatement);
+                        }
+                    }
+                }
+            }
+        }
+        // Only add model-level imports if this is a schema type that should include model-level validation
+        // Model-level validation (like .refine()) should only be in result/output schemas, not input aggregate schemas
+        const isResultSchema = this.name.includes('Result') ||
+            this.name.includes('ModelSchema') ||
+            (!this.name.includes('Input') &&
+                !this.name.includes('Filter') &&
+                !this.name.includes('OrderBy') &&
+                !this.name.includes('Aggregate'));
+        if (isResultSchema &&
+            enhancedModel.modelCustomImports &&
+            enhancedModel.modelCustomImports.length > 0) {
+            for (const modelImport of enhancedModel.modelCustomImports) {
+                if (!usedImportSources.has(modelImport.importStatement)) {
+                    usedImports.push(modelImport);
+                    usedImportSources.add(modelImport.importStatement);
+                }
+            }
+        }
+        return usedImports;
+    }
+    /**
+     * Check if a field actually contains custom validation logic
+     */
+    fieldContainsCustomValidation(field, enhancedField) {
+        // Check if the enhanced field has a custom schema or custom validation
+        if (enhancedField.hasZodAnnotations && enhancedField.zodSchema) {
+            const zodSchema = enhancedField.zodSchema;
+            // Check if the zodSchema contains function calls from the custom imports
+            if (enhancedField.customImports) {
+                for (const customImport of enhancedField.customImports) {
+                    // Check if any of the imported function names are used in the schema
+                    for (const importedItem of customImport.importedItems || []) {
+                        if (zodSchema.includes(importedItem)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            // Check if schema contains .refine() or .transform() which would use custom logic
+            if (zodSchema.includes('.refine(') || zodSchema.includes('.transform(')) {
+                return true;
+            }
+        }
+        // Check if the enhanced field has a custom schema from @zod.import().custom.use()
+        if (enhancedField.customSchema) {
+            return true;
+        }
+        // Convert field to string to check its content as fallback
+        const fieldString = field.toString();
+        // If field is just z.literal(true).optional() or similar basic patterns, it doesn't need custom imports
+        if (fieldString.includes('z.literal(true)') || fieldString.includes('z.lazy(')) {
+            return false;
+        }
+        // Check if field contains function calls from the custom imports as fallback
+        if (enhancedField.customImports) {
+            for (const customImport of enhancedField.customImports) {
+                // Check if any of the imported function names are used in the field
+                for (const importedItem of customImport.importedItems || []) {
+                    if (fieldString.includes(importedItem)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Get custom schema for a specific field
+     *
+     * @param fieldName - Name of the field
+     * @returns Custom schema string or null if not found
+     */
+    getCustomSchemaForField(fieldName) {
+        const modelName = Transformer.extractModelNameFromContext(this.name);
+        if (!modelName)
+            return null;
+        // Find the enhanced model data
+        const enhancedModel = this.enhancedModels.find((em) => em.model.name === modelName);
+        if (!enhancedModel)
+            return null;
+        // Find the enhanced field data
+        const enhancedField = enhancedModel.enhancedFields.find((ef) => ef.field.name === fieldName);
+        if (!enhancedField)
+            return null;
+        // Return ONLY the custom schema from @zod.import().custom.use() if available
+        // Regular @zod annotations should be handled by wrapWithZodValidators to avoid double-processing
+        if (enhancedField.customSchema) {
+            return enhancedField.customSchema;
+        }
+        return null;
+    }
+    /**
+     * Directory the file being emitted sits in, relative to the generator output directory.
+     *
+     * This is what a relative `typedJson.schemaModule` is rewritten against, so `./json-types`
+     * becomes `../json-types` from `objects/`.
+     */
+    static typedJsonOutputSubdir(subdir) {
+        var _a;
+        try {
+            // In single-file mode every schema ends up in one bundle, so what matters is where
+            // that bundle lands, not which subdirectory the content came from.
+            const dir = (0, singleFileAggregator_1.isSingleFileEnabled)()
+                ? ((_a = Transformer.getGeneratorConfig()) === null || _a === void 0 ? void 0 : _a.placeSingleFileAtRoot) !== false
+                    ? Transformer.getOutputPath()
+                    : Transformer.getSchemasPath()
+                : path_1.default.join(Transformer.getSchemasPath(), subdir);
+            return path_1.default.relative(Transformer.getOutputPath(), dir).split(path_1.default.sep).join('/');
+        }
+        catch {
+            return subdir;
+        }
+    }
+    /**
+     * The model this schema's members take their typed-JSON annotations from.
+     *
+     * `resolveTypedJsonOwnerModel` repairs the one shape the general extraction reads wrong -
+     * `<Model>UncheckedCreateWithout<Relation>Input` and its update twin, which it answers as
+     * a model called `<Model>Unchecked`. The repair lives here, on the typed-JSON path only,
+     * rather than in `extractModelNameFromContext`, because that function also drives file
+     * naming and field filtering: a changed answer there would move bytes for repos that have
+     * never configured `typedJson`.
+     */
+    typedJsonOwnerModel(extractedName) {
+        return (0, emission_1.resolveTypedJsonOwnerModel)(extractedName, (name) => this.enhancedModels.some((em) => em.model.name === name));
+    }
+    /** The DMMF model field an input-object member refers to, when there is one. */
+    getModelFieldForArg(fieldName) {
+        var _a, _b;
+        const modelName = this.typedJsonOwnerModel(Transformer.extractModelNameFromContext(this.name));
+        if (!modelName)
+            return null;
+        const enhancedModel = this.enhancedModels.find((em) => em.model.name === modelName);
+        if (!enhancedModel)
+            return null;
+        return (_b = (_a = enhancedModel.enhancedFields.find((ef) => ef.field.name === fieldName)) === null || _a === void 0 ? void 0 : _a.field) !== null && _b !== void 0 ? _b : null;
+    }
+    /**
+     * The model list field this schema is the `{ set }` / `{ push }` wrapper for, if it is one.
+     *
+     * Prisma emits one of these per list column, named `<Model><Create|Update><field>Input`,
+     * and its members are literally `set` and `push`. So the model cannot be read off the
+     * schema name by `extractModelNameFromContext` - and must not be taught to it, because
+     * that same function drives file naming and field filtering. It is resolved here instead,
+     * against the models actually in the schema.
+     *
+     * The longest matching model name wins, so `Foo` and `FooBar` both existing resolves
+     * `FooBarUpdatetagsInput` to `FooBar.tags` regardless of DMMF order.
+     */
+    listWrapperTarget() {
+        var _a, _b, _c;
+        if (this.listWrapperTargetCache !== undefined)
+            return this.listWrapperTargetCache;
+        let best = null;
+        for (const enhancedModel of this.enhancedModels) {
+            const modelName = enhancedModel.model.name;
+            if (best && modelName.length <= best.modelName.length)
+                continue;
+            const fieldName = (_b = (_a = this.name) === null || _a === void 0 ? void 0 : _a.match(new RegExp(`^${Transformer.escapeRegExp(modelName)}(?:Create|Update)(.+)Input$`))) === null || _b === void 0 ? void 0 : _b[1];
+            if (!fieldName)
+                continue;
+            const field = (_c = enhancedModel.enhancedFields.find((ef) => ef.field.name === fieldName && ef.field.isList)) === null || _c === void 0 ? void 0 : _c.field;
+            if (field)
+                best = { modelName, field };
+        }
+        this.listWrapperTargetCache = best;
+        return best;
+    }
+    /**
+     * The model field an input-object member should take its annotation from, if any.
+     *
+     * Normally that is the field of the same name. A list-operation wrapper is the exception:
+     * `set` and `push` are operations on the wrapped column, so the annotation belongs to
+     * that column. Looking a wrapper's members up by name would find nothing, or - once a
+     * model has a column actually *called* `set` - find an unrelated one and stamp its
+     * annotation onto every wrapper in the model.
+     */
+    typedJsonTargetForArg(argName) {
+        // A per-field copy of a shared update-operations input. Its name yields no model to
+        // the general extraction, and its `set` member holds a value of the column it was
+        // copied for, so the plan is the only thing that knows which column that is.
+        const copied = Transformer.typedFieldUpdateOperationsPlan.targetFor(this.name, argName);
+        if (copied)
+            return copied;
+        const wrapper = this.listWrapperTarget();
+        if (wrapper) {
+            // Only the operation members. Anything else in one of these files is not a value of
+            // the wrapped column and has no business carrying its annotation.
+            if (!emission_1.LIST_OPERATION_MEMBERS.has(argName))
+                return null;
+            return wrapper.field.documentation ? wrapper : null;
+        }
+        const modelName = this.typedJsonOwnerModel(Transformer.extractModelNameFromContext(this.name));
+        if (!modelName)
+            return null;
+        const field = this.getModelFieldForArg(argName);
+        return (field === null || field === void 0 ? void 0 : field.documentation) ? { modelName, field } : null;
+    }
+    /**
+     * Resolve a PJTG annotation for one input-object member, or `null` to leave it alone.
+     *
+     * Returning `null` is the default in every uncertain case, and `null` means "emit exactly
+     * what 3.0.0 emitted". Nothing here runs at all when `typedJson` is unconfigured.
+     */
+    typedJsonForField(field, inputType) {
+        const config = Transformer.getTypedJsonConfig();
+        if (!config)
+            return null;
+        if (!(0, emission_1.isTypedJsonInputType)(inputType.type))
+            return null;
+        if ((0, emission_1.isTypedJsonExcludedSchema)(this.name))
+            return null;
+        const target = this.typedJsonTargetForArg(field.name);
+        if (!(target === null || target === void 0 ? void 0 : target.field.documentation))
+            return null;
+        const result = (0, resolver_1.resolveTypedJsonField)({
+            modelName: target.modelName,
+            fieldName: target.field.name,
+            documentation: target.field.documentation,
+            // The DMMF arg carries the list-ness for this position; the model field is a
+            // list even where the arg is a single `push` value.
+            isList: inputType.isList,
+            isOptional: !field.isRequired,
+            outputSubdir: Transformer.typedJsonOutputSubdir('objects'),
+            importExtension: this.getImportFileExtension(),
+        }, config);
+        (0, emission_1.reportTypedJsonResult)(result, () => `${target.modelName}.${target.field.name}`);
+        return result.status === 'resolved' ? result : null;
+    }
+    /**
+     * Imports the typed-JSON expressions in this file need, merged to one per module and
+     * filtered to the names the file actually mentions.
+     */
+    getTypedJsonImportsForSchema(modelName, schemaContent) {
+        var _a, _b, _c, _d;
+        const config = Transformer.getTypedJsonConfig();
+        if (!config)
+            return [];
+        // A `{ set }` / `{ push }` wrapper's name does not yield its model to the general
+        // extraction, so it has to be resolved the way the members themselves are. Without
+        // this the wrapper references a schema it never imports - and the same is true of the
+        // `Unchecked` halves of a nested write, whose model the extraction reads wrong.
+        const owner = (_d = (_b = (_a = Transformer.typedFieldUpdateOperationsPlan.ownerOf(this.name)) !== null && _a !== void 0 ? _a : this.typedJsonOwnerModel(modelName)) !== null && _b !== void 0 ? _b : (_c = this.listWrapperTarget()) === null || _c === void 0 ? void 0 : _c.modelName) !== null && _d !== void 0 ? _d : null;
+        if (!owner)
+            return [];
+        const enhancedModel = this.enhancedModels.find((em) => em.model.name === owner);
+        if (!enhancedModel)
+            return [];
+        const collected = [];
+        for (const enhancedField of enhancedModel.enhancedFields) {
+            const documentation = enhancedField.field.documentation;
+            if (!documentation)
+                continue;
+            const result = (0, resolver_1.resolveTypedJsonField)({
+                modelName: owner,
+                fieldName: enhancedField.field.name,
+                documentation,
+                isList: enhancedField.field.isList,
+                outputSubdir: Transformer.typedJsonOutputSubdir('objects'),
+                importExtension: this.getImportFileExtension(),
+            }, config);
+            if (result.status === 'resolved')
+                collected.push(...result.imports);
+        }
+        return (0, emission_1.mergeTypedJsonImports)(collected, schemaContent, (0, singleFileAggregator_1.isSingleFileEnabled)());
+    }
+    /**
+     * Adjust relative import paths based on output directory structure
+     *
+     * @param importStatement - Original import statement
+     * @param outputPath - Current output path
+     * @returns Adjusted import statement
+     */
+    adjustRelativeImportPath(importStatement, _outputPath) {
+        // Previous logic attempted to rewrite relative paths heuristically. This is prone to
+        // breaking user-supplied paths, so we now trust the provided statement as-is.
+        return importStatement;
+    }
+    async generateObjectSchema() {
+        const zodObjectSchemaFields = this.generateObjectSchemaFields();
+        const objectSchema = this.prepareObjectSchema(zodObjectSchemaFields);
+        // Use input naming configuration for input objects
+        const inputNamingConfig = (0, naming_resolver_1.resolveInputNaming)(Transformer.getGeneratorConfig());
+        // Extract model name and input type from the object name
+        // Use input type as fallback to prevent filename collisions
+        const modelName = Transformer.extractModelNameFromContext(this.name);
+        const inputType = this.name;
+        const fileName = (0, naming_resolver_1.generateFileName)(inputNamingConfig.filePattern, modelName || inputType, undefined, // No operation
+        inputType);
+        await (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer.getSchemasPath(), `objects/${fileName}`), objectSchema);
+    }
+    generateObjectSchemaFields() {
+        // Determine context for field filtering
+        const modelName = Transformer.extractModelNameFromContext(this.name);
+        const variant = Transformer.determineSchemaVariant(this.name);
+        // Debug all schemas being processed
+        logger_1.logger.debug(`🔍 Processing: ${this.name}`);
+        // Debug: Log the raw context name and extracted model name
+        logger_1.logger.debug(`🔍 Schema context: "${this.name}" -> extracted model: "${modelName}"`);
+        // CRITICAL FIX: UpdateManyWithWhereWithout*Input DMMF Bug
+        // Prisma's DMMF is missing the required 'where' field for these types
+        if (/UpdateManyWithWhereWithout\w+Input$/.test(this.name)) {
+            logger_1.logger.debug(`🎯 MATCHED PATTERN: ${this.name}`);
+            logger_1.logger.debug(`   - Fields available: [${this.fields.map((f) => f.name).join(', ')}]`);
+            const hasWhereField = this.fields.some((f) => f.name === 'where');
+            logger_1.logger.debug(`   - Has where field: ${hasWhereField}`);
+            if (!hasWhereField && modelName) {
+                logger_1.logger.debug(`🔧 FIXING DMMF BUG: Adding missing 'where' field to ${this.name}`);
+                // Create a synthetic 'where' field that references the model's ScalarWhereInput type
+                const syntheticWhereField = {
+                    isParameterizable: false,
+                    name: 'where',
+                    isNullable: false,
+                    isRequired: true,
+                    inputTypes: [
+                        {
+                            type: `${modelName}ScalarWhereInput`,
+                            namespace: 'prisma',
+                            location: 'inputObjectTypes',
+                            isList: false,
+                        },
+                    ],
+                };
+                // Inject the missing field
+                this.fields = [...this.fields, syntheticWhereField];
+                logger_1.logger.debug(`   ✅ Added synthetic where field for ${modelName}ScalarWhereInput`);
+            }
+        }
+        // Apply field filtering
+        const originalFieldCount = this.fields.length;
+        let filteredFields = Transformer.filterFields(this.fields, modelName || undefined, variant, this.models, this.name);
+        // Special handling for UpdateManyWithWhereWithout*Input patterns - ensure 'where' field is preserved
+        if (/UpdateManyWithWhereWithout\w+Input$/.test(this.name)) {
+            const whereField = this.fields.find((f) => f.name === 'where');
+            const hasWhereInFiltered = filteredFields.some((f) => f.name === 'where');
+            if (whereField && !hasWhereInFiltered) {
+                logger_1.logger.debug(`  - Restoring filtered 'where' field for ${this.name}`);
+                filteredFields = [...filteredFields, whereField];
+            }
+            else if (!whereField) {
+                // If the where field doesn't exist in the original fields, this might indicate a DMMF issue
+                // We need to manually construct the missing where field based on the pattern
+                logger_1.logger.debug(`  - 'where' field missing from DMMF for ${this.name}, attempting to fix in prepareObjectSchema`);
+            }
+        }
+        // Compute excluded field names for this schema context
+        const excluded = this.fields
+            .filter((orig) => !filteredFields.some((f) => f.name === orig.name))
+            .map((f) => f.name);
+        this.lastExcludedFieldNames = excluded.length > 0 ? excluded : [];
+        // Log field filtering if any fields were excluded
+        Transformer.logFieldFiltering(originalFieldCount, filteredFields.length, modelName || undefined, variant);
+        const zodObjectSchemaFields = filteredFields
+            .map((field) => this.generateObjectSchemaField(field))
+            .flatMap((item) => item)
+            .map((item) => {
+            const [zodStringWithMainType, field, skipValidators] = item;
+            const value = skipValidators
+                ? zodStringWithMainType
+                : this.generateFieldValidators(zodStringWithMainType, field);
+            return value.trim();
+        });
+        return zodObjectSchemaFields;
+    }
+    /**
+     * The replacement text to compose into a property line, given where it is about to land.
+     *
+     * A typed replacement is the user's schema and the emitter does not rewrite it, with one
+     * exception that is not a rewrite so much as a division of labour: a marker at the TOP
+     * LEVEL of the replacement answers a question the emitter has already answered from the
+     * DMMF, and only one of the two answers can be right.
+     *
+     * Every object schema is cast to the Prisma input type for the same operation, so
+     * whether a key may be omitted and whether it admits `null` are facts about the column,
+     * not opinions the annotation gets to hold. `![string | undefined]` on a required column
+     * would make a required key omittable; `![{ a: string } | null]` on a required `Json`
+     * column would accept a bare `null` where `Prisma.<M>CreateInput` says
+     * `JsonNullValueInput | InputJsonValue` and means `Prisma.JsonNull`. Both are payloads
+     * the type the schema is cast to rejects. So a trailing run of markers comes off here and
+     * the emitter's own optional/nullable policy re-applies whatever the column actually
+     * says - which is also why an annotation that agrees with the column no longer emits its
+     * marker twice.
+     *
+     * Nothing else in the replacement is touched. `{ a: string; b?: number }` keeps `b`
+     * optional, and so does an element inside a `z.array(...)` the annotation wrote itself:
+     * those markers are nowhere near the top level and describe the user's own type.
+     *
+     * The `isList` case is the reason this takes an `inputType` rather than working on the
+     * string alone. On a list field the replacement is the ELEMENT schema and
+     * `wrapWithZodValidators` is about to append `.array()` to it, so its trailing marker
+     * ends up under that wrapper describing an element rather than the field. Prisma's
+     * `InputJsonArray` is `ReadonlyArray<InputJsonValue | null>`, so a null element is a
+     * value it really does accept, and the condition below is the same one the wrapper
+     * itself uses to decide whether to append.
+     */
+    static typedJsonSlotExpression(expression, inputType) {
+        const willWrapInArray = inputType.isList && !expression.includes('.array()');
+        if (willWrapInArray)
+            return expression;
+        return expression.replace(TYPED_JSON_TRAILING_OPTIONALITY, '');
+    }
+    /**
+     * Run an optionality strip over a composed property line without letting it reach
+     * inside a typed-JSON replacement.
+     *
+     * The strips exist for the OUTER expression and are load-bearing there: every
+     * alternative arrives from `wrapWithZodValidators` already carrying `.optional()`, a
+     * union adds its own tail, and the optional/nullable policy below re-applies exactly
+     * one marker. Left unstripped that composes two markers where the policy allows one.
+     *
+     * Inside a typed replacement is not the emitter's to strip, though. That is the user's
+     * schema, and `{ a: string; b?: number }` means `b` is optional in every artifact that
+     * reads the annotation - the pure model and the result schema both say so. Masking each
+     * replacement to an opaque token keeps the outer strip doing its job while what it
+     * covers passes through byte for byte.
+     *
+     * What it covers is `typedJsonSlotExpression`'s answer, which is the replacement with
+     * the top-level markers the emitter owns already removed. So the two halves compose
+     * rather than fight: the emitter decides the outermost marker, the annotation decides
+     * every marker under it, and neither reaches into the other.
+     *
+     * Nothing is ever collected without a `typedJson` block, so for everyone else this is
+     * exactly `strip(expression)`.
+     */
+    static withTypedJsonMasked(expression, typedJsonExpressions, strip) {
+        if (typedJsonExpressions.size === 0)
+            return strip(expression);
+        // Longest first: one replacement can contain another (`TagSchema` inside
+        // `z.array(TagSchema)`), and masking the shorter one first would leave the rest of
+        // the longer one exposed to the strip.
+        const masked = [...typedJsonExpressions].sort((a, b) => b.length - a.length);
+        // Delimited at both ends, so restoring token 1 cannot chew the head off token 11.
+        const token = (index) => `${TYPED_JSON_MASK}${index}${TYPED_JSON_MASK}`;
+        let result = expression;
+        masked.forEach((value, index) => {
+            result = result.split(value).join(token(index));
+        });
+        result = strip(result);
+        masked.forEach((value, index) => {
+            result = result.split(token(index)).join(value);
+        });
+        return result;
+    }
+    generateObjectSchemaField(field) {
+        var _a, _b;
+        const lines = field.inputTypes;
+        if (lines.length === 0) {
+            return [];
+        }
+        /**
+         * Typed replacements used in this property line, kept out of the optionality strips
+         * below. Empty unless `typedJson` is configured, which is what leaves those strips
+         * byte-identical for everybody else.
+         *
+         * What goes in the set is what was composed into the line, which is the replacement
+         * minus whatever `typedJsonSlotExpression` handed back to the emitter. So the mask
+         * protects the user's schema and nothing more: the emitter's own markers, including
+         * the one the annotation duplicated, are still in front of the strips.
+         */
+        const typedJsonExpressions = new Set();
+        const typedJsonBase = (typedJson, inputType) => {
+            const resolved = typedJson === null || typedJson === void 0 ? void 0 : typedJson.elementExpression;
+            if (!resolved)
+                return undefined;
+            const expression = Transformer.typedJsonSlotExpression(resolved, inputType);
+            typedJsonExpressions.add(expression);
+            return expression;
+        };
+        let alternatives = lines.reduce((result, inputType) => {
+            var _a;
+            // Skip inputTypes that reference blocked schemas in minimal mode
+            if (inputType.location === 'inputObjectTypes' && typeof inputType.type === 'string') {
+                if (!this.isSchemaImportEnabled(inputType.type)) {
+                    return result; // Skip this inputType
+                }
+            }
+            if (inputType.type === 'String') {
+                // Check for custom schema from @zod.import() annotations
+                const typedJson = this.typedJsonForField(field, inputType);
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = typedJsonBase(typedJson, inputType) || customSchema || 'z.string()';
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema || !!typedJson, 
+                // `@db.VarChar(n)` appends `.max(n)` to whatever the base is, and
+                // `z.enum([...]).max(8)` throws TypeError the moment the module loads.
+                typedJson ? typedJson.allowsStringLengthConstraints : true));
+            }
+            else if (inputType.type === 'Boolean') {
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = customSchema || 'z.boolean()';
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema));
+            }
+            else if (inputType.type === 'Int') {
+                const typedJson = this.typedJsonForField(field, inputType);
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = typedJsonBase(typedJson, inputType) || customSchema || 'z.number().int()';
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema || !!typedJson));
+            }
+            else if (inputType.type === 'Float') {
+                const typedJson = this.typedJsonForField(field, inputType);
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = typedJsonBase(typedJson, inputType) || customSchema || 'z.number()';
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema || !!typedJson));
+            }
+            else if (inputType.type === 'Decimal') {
+                const cfg = Transformer.getGeneratorConfig();
+                const mode = (cfg === null || cfg === void 0 ? void 0 : cfg.decimalMode) || 'decimal';
+                let decimalExpr = 'z.number()'; // fallback
+                if (mode === 'decimal') {
+                    // Use helper schema with union + refine for input validation
+                    this.hasDecimal = true; // Track that we need decimal helpers
+                    decimalExpr = (0, decimal_helpers_1.generateDecimalInputSchema)('z', (0, decimal_helpers_1.isDecimalJsAvailable)(), field.name);
+                }
+                else if (mode === 'string') {
+                    decimalExpr = 'z.string()';
+                }
+                else {
+                    decimalExpr = 'z.number()';
+                }
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = customSchema || decimalExpr;
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema));
+            }
+            else if (inputType.type === 'BigInt') {
+                let bigintExpr = 'z.bigint()';
+                // JSON Schema compatibility mode overrides normal behavior
+                if (Transformer.isJsonSchemaModeEnabled()) {
+                    const { bigIntFormat } = Transformer.getJsonSchemaOptions();
+                    const format = bigIntFormat || 'string';
+                    if (format === 'string') {
+                        // Allow optional leading minus for negative bigint strings
+                        bigintExpr = 'z.string().regex(/^-?\\d+$/, "Invalid bigint string")';
+                    }
+                    else {
+                        bigintExpr = 'z.number().int()'; // Note: May lose precision for very large numbers
+                    }
+                }
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = customSchema || bigintExpr;
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema));
+            }
+            else if (inputType.type === 'DateTime') {
+                // Apply configurable DateTime strategy
+                const cfg = Transformer.getGeneratorConfig();
+                const target = ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.zodImportTarget) !== null && _a !== void 0 ? _a : 'auto');
+                let dateExpr = 'z.date()';
+                // JSON Schema compatibility mode overrides all other strategies
+                if (Transformer.isJsonSchemaModeEnabled()) {
+                    const { dateTimeFormat } = Transformer.getJsonSchemaOptions();
+                    const format = dateTimeFormat || 'isoString';
+                    if (format === 'isoDate') {
+                        dateExpr = 'z.string().regex(/^\\d{4}-\\d{2}-\\d{2}$/, "Invalid ISO date")';
+                    }
+                    else {
+                        // isoString - validate RFC3339 date-time (optional fraction, timezone offsets)
+                        dateExpr =
+                            'z.string().regex(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$/, "Invalid RFC3339 date-time")';
+                    }
+                }
+                else if ((cfg === null || cfg === void 0 ? void 0 : cfg.dateTimeStrategy) === 'coerce') {
+                    dateExpr = 'z.coerce.date()';
+                }
+                else if ((cfg === null || cfg === void 0 ? void 0 : cfg.dateTimeStrategy) === 'isoString') {
+                    // For v4, use the modern z.iso.datetime() API, otherwise use regex validation
+                    if (target === 'v4') {
+                        dateExpr = 'z.iso.datetime().transform(v => new Date(v))';
+                    }
+                    else {
+                        // ISO string validated then transformed to Date
+                        dateExpr =
+                            'z.string().regex(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/, "Invalid ISO datetime").transform(v => new Date(v))';
+                    }
+                }
+                else {
+                    // No explicit strategy set. If split strategy is enabled, use variant-aware default:
+                    // inputs => coerce; pure/result => date
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.dateTimeSplitStrategy) === true) {
+                        const variant = Transformer.determineSchemaVariant(this.name);
+                        if (variant === 'input') {
+                            dateExpr = 'z.coerce.date()';
+                        }
+                        else {
+                            dateExpr = 'z.date()';
+                        }
+                    }
+                }
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = customSchema || dateExpr;
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema));
+            }
+            else if (inputType.type === 'Json') {
+                const typedJson = this.typedJsonForField(field, inputType);
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = typedJsonBase(typedJson, inputType) || customSchema || 'jsonSchema';
+                // A typed field no longer mentions `jsonSchema`, so flagging it would emit an
+                // unused import. Gated on typedJson specifically, not on the resulting expression:
+                // the `@zod.custom.use` path has always set this and must keep doing so, or every
+                // schema using that escape hatch changes.
+                if (!typedJson)
+                    this.hasJson = true;
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema || !!typedJson));
+            }
+            else if (inputType.type === 'True') {
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = customSchema || 'z.literal(true)';
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema));
+            }
+            else if (inputType.type === 'Bytes') {
+                let bytesExpr = 'z.instanceof(Uint8Array)';
+                // JSON Schema compatibility mode overrides normal behavior
+                if (Transformer.isJsonSchemaModeEnabled()) {
+                    const { bytesFormat } = Transformer.getJsonSchemaOptions();
+                    const format = bytesFormat || 'base64String';
+                    if (format === 'base64String') {
+                        // Proper 4-char blocks with valid terminal padding
+                        bytesExpr =
+                            'z.string().regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=)?$/, "Invalid base64 string")';
+                    }
+                    else {
+                        // Even number of hex chars
+                        bytesExpr = 'z.string().regex(/^(?:[0-9a-fA-F]{2})+$/, "Invalid hex string")';
+                    }
+                }
+                const customSchema = this.getCustomSchemaForField(field.name);
+                const baseSchema = customSchema || bytesExpr;
+                result.push(this.wrapWithZodValidators(baseSchema, field, inputType, !!customSchema));
+            }
+            else {
+                const isEnum = inputType.location === 'enumTypes';
+                if (inputType.namespace === 'prisma' && !isEnum) {
+                    // Prisma object/nested input types: use the standard generator path
+                    if (inputType.type !== this.name && typeof inputType.type === 'string') {
+                        this.addSchemaImport(inputType.type);
+                    }
+                    result.push(this.generatePrismaStringLine(field, inputType, lines.length));
+                }
+                else if (isEnum) {
+                    // Enum types: build the correct enum schema reference then apply @zod validations
+                    if (typeof inputType.type === 'string') {
+                        // Ensure enum schema import is tracked
+                        this.addSchemaImport(inputType.type);
+                    }
+                    // Resolve enum export name via naming resolver (mirrors generatePrismaStringLine)
+                    const enumNamingConfig = (0, naming_resolver_1.resolveEnumNaming)(Transformer.getGeneratorConfig());
+                    const enumSchemaLine = (0, naming_resolver_1.generateExportName)(enumNamingConfig.exportNamePattern, inputType.type, undefined, undefined, inputType.type);
+                    const baseSchema = enumSchemaLine;
+                    result.push(this.wrapWithZodValidators(baseSchema, field, inputType));
+                }
+            }
+            return result;
+        }, []);
+        if (alternatives.length === 0) {
+            return [];
+        }
+        // If any alternative uses a getter-based property (v4 recursion),
+        // treat it as a complete property entry and skip wrapper/optionality tweaks.
+        const hasGetterAlternative = alternatives.some((alt) => alt.trimStart().startsWith('get '));
+        if (hasGetterAlternative) {
+            const cleaned = alternatives.map((alt) => alt.replace(/,\s*$/, ''));
+            const final = cleaned.join(', ');
+            return [[`  ${final}`, field, true]];
+        }
+        if (alternatives.length > 1) {
+            alternatives = alternatives.map((alter) => Transformer.withTypedJsonMasked(alter, typedJsonExpressions, (value) => value.replace('.optional()', '')));
+        }
+        // Check if ALL alternatives already include the field name
+        // This happens when inputsLength === 1 for all alternatives
+        // We check if alternatives start with the field name pattern (spaces + fieldname + colon)
+        const fieldNamePattern = `  ${field.name}:`;
+        const allAlternativesHaveFieldName = alternatives.every((alt) => alt.startsWith(fieldNamePattern));
+        const fieldName = allAlternativesHaveFieldName ? '' : fieldNamePattern;
+        // Base optional marker; union gets a trailing optional which we'll normalize below
+        const opt = !field.isRequired ? '.optional()' : '';
+        let resString = alternatives.length === 1
+            ? alternatives.join(', ')
+            : `z.union([${alternatives.join(', ')}])${opt}`;
+        // Policy fix:
+        // - Keep relation fields as optional only (no nullable)
+        // - For non-relation fields that are optional, append .optional().nullable()
+        // - For required-but-nullable fields, append .nullable()
+        const isRelationArg = Transformer.isRelationFieldArg(field) ||
+            [
+                'create',
+                'connectOrCreate',
+                'connect',
+                'disconnect',
+                'delete',
+                'update',
+                'upsert',
+                'set',
+                'updateMany',
+                'deleteMany',
+                'createMany',
+            ].includes(field.name);
+        // Strip any existing optional/nullable/nullish from the composed string; we will re-apply
+        resString = Transformer.withTypedJsonMasked(resString, typedJsonExpressions, (value) => value
+            .replace(/\.optional\(\)/g, '')
+            .replace(/\.nullish\(\)/g, '')
+            .replace(/\.nullable\(\)/g, ''));
+        let isRequired = field.isRequired;
+        if (this.name.includes('CreateInput')) {
+            const modelName = Transformer.extractModelNameFromContext(this.name);
+            if (modelName) {
+                const model = this.models.find((m) => m.name === modelName);
+                if (model) {
+                    const modelField = model.fields.find((f) => f.name === field.name);
+                    if (modelField) {
+                        if (modelField.isUpdatedAt) {
+                            return [];
+                        }
+                        const isListField = modelField.isList;
+                        if (isListField) {
+                            // Prisma marks list fields (relation or scalar) as required in the datamodel,
+                            // but the generated CreateInput/UncheckedCreateInput types expose them as optional.
+                            // Treat them as optional to stay aligned with @prisma/client.
+                            isRequired = false;
+                        }
+                        else {
+                            // DMMF schema.inputObjectTypes isRequired is the source of truth — it is
+                            // exactly what @prisma/client's input types are generated from. The datamodel
+                            // recompute may only relax requiredness (e.g. a field with a default becomes
+                            // optional); it must never promote a DMMF-optional field to required
+                            // (e.g. a to-one relation whose FK scalar has a default).
+                            isRequired = field.isRequired && modelField.isRequired && !modelField.hasDefaultValue;
+                        }
+                    }
+                }
+            }
+        }
+        if (!isRequired) {
+            resString += '.optional()';
+        }
+        if (field.isNullable && !isRelationArg) {
+            resString += '.nullable()';
+        }
+        // Zod v4 target: object schema references composed eagerly (e.g. inside
+        // z.union([...])) dereference other module-scope consts before they are
+        // initialized (TDZ/undefined crashes on forward or circular references).
+        // Wrap the whole composed expression in a getter so resolution is deferred
+        // to first parse, mirroring v3's z.lazy semantics.
+        const unionTarget = ((_b = (_a = Transformer.getGeneratorConfig()) === null || _a === void 0 ? void 0 : _a.zodImportTarget) !== null && _b !== void 0 ? _b : 'auto');
+        const hasObjectSchemaRef = field.inputTypes.some((it) => it.type === this.name || (it.namespace === 'prisma' && it.location !== 'enumTypes'));
+        if (unionTarget === 'v4' && hasObjectSchemaRef) {
+            return [[`  get ${field.name}(){ return ${resString.trim()}; }`, field, true]];
+        }
+        return [[`  ${fieldName} ${resString} `, field, true]];
+    }
+    wrapWithZodValidators(mainValidator, field, inputType, skipZodAnnotations = false, 
+    /**
+     * Whether a native `@db.VarChar(n)` length may still be appended to the base.
+     *
+     * False only for a typed replacement that is not rooted in `z.string()`. The native-max
+     * block rewrites the leading `z.…(…)` call, so `!['A' | 'B']` on a `String @db.VarChar(8)`
+     * would emit `z.enum(['A','B']).max(8)` - a module that throws `TypeError` on import.
+     */
+    allowNativeMaxLength = true) {
+        var _a;
+        let line = mainValidator;
+        let hasEnhancedZodSchema = false;
+        // Track when we composed from a dot-prefixed validation chain (e.g., ".min(1)")
+        // This helps us place array() in the correct position for list fields
+        let composedFromChainOnly = false;
+        let composedBaseForChain = null;
+        let composedChainOnly = null;
+        // Re-enabled @zod comment validations
+        try {
+            // Add safety check to prevent infinite loops
+            if (field.name && typeof field.name === 'string' && field.name.length > 0) {
+                const zodValidations = this.extractZodValidationsForField(field.name, field);
+                if (!skipZodAnnotations && zodValidations) {
+                    const base = (mainValidator !== null && mainValidator !== void 0 ? mainValidator : '').trim();
+                    const chain = zodValidations.trim();
+                    const isChainOnly = chain.startsWith('.');
+                    // When the annotation is a dot-prefixed chain (e.g., .min(1)),
+                    // always compose it with the base (whether the base is a reference
+                    // or a z.* constructor). This avoids producing chain-only sequences
+                    // like ".min(1)" and preserves proper ordering for lists where
+                    // we later need to place array() before the chain.
+                    if (base && isChainOnly) {
+                        line = `${base}${chain}`;
+                        composedFromChainOnly = true;
+                        composedBaseForChain = base;
+                        composedChainOnly = chain;
+                    }
+                    else {
+                        // Otherwise, use the provided validations as-is (covers full schemas
+                        // like z.email(), z.enum([...]), z.array(...).min(), etc.)
+                        line = chain;
+                    }
+                    hasEnhancedZodSchema = true;
+                }
+            }
+        }
+        catch (error) {
+            // If @zod processing fails, continue with the default validator
+            console.warn(`Failed to process @zod comments for field ${field.name}:`, error);
+        }
+        // Apply native type constraints (e.g., @db.VarChar(255) -> .max(255))
+        // Only for String types and only if no enhanced Zod schema is already applied
+        if (inputType.type === 'String' && field.name && allowNativeMaxLength) {
+            const nativeMaxLength = this.extractMaxLengthFromNativeType(field);
+            const existingMaxConstraint = hasEnhancedZodSchema
+                ? this.extractExistingMaxConstraint(line)
+                : null;
+            if (nativeMaxLength !== null) {
+                if (hasEnhancedZodSchema && existingMaxConstraint !== null) {
+                    // Both native type and @zod.max exist - use the more restrictive one
+                    const finalMaxLength = Math.min(nativeMaxLength, existingMaxConstraint);
+                    line = this.replaceAllMaxConstraints(line, finalMaxLength);
+                }
+                else if (hasEnhancedZodSchema && existingMaxConstraint === null) {
+                    // Enhanced @zod schema exists but no max constraint - add native constraint
+                    line = this.replaceAllMaxConstraints(line, nativeMaxLength);
+                }
+                else if (!hasEnhancedZodSchema) {
+                    // Only native type constraint exists - apply it to the base validator
+                    line = this.replaceAllMaxConstraints(line, nativeMaxLength);
+                }
+            }
+        }
+        if (inputType.isList) {
+            if (inputType.type === 'DateTime') {
+                // In JSON Schema compatibility mode, Date is not representable; use string[]
+                if (Transformer.isJsonSchemaModeEnabled()) {
+                    const { dateTimeFormat } = Transformer.getJsonSchemaOptions();
+                    const format = dateTimeFormat || 'isoString';
+                    const strExpr = format === 'isoDate'
+                        ? 'z.string().regex(/^\\d{4}-\\d{2}-\\d{2}$/,"Invalid ISO date")'
+                        : 'z.string().regex(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$/,"Invalid RFC3339 date-time")';
+                    line = `${strExpr}.array()`;
+                }
+                else {
+                    // For DateTime lists, support both Date and ISO datetime arrays
+                    const cfg = Transformer.getGeneratorConfig();
+                    const target = ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.zodImportTarget) !== null && _a !== void 0 ? _a : 'auto');
+                    const datetimeValidator = target === 'v4' ? 'z.iso.datetime()' : 'z.string().datetime()';
+                    line = `z.union([z.date().array(), ${datetimeValidator}.array()])`;
+                }
+            }
+            else {
+                // Append array() only once to avoid duplication. Do NOT treat z.array(...)
+                // as an existing .array() call — tests expect a trailing .array() even if
+                // the base is already wrapped with z.array(...).
+                if (!line.includes('.array()')) {
+                    if (composedFromChainOnly && composedBaseForChain && composedChainOnly) {
+                        // Compose as: Base.array().<chain> then allow the final safety to normalize
+                        line = `${composedBaseForChain}.array()${composedChainOnly}`;
+                    }
+                    else {
+                        line += '.array()';
+                    }
+                }
+            }
+        }
+        // Handle optionality correctly - add .optional() before any validations if field is optional
+        if (!field.isRequired) {
+            if (hasEnhancedZodSchema) {
+                // For enhanced schemas, check if optionality is already handled
+                if (!line.includes('.optional()') && !line.includes('.nullable()')) {
+                    // Extract base type and validations, then reorder
+                    // For enhanced Zod schemas like "z.string().email()", we need to carefully split
+                    // to avoid duplicating the base type in the validations part
+                    const baseTypeMatch = line.match(/^(z\.[^.(]+(?:\([^)]*\))?)/);
+                    if (baseTypeMatch) {
+                        const baseType = baseTypeMatch[1]; // e.g., "z.string"
+                        const afterBaseType = line.substring(baseType.length); // e.g., "().email()"
+                        const validationsMatch = afterBaseType.match(/^(\(\))?(.*)$/);
+                        if (validationsMatch) {
+                            const baseCall = validationsMatch[1] || ''; // e.g., "()"
+                            const actualValidations = validationsMatch[2]; // e.g., ".email()"
+                            line = `${baseType}${baseCall}${actualValidations}.optional()`;
+                        }
+                        else {
+                            line += '.optional()';
+                        }
+                    }
+                    else {
+                        line += '.optional()';
+                    }
+                }
+            }
+            else {
+                line += '.optional()';
+            }
+        }
+        // Final safety: collapse any accidental duplicate array() chaining (e.g., .array().array())
+        line = line.replace(/(\.array\(\))+$/, '.array()');
+        return line;
+    }
+    addSchemaImport(name) {
+        // Only add import if the schema is enabled
+        if (this.isSchemaImportEnabled(name)) {
+            this.schemaImports.add(name);
+        }
+    }
+    /**
+     * Check if a schema import should be included based on minimal mode configuration
+     */
+    isSchemaImportEnabled(schemaName) {
+        // Skip model checking for enum names - enums are always allowed
+        if (Transformer.enumNames.includes(schemaName)) {
+            return true;
+        }
+        // Allow scalar/enum filter and field update helper types regardless of model gating
+        // These helper types are not tied to a single model in Prisma v6
+        const helperTypePatterns = [
+            /^(?:Enum\w+NullableFilter|Enum\w+Filter)$/,
+            /^(?:\w+NullableFilter|\w+Filter)$/,
+            /^(?:\w+WithAggregatesFilter|Nested\w+Filter|Nested\w+WithAggregatesFilter)$/,
+            /^(?:\w+FieldUpdateOperationsInput|Nullable\w+FieldUpdateOperationsInput)$/,
+        ];
+        if (helperTypePatterns.some((p) => p.test(schemaName))) {
+            return true;
+        }
+        // First check if the related model is enabled
+        const modelName = this.extractModelNameFromSchema(schemaName);
+        if (modelName && !Transformer.isModelEnabled(modelName)) {
+            return false; // Don't import schemas for disabled models
+        }
+        const config = Transformer.getGeneratorConfig();
+        if ((config === null || config === void 0 ? void 0 : config.mode) !== 'minimal') {
+            return true; // Allow all imports in non-minimal mode (if model is enabled)
+        }
+        // In minimal mode, check against the same patterns used in isObjectSchemaEnabled
+        const disallowedPatterns = [
+            // Block Include/Select helper schemas entirely in minimal mode
+            /Args$/,
+            /Include$/,
+            /Select$/,
+            /OrderByWithAggregationInput$/,
+            /ScalarWhereWithAggregatesInput$/,
+            /CountAggregateInput$/,
+            /AvgAggregateInput$/,
+            /SumAggregateInput$/,
+            /MinAggregateInput$/,
+            /MaxAggregateInput$/,
+            // Deep or relation-heavy object inputs
+            /CreateNested\w+Input$/,
+            /UpdateNested\w+Input$/,
+            /UpsertNested\w+Input$/,
+            /CreateWithout\w+Input$/,
+            /UncheckedCreateWithout\w+Input$/,
+            /UpdateWithout\w+Input$/,
+            /UncheckedUpdateWithout\w+Input$/,
+            /UpsertWithout\w+Input$/,
+            /UpdateManyWithout\w+NestedInput$/,
+            /UncheckedUpdateManyWithout\w+NestedInput$/,
+            /CreateMany\w+InputEnvelope$/,
+            /ListRelationFilter$/,
+            /RelationFilter$/,
+            /ScalarRelationFilter$/,
+            // Block schemas that depend on blocked Without schemas
+            /CreateOrConnectWithout\w+Input$/,
+            /CreateManyWithout\w+Input$/,
+            /UpdateToOneWithWhereWithout\w+Input$/,
+            /UpdateOneWithout\w+NestedInput$/,
+            /UpdateOneRequiredWithout\w+NestedInput$/,
+            /UpdateManyWithWhereWithout\w+Input$/,
+            /UpdateWithWhereUniqueWithout\w+Input$/,
+        ];
+        if (disallowedPatterns.some((p) => p.test(schemaName))) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Extract model name from schema name for import filtering
+     */
+    extractModelNameFromSchema(schemaName) {
+        // Common patterns for Prisma object schema names - same as in prisma-generator.ts
+        const patterns = [
+            // Most specific patterns first to avoid false matches
+            /^(\w+)UncheckedCreateNestedManyWithout\w+Input$/,
+            /^(\w+)UncheckedUpdateManyWithout\w+Input$/,
+            /^(\w+)UncheckedUpdateManyWithout\w+NestedInput$/,
+            /^(\w+)UncheckedCreateWithout\w+Input$/,
+            /^(\w+)UncheckedUpdateWithout\w+Input$/,
+            /^(\w+)CreateNestedOneWithout\w+Input$/,
+            /^(\w+)CreateNestedManyWithout\w+Input$/,
+            /^(\w+)UpdateNestedOneWithout\w+Input$/,
+            /^(\w+)UpdateNestedManyWithout\w+Input$/,
+            /^(\w+)UpsertNestedOneWithout\w+Input$/,
+            /^(\w+)UpsertNestedManyWithout\w+Input$/,
+            /^(\w+)CreateOrConnectWithout\w+Input$/,
+            /^(\w+)UpdateOneRequiredWithout\w+NestedInput$/,
+            /^(\w+)UpdateToOneWithWhereWithout\w+Input$/,
+            /^(\w+)UpsertWithout\w+Input$/,
+            /^(\w+)CreateWithout\w+Input$/,
+            /^(\w+)UpdateWithout\w+Input$/,
+            /^(\w+)UpdateManyWithWhereWithout\w+Input$/,
+            /^(\w+)UpdateWithWhereUniqueWithout\w+Input$/,
+            /^(\w+)UpsertWithWhereUniqueWithout\w+Input$/,
+            /^(\w+)UpdateManyWithout\w+NestedInput$/,
+            /^(\w+)CreateManyAuthorInput$/,
+            /^(\w+)CreateManyAuthorInputEnvelope$/,
+            /^(\w+)ScalarWhereInput$/,
+            // Basic input types - more specific patterns first
+            /^(\w+)UncheckedCreateInput$/,
+            /^(\w+)UncheckedUpdateInput$/,
+            /^(\w+)UncheckedUpdateManyInput$/,
+            /^(\w+)UpdateManyMutationInput$/,
+            /^(\w+)WhereUniqueInput$/,
+            /^(\w+)CreateManyInput$/,
+            /^(\w+)UpdateManyInput$/,
+            /^(\w+)WhereInput$/,
+            /^(\w+)CreateInput$/,
+            /^(\w+)UpdateInput$/,
+            // Order by inputs
+            /^(\w+)OrderByWithRelationInput$/,
+            /^(\w+)OrderByWithAggregationInput$/,
+            /^(\w+)OrderByRelationAggregateInput$/,
+            // Filter inputs
+            /^(\w+)ScalarWhereInput$/,
+            /^(\w+)ScalarWhereWithAggregatesInput$/,
+            /^(\w+)ListRelationFilter$/,
+            /^(\w+)RelationFilter$/,
+            /^(\w+)ScalarRelationFilter$/,
+            // Aggregate inputs
+            /^(\w+)CountAggregateInput$/,
+            /^(\w+)CountOrderByAggregateInput$/,
+            /^(\w+)AvgAggregateInput$/,
+            /^(\w+)AvgOrderByAggregateInput$/,
+            /^(\w+)MaxAggregateInput$/,
+            /^(\w+)MaxOrderByAggregateInput$/,
+            /^(\w+)MinAggregateInput$/,
+            /^(\w+)MinOrderByAggregateInput$/,
+            /^(\w+)SumAggregateInput$/,
+            /^(\w+)SumOrderByAggregateInput$/,
+            // Args and other schemas
+            /^(\w+)Args$/,
+            /^(\w+)CountOutputTypeArgs$/,
+            // Filter types - handle these specially as they may be phantom types
+            /^Enum(\w+)NullableFilter$/,
+            /^Enum(\w+)Filter$/,
+            /^(\w+)NullableFilter$/,
+            /^(\w+)Filter$/,
+        ];
+        for (const pattern of patterns) {
+            const match = schemaName.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        // Fallback for any other schema names
+        const fallbackMatch = schemaName.match(/^([A-Z][a-zA-Z0-9]*)/);
+        return fallbackMatch ? fallbackMatch[1] : null;
+    }
+    /**
+     * Extract max length constraint from native type (e.g., @db.VarChar(255) -> 255)
+     */
+    extractMaxLengthFromNativeType(field) {
+        // Check if the field has the enhanced field information with native type
+        if (!this.enhancedModels || !field.name) {
+            return null;
+        }
+        // Extract model name from the current transformer context
+        const modelName = Transformer.extractModelNameFromContext(this.name);
+        if (!modelName) {
+            return null;
+        }
+        // Find the enhanced model information
+        const enhancedModel = this.enhancedModels.find((em) => em.model.name === modelName);
+        if (!enhancedModel) {
+            return null;
+        }
+        // Find the enhanced field information
+        const enhancedField = enhancedModel.enhancedFields.find((ef) => ef.field.name === field.name);
+        if (!enhancedField || !enhancedField.field.nativeType) {
+            return null;
+        }
+        const nativeType = enhancedField.field.nativeType;
+        // nativeType is an array: [typeName, [param1, param2, ...]]
+        if (!Array.isArray(nativeType) || nativeType.length < 2) {
+            return null;
+        }
+        const [typeName, params] = nativeType;
+        // Handle string length constraints for various native types
+        if (typeof typeName === 'string') {
+            // SQL database string types with explicit length parameters
+            if (Array.isArray(params) && params.length > 0) {
+                const supportedTypes = ['VarChar', 'Char', 'NVarChar', 'NChar', 'VARCHAR', 'CHAR'];
+                if (supportedTypes.includes(typeName)) {
+                    const lengthParam = params[0];
+                    const maxLength = parseInt(lengthParam, 10);
+                    if (!isNaN(maxLength) && maxLength > 0) {
+                        return maxLength;
+                    }
+                }
+            }
+            // MongoDB ObjectId has a fixed length (24 hex characters)
+            if (typeName === 'ObjectId') {
+                return 24;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract existing max constraint from @zod validations
+     */
+    extractExistingMaxConstraint(zodValidation) {
+        if (!zodValidation) {
+            return null;
+        }
+        // Look for all .max(number) in the validation string and return the most restrictive
+        const maxMatches = zodValidation.match(/\.max\((\d+)\)/g);
+        if (maxMatches && maxMatches.length > 0) {
+            let minMax = Infinity;
+            for (const match of maxMatches) {
+                const valueMatch = match.match(/\.max\((\d+)\)/);
+                if (valueMatch) {
+                    const maxValue = parseInt(valueMatch[1], 10);
+                    if (!isNaN(maxValue) && maxValue > 0) {
+                        minMax = Math.min(minMax, maxValue);
+                    }
+                }
+            }
+            return minMax === Infinity ? null : minMax;
+        }
+        return null;
+    }
+    /**
+     * Replace all max constraints in a validation string with a single constraint
+     */
+    replaceAllMaxConstraints(validationString, newMaxValue) {
+        // Strip any existing .max() constraints
+        const result = validationString.replace(/\.max\(\s*\d+\s*\)/g, '');
+        // Insert after the first Zod constructor call (covers z.string(), z.iso.date(), z.hash(), etc.)
+        const baseCallMatch = result.match(/^(\s*z(?:\.[A-Za-z_]\w*)+\([^)]*\))/);
+        if (baseCallMatch) {
+            return result.replace(baseCallMatch[1], `${baseCallMatch[1]}.max(${newMaxValue})`);
+        }
+        console.warn(`[transformer] Could not find where to insert max constraint in: ${result}`);
+        return result;
+    }
+    /**
+     * Extract @zod validations for a specific field using the enhanced model information
+     */
+    /**
+     * Whether this member carries a sort direction rather than the column's value.
+     *
+     * `OrderByWithRelationInput`, `OrderByWithAggregationInput` and the five
+     * `<Agg>OrderByAggregateInput` families all take `SortOrder` (plus `SortOrderInput` on a
+     * nullable column, which adds `nulls`). A `@zod.email()` written for the column is a
+     * statement about the column's value and means nothing here, so applying it rejects
+     * `orderBy: { contact: 'asc' }` and accepts `orderBy: { contact: 'a@b.com' }`.
+     *
+     * Asked of the DMMF rather than of the schema name on purpose. The sibling guards above
+     * match `<Model>Select` and `<Agg>AggregateInput` by name, and the Select one shipped as a
+     * substring test that silently dropped every annotation on a model named `SelectionRound`.
+     * A name test here would do the same to `OrderByHistory`. An OrderBy member never offers
+     * the scalar arm and a write or filter member always does, so the DMMF answers this
+     * exactly, whatever the model is called.
+     */
+    static isSortDirectionMember(field) {
+        const inputTypes = field === null || field === void 0 ? void 0 : field.inputTypes;
+        if (!inputTypes || inputTypes.length === 0)
+            return false;
+        return inputTypes.every((it) => it.type === 'SortOrder' || it.type === 'SortOrderInput');
+    }
+    extractZodValidationsForField(fieldName, field) {
+        if (Transformer.isSortDirectionMember(field)) {
+            return null;
+        }
+        // IMPORTANT: Don't apply field validations to Select schemas
+        // Select schemas should always use boolean types regardless of the original field type
+        //
+        // Anchored, not a substring test. Every schema this guard exists for is a suffix
+        // (`<Model>Select`, `<Model>CountOutputTypeSelect`), while "Select" is an ordinary
+        // thing to find inside a user-chosen model name: `SelectionRound`, `SelectorProfile`,
+        // `PreSelection`. A substring test silently dropped every `@zod` annotation on those
+        // models' objects/ schemas while leaving them working in variants/, so nothing looked
+        // wrong until an unvalidated payload reached the database. Keep it anchored.
+        // `src/typed-json/emission.ts` matches Select schemas the same way.
+        if (this.name && /^\w+Select$/.test(this.name)) {
+            return null;
+        }
+        // IMPORTANT: Don't apply field validations to aggregate input schemas
+        // Aggregate inputs use boolean flags to specify which fields to include in aggregation
+        if (this.name && /(?:Count|Min|Max|Sum|Avg)AggregateInput$/.test(this.name)) {
+            return null;
+        }
+        // Basic validation
+        if (!fieldName || !this.enhancedModels || this.enhancedModels.length === 0) {
+            return null;
+        }
+        // Extract model name from the current transformer context
+        const modelName = Transformer.extractModelNameFromContext(this.name);
+        if (!modelName) {
+            return null;
+        }
+        // Find the enhanced model information
+        const enhancedModel = this.enhancedModels.find((em) => em.model.name === modelName);
+        if (!enhancedModel) {
+            return null;
+        }
+        // Find the enhanced field information
+        const enhancedField = enhancedModel.enhancedFields.find((ef) => ef.field.name === fieldName);
+        if (!enhancedField) {
+            return null;
+        }
+        // Return the Zod schema if it has annotations and is valid
+        if (enhancedField.hasZodAnnotations && enhancedField.zodSchema) {
+            return enhancedField.zodSchema;
+        }
+        return null;
+    }
+    generatePrismaStringLine(field, inputType, inputsLength) {
+        var _a;
+        const isEnum = inputType.location === 'enumTypes';
+        const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(inputType.type);
+        const objectSchemaLine = isModelQueryType
+            ? this.resolveModelQuerySchemaName(modelName, queryName)
+            : Transformer.exportTypedSchemas
+                ? `${inputType.type}ObjectSchema`
+                : `${inputType.type}Object${Transformer.zodSchemaSuffix}`;
+        // Use proper enum naming resolution instead of hardcoded "Schema" suffix
+        const enumNamingConfig = (0, naming_resolver_1.resolveEnumNaming)(Transformer.getGeneratorConfig());
+        const enumSchemaLine = (0, naming_resolver_1.generateExportName)(enumNamingConfig.exportNamePattern, inputType.type, // Use enum name as model name for naming pattern
+        undefined, // No operation
+        undefined, // No input type
+        inputType.type);
+        const schema = inputType.type === this.name ? objectSchemaLine : isEnum ? enumSchemaLine : objectSchemaLine;
+        const arr = inputType.isList ? '.array()' : '';
+        const opt = !field.isRequired ? '.optional()' : '';
+        // Only use lazy loading for self-references or complex object schemas that might have circular dependencies
+        // Simple enums like SortOrder don't need lazy loading
+        const isSelfReference = inputType.type === this.name;
+        const needsLazyLoading = isSelfReference || (!isEnum && inputType.namespace === 'prisma');
+        if (needsLazyLoading) {
+            const cfg = Transformer.getGeneratorConfig();
+            const target = ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.zodImportTarget) !== null && _a !== void 0 ? _a : 'auto');
+            if (target === 'v4') {
+                // Prefer Zod v4 getter-based recursion to avoid z.lazy()
+                const ref = isSelfReference ? `${this.name}ObjectSchema` : schema;
+                if (inputsLength === 1) {
+                    return `  get ${field.name}(){ return ${ref}${arr}${opt}; },`;
+                }
+                // In unions, return the bare reference; the field name wrapper is applied later
+                return `${ref}${arr}${opt}`;
+            }
+            if (isSelfReference) {
+                // v3 and auto (legacy) use z.lazy
+                return inputsLength === 1
+                    ? `  ${field.name}: z.lazy(() => ${this.name}ObjectSchema)${arr}${opt}`
+                    : `z.lazy(() => ${this.name}ObjectSchema)${arr}${opt}`;
+            }
+            return inputsLength === 1
+                ? `  ${field.name}: z.lazy(() => ${schema})${arr}${opt}`
+                : `z.lazy(() => ${schema})${arr}${opt}`;
+        }
+        else {
+            return inputsLength === 1
+                ? `  ${field.name}: ${schema}${arr}${opt}`
+                : `${schema}${arr}${opt}`;
+        }
+    }
+    generateFieldValidators(zodStringWithMainType, field) {
+        const { isRequired, isNullable } = field;
+        if (!isRequired) {
+            zodStringWithMainType += '.optional()';
+        }
+        if (isNullable) {
+            zodStringWithMainType += '.nullable()';
+        }
+        return zodStringWithMainType;
+    }
+    prepareObjectSchema(zodObjectSchemaFields) {
+        // Field processing is now handled earlier in generateObjectSchemaFields()
+        // This method just prepares the final schema
+        const finalFields = zodObjectSchemaFields;
+        const objectSchemaBody = this.addFinalWrappers({ zodStringFields: finalFields });
+        // Check if schema has self-references (needs explicit return type to avoid TS7023)
+        const needsReturnType = finalFields.some((field) => field.includes(`z.lazy(() => ${this.name}ObjectSchema)`));
+        // Apply GitHub issue 214 fix: use schema constant pattern for better type inference
+        let objectSchema;
+        if (needsReturnType) {
+            // Use unique variable name to avoid conflicts in single-file mode
+            const uniqueVarName = `${this.name.toLowerCase()}Schema`;
+            const schemaDecl = `const ${uniqueVarName} = ${objectSchemaBody};\n`;
+            objectSchema = `${schemaDecl}${this.generateExportObjectSchemaStatement(uniqueVarName)}\n`;
+        }
+        else {
+            const factoryDecl = `const makeSchema = () => ${objectSchemaBody};\n`;
+            objectSchema = `${factoryDecl}${this.generateExportObjectSchemaStatement('makeSchema()')}\n`;
+        }
+        // Add optional sanity-check block for Zod-only schemas when self recursion exists
+        const hasSelfRecursion = finalFields.some((l) => l.includes(`z.lazy(() => ${this.name}ObjectSchema)`));
+        if (Transformer.exportZodSchemas && hasSelfRecursion) {
+            const sanity = this.generateZodOnlySanityCheck(finalFields);
+            if (sanity)
+                objectSchema += sanity + '\n';
+        }
+        // Get custom imports for this model by analyzing the actual schema content
+        const modelName = Transformer.extractModelNameFromContext(this.name);
+        const customImports = [
+            ...this.getCustomImportsForModel(modelName, objectSchema),
+            ...this.getTypedJsonImportsForSchema(modelName, objectSchema),
+        ];
+        const baseImports = this.generateObjectSchemaImportStatements(customImports);
+        let jsonImport = '';
+        if (this.hasJson) {
+            const cfg = Transformer.getGeneratorConfig();
+            const isMinimal = (cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal';
+            if (isMinimal) {
+                // Inline lightweight json helpers per file (cheaper in minimal mode, files are separate)
+                jsonImport = `\nconst literalSchema = z.union([z.string(), z.number(), z.boolean()]);\nconst jsonSchema: any = z.lazy(() =>\n  z.union([literalSchema, z.array(jsonSchema.nullable()), z.record(z.string(), jsonSchema.nullable())])\n);\n\n`;
+            }
+            else {
+                // Ensure helpers file exists once and compute correct relative path from objects dir → helpers dir
+                Transformer.ensureJsonHelpersFile();
+                try {
+                    const objectsDir = path_1.default.join(Transformer.getSchemasPath(), 'objects');
+                    const helpersDir = path_1.default.join(Transformer.getOutputPath(), 'helpers');
+                    let rel = path_1.default.relative(objectsDir, helpersDir).replace(/\\/g, '/');
+                    if (!rel.startsWith('.') && !rel.startsWith('/'))
+                        rel = `./${rel}`;
+                    const extension = this.getImportFileExtension();
+                    jsonImport = `import { JsonValueSchema as jsonSchema } from '${rel}/json-helpers${extension}';\n\n`;
+                }
+                catch {
+                    // Fallback to original relative import (pre-change behavior)
+                    const extension = this.getImportFileExtension();
+                    jsonImport = `import { JsonValueSchema as jsonSchema } from './helpers/json-helpers${extension}';\n\n`;
+                }
+            }
+        }
+        let decimalImport = '';
+        if (this.hasDecimal) {
+            const cfg = Transformer.getGeneratorConfig();
+            const mode = (cfg === null || cfg === void 0 ? void 0 : cfg.decimalMode) || 'decimal';
+            const isMinimal = (cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal';
+            if (mode === 'decimal') {
+                if (isMinimal) {
+                    // Inline decimal helpers per file in minimal mode
+                    decimalImport = `\nconst DecimalJSLikeSchema: z.ZodType<Prisma.DecimalJsLike> = z.object({
+  d: z.array(z.number()),
+  e: z.number(),
+  s: z.number(),
+  // Zod v3/v4 compatible callable check
+  toFixed: z.custom<Prisma.DecimalJsLike['toFixed']>((v) => typeof v === 'function'),
+});
+
+// Accept canonical decimal strings (+/-, optional fraction, optional exponent), or Infinity/NaN.
+const DECIMAL_STRING_REGEX = /^(?:[+-]?(?:[0-9]+(?:\\.[0-9]+)?(?:[eE][+\\-]?[0-9]+)?|Infinity)|NaN)$/;
+
+const isValidDecimalInput = (
+  v?: null | string | number | Prisma.DecimalJsLike,
+): v is string | number | Prisma.DecimalJsLike => {
+  if (v === undefined || v === null) return false;
+  return (
+    // Cross-runtime-copy safe check (browser and server runtimes bundle separate Decimal classes)
+    Prisma.Decimal.isDecimal(v) ||
+    (typeof v === 'object' &&
+      'd' in v &&
+      'e' in v &&
+      's' in v &&
+      'toFixed' in v) ||
+    (typeof v === 'string' && DECIMAL_STRING_REGEX.test(v)) ||
+    typeof v === 'number'
+  );
+};
+
+`;
+                }
+                else {
+                    // Import from helpers directory
+                    Transformer.ensureDecimalHelpersFile();
+                    try {
+                        const objectsDir = path_1.default.join(Transformer.getSchemasPath(), 'objects');
+                        const helpersDir = path_1.default.join(Transformer.getOutputPath(), 'helpers');
+                        let rel = path_1.default.relative(objectsDir, helpersDir).replace(/\\/g, '/');
+                        if (!rel.startsWith('.') && !rel.startsWith('/'))
+                            rel = `./${rel}`;
+                        const extension = this.getImportFileExtension();
+                        decimalImport = `import { DecimalJSLikeSchema, isValidDecimalInput } from '${rel}/decimal-helpers${extension}';\n`;
+                    }
+                    catch {
+                        const extension = this.getImportFileExtension();
+                        decimalImport = `import { DecimalJSLikeSchema, isValidDecimalInput } from './helpers/decimal-helpers${extension}';\n`;
+                    }
+                }
+            }
+        }
+        return `${baseImports}${jsonImport}${decimalImport}${objectSchema}`;
+    }
+    generateExportObjectSchemaStatement(schema) {
+        var _a;
+        let name = this.name;
+        let exportName = this.name;
+        if (Transformer.provider === 'mongodb') {
+            // Only remap when the lookup succeeds so a miss can never crash generation
+            const mapped = Transformer.rawOpsMap[name];
+            if (mapped) {
+                name = mapped;
+                exportName = mapped.replace('Args', '');
+            }
+        }
+        // Use input naming configuration if available
+        try {
+            const config = Transformer.getGeneratorConfig();
+            const inputNamingConfig = (_a = config === null || config === void 0 ? void 0 : config.naming) === null || _a === void 0 ? void 0 : _a.input;
+            if (inputNamingConfig === null || inputNamingConfig === void 0 ? void 0 : inputNamingConfig.exportNamePattern) {
+                const modelName = Transformer.extractModelNameFromContext(this.name);
+                const inputType = this.name;
+                const customExportName = (0, naming_resolver_1.generateExportName)(inputNamingConfig.exportNamePattern, modelName || inputType, undefined, inputType);
+                if (customExportName) {
+                    // Remove schema suffixes from the export variable name; keep Prisma binding independent.
+                    exportName = customExportName.replace(/ObjectSchema$|Schema$/, '');
+                }
+            }
+        }
+        catch {
+            // Fallback to default naming if there's an error
+        }
+        // Build dual exports: a typed Prisma-bound schema and a pure Zod schema
+        // Always export the typed name as `${exportName}ObjectSchema` for compatibility
+        const lines = [];
+        const supportsPrismaType = !name.endsWith('Args');
+        if (Transformer.exportTypedSchemas) {
+            if (supportsPrismaType) {
+                // Determine correct Prisma type binding from the intrinsic input name (this.name)
+                const prismaBase = this.name;
+                let prismaType = this.resolvePrismaTypeForObject(prismaBase);
+                // Optionally wrap with Omit<> when strictCreateInputs=false and fields were excluded on Create-like inputs
+                const config = (Transformer.getGeneratorConfig() || {});
+                const strictCreateInputs = config.strictCreateInputs !== false; // default true
+                const isInputVariant = Transformer.determineSchemaVariant(name) === 'input';
+                const isCreateLike = [
+                    /^(\w+)CreateInput$/,
+                    /^(\w+)UncheckedCreateInput$/,
+                    /^(\w+)CreateManyInput$/,
+                    /^(\w+)CreateMany\w+Input$/,
+                    /^(\w+)CreateWithout\w+Input$/,
+                    /^(\w+)UncheckedCreateWithout\w+Input$/,
+                    /^(\w+)CreateOrConnectWithout\w+Input$/,
+                    /^(\w+)CreateNested(?:One|Many)Without\w+Input$/,
+                ].some((re) => re.test(this.name));
+                const excludedNames = this.lastExcludedFieldNames || [];
+                if (!strictCreateInputs &&
+                    isInputVariant &&
+                    isCreateLike &&
+                    excludedNames.length > 0 &&
+                    prismaType) {
+                    const union = excludedNames.map((n) => `'${n}'`).join(' | ');
+                    prismaType = `Omit<${prismaType}, ${union}>`;
+                }
+                if (prismaType) {
+                    lines.push(`export const ${exportName}ObjectSchema: z.ZodType<${prismaType}> = ${schema} as unknown as z.ZodType<${prismaType}>;`);
+                }
+                else {
+                    // Fallback to untyped if we cannot resolve a safe Prisma type
+                    lines.push(`export const ${exportName}ObjectSchema = ${schema};`);
+                }
+            }
+            else {
+                // Args-like types may not exist on Prisma namespace; export untyped for compatibility
+                lines.push(`export const ${exportName}ObjectSchema = ${schema};`);
+            }
+        }
+        if (Transformer.exportZodSchemas) {
+            const zodName = `${exportName}Object${Transformer.zodSchemaSuffix}`;
+            lines.push(`export const ${zodName} = ${schema};`);
+        }
+        // Fallback: if neither flag produced output, emit a basic (untyped) export
+        if (lines.length === 0) {
+            lines.push(`export const ${exportName}ObjectSchema = ${schema};`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Emit a manual TS type and a `satisfies z.ZodType<...>` check for Zod-only, self-recursive schemas.
+     * This avoids TS7022 and keeps output variable types unchanged.
+     */
+    generateZodOnlySanityCheck(_finalFields) {
+        // According to the factory pattern spec, we should NOT add satisfies annotations
+        // to pure Zod schemas as they break .extend()/.omit() functionality
+        return '';
+    }
+    /**
+     * Whether generateExportObjectSchemaStatement will emit a `z.ZodType<Prisma.X>`
+     * annotated export for this object schema. Mirrors its decision exactly so the
+     * `import type { Prisma }` line is only emitted when it is actually referenced
+     * (e.g. `<Model>Args` schemas are always exported untyped).
+     */
+    willGenerateTypedObjectExport() {
+        if (!Transformer.exportTypedSchemas)
+            return false;
+        let name = this.name;
+        if (Transformer.provider === 'mongodb' && (0, helpers_1.isMongodbRawOp)(name)) {
+            name = Transformer.rawOpsMap[name];
+        }
+        return !name.endsWith('Args') && this.resolvePrismaTypeForObject(this.name) !== null;
+    }
+    /**
+     * Resolve the appropriate Prisma type identifier for an object schema export.
+     * In Prisma 6, certain aggregate input types are exported with a `Type` suffix.
+     * Example: Prisma.PlanetCountAggregateInputType instead of Prisma.PlanetCountAggregateInput
+     */
+    resolvePrismaTypeForObject(exportName) {
+        // No Prisma types for generic Args wrappers here
+        if (exportName.endsWith('Args'))
+            return null;
+        // A per-field copy of a shared update-operations input has no Prisma type of its own.
+        // It is structurally the input it was copied from and binds to that one, so the
+        // emitted file still typechecks against the client.
+        const copiedFrom = Transformer.typedFieldUpdateOperationsPlan.prismaTypeNameFor(exportName);
+        if (copiedFrom)
+            return `Prisma.${copiedFrom}`;
+        // Handle aggregate input objects that use the `Type` suffix
+        if (/(Count|Min|Max|Avg|Sum)AggregateInput$/.test(exportName)) {
+            return `Prisma.${exportName}Type`;
+        }
+        // Default mapping: Prisma.<ExportName>
+        return `Prisma.${exportName}`;
+    }
+    addFinalWrappers({ zodStringFields }) {
+        var _a, _b, _c;
+        const fields = [...zodStringFields];
+        // Base object + strict mode based on configuration
+        const modelName = this.name ? Transformer.extractModelNameFromContext(this.name) : undefined;
+        const strictModeSuffix = ((_a = Transformer.getStrictModeResolver()) === null || _a === void 0 ? void 0 : _a.getObjectStrictModeSuffix(modelName || undefined)) || '';
+        // Zod v4's .strict() clones the schema def and spreads its shape, which invokes
+        // every field getter at module-init time — defeating getter-based recursion and
+        // crashing on forward/circular references. Use z.strictObject instead (identical
+        // strictness semantics; the shape stays lazy until first parse).
+        const isV4 = ((_c = (_b = Transformer.getGeneratorConfig()) === null || _b === void 0 ? void 0 : _b.zodImportTarget) !== null && _c !== void 0 ? _c : 'auto') === 'v4';
+        let base = isV4 && strictModeSuffix === '.strict()'
+            ? this.wrapWithZodObject(fields, true)
+            : this.wrapWithZodObject(fields) + strictModeSuffix;
+        // WhereUniqueInput optional refinement (opt-in): require at least one selector
+        if (this.name && /WhereUniqueInput$/.test(this.name)) {
+            const cfg = Transformer.getGeneratorConfig();
+            if (cfg === null || cfg === void 0 ? void 0 : cfg.validateWhereUniqueAtLeastOne) {
+                // Use the current object's top-level field names as valid selector keys
+                // (includes single-field uniques and composite unique selectors)
+                const selectorKeys = Array.from(new Set((this.fields || []).map((f) => f.name).filter(Boolean)));
+                const selectorKeysJson = JSON.stringify(selectorKeys);
+                const refineAtLeastOne = `.superRefine((obj, ctx) => {\n  const keys: string[] = ${selectorKeysJson} as string[];\n  const present = (k: string) => (obj as any)[k] != null;\n  if (!Array.isArray(keys) || keys.length === 0) return;\n  if (!keys.some(present)) {\n    ctx.addIssue({ code: 'custom', message: 'Provide at least one unique selector' });\n  }\n})`;
+                base = base + refineAtLeastOne;
+            }
+        }
+        return base;
+    }
+    // Legacy method retained for backward compatibility; now returns empty string.
+    static ensureJsonHelpersFile() {
+        if (this.jsonHelpersWritten)
+            return;
+        this.jsonHelpersWritten = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports -- fallback sync write path for environments without top-level await
+            const fs = require('fs');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const pathMod = require('path');
+            const helpersDir = pathMod.join(this.outputPath, 'helpers');
+            fs.mkdirSync(helpersDir, { recursive: true });
+            const filePath = pathMod.join(helpersDir, 'json-helpers.ts');
+            const zImport2 = new Transformer({
+                name: '',
+                fields: [],
+                models: [],
+                modelOperations: [],
+                enumTypes: [],
+            }).generateImportZodStatement();
+            // Single source: src/helpers/json-helpers.ts. This was a second copy of that program,
+            // maintained by hand.
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { generateJsonHelpers } = require('./helpers/json-helpers');
+            const content = `${zImport2}\n${generateJsonHelpers()}`;
+            fs.writeFileSync(filePath, content, 'utf8');
+        }
+        catch (e) {
+            logger_1.logger.warn(`Failed to write json helpers: ${e}`);
+        }
+    }
+    static ensureDecimalHelpersFile() {
+        if (this.decimalHelpersWritten)
+            return;
+        this.decimalHelpersWritten = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const fs = require('fs');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const pathMod = require('path');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { generateDecimalHelpers, isDecimalJsAvailable } = require('./helpers/decimal-helpers');
+            const helpersDir = pathMod.join(this.outputPath, 'helpers');
+            fs.mkdirSync(helpersDir, { recursive: true });
+            const filePath = pathMod.join(helpersDir, 'decimal-helpers.ts');
+            // Check if decimal.js is available
+            const hasDecimalJs = isDecimalJsAvailable();
+            // Generate Zod import
+            const zImport = new Transformer({
+                name: '',
+                fields: [],
+                models: [],
+                modelOperations: [],
+                enumTypes: [],
+            }).generateImportZodStatement();
+            // Generate decimal helpers
+            const prismaImportPath = Transformer.resolvePrismaImportPath(helpersDir);
+            const { helperCode, imports } = generateDecimalHelpers(hasDecimalJs, 'z', prismaImportPath);
+            const content = `${zImport}
+${imports.join('\n')}
+
+${helperCode}
+`;
+            fs.writeFileSync(filePath, content, 'utf8');
+        }
+        catch (e) {
+            logger_1.logger.warn(`Failed to write decimal helpers: ${e}`);
+        }
+    }
+    generateObjectSchemaImportStatements(customImports = []) {
+        let generatedImports = this.generateImportZodStatement();
+        // Add custom imports from @zod.import() annotations
+        const customImportStatements = this.generateCustomImportStatements(customImports, 'objects');
+        if (customImportStatements) {
+            generatedImports += customImportStatements;
+        }
+        // Import Prisma - use value import if Decimal mode is active, otherwise type-only
+        // (and only when the file's typed export will actually reference Prisma)
+        const cfg = Transformer.getGeneratorConfig();
+        const mode = (cfg === null || cfg === void 0 ? void 0 : cfg.decimalMode) || 'decimal';
+        const needsPrismaValueImport = this.hasDecimal && mode === 'decimal';
+        const needsPrismaTypeImport = !needsPrismaValueImport && this.willGenerateTypedObjectExport();
+        if (needsPrismaValueImport || needsPrismaTypeImport) {
+            const objectsDir = path_1.default.join(Transformer.getSchemasPath(), 'objects');
+            const prismaImportPath = Transformer.resolvePrismaImportPath(objectsDir);
+            if (needsPrismaValueImport) {
+                // Value import for instanceof checks in Decimal mode
+                generatedImports += `import { Prisma } from '${prismaImportPath}';\n`;
+                // Also try to import Decimal from decimal.js if available
+                try {
+                    require.resolve('decimal.js');
+                    generatedImports += `import Decimal from 'decimal.js';\n`;
+                }
+                catch {
+                    // decimal.js not installed, skip the import
+                }
+            }
+            else {
+                // Type-only import for typed schemas
+                generatedImports += `import type { Prisma } from '${prismaImportPath}';\n`;
+            }
+        }
+        generatedImports += this.generateSchemaImports();
+        generatedImports += '\n\n';
+        return generatedImports;
+    }
+    /**
+     * Get the file extension to use for imports based on Prisma client configuration
+     * For ESM with importFileExtension = "js", we need to add .js extension
+     */
+    getImportFileExtension() {
+        return Transformer.getImportFileExtension();
+    }
+    /**
+     * Convert model name to PascalCase for consistent file naming
+     */
+    getPascalCaseModelName(modelName) {
+        return modelName
+            .replace(/[_-\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+            .replace(/^\w/, (c) => c.toUpperCase());
+    }
+    /**
+     * Resolve an input object import honoring naming.input patterns, aliasing to stable identifiers.
+     */
+    generateInputImport(inputTypeName, from = 'objects') {
+        try {
+            const cfg = (0, naming_resolver_1.resolveInputNaming)(Transformer.getGeneratorConfig());
+            // Extract model name - fallback to inputTypeName if extraction fails
+            const model = Transformer.extractModelNameFromContext(inputTypeName) || inputTypeName;
+            // Generate the file name using the custom pattern
+            const file = (0, naming_resolver_1.generateFileName)(cfg.filePattern, model, undefined, inputTypeName);
+            const base = file.replace(/\.ts$/, '');
+            // Generate export name using the custom pattern - this already includes the full name
+            const resolvedExportName = (0, naming_resolver_1.generateExportName)(cfg.exportNamePattern, model, undefined, inputTypeName) || inputTypeName;
+            const exportBase = resolvedExportName.replace(/ObjectSchema$|Schema$/, '');
+            const importName = Transformer.exportTypedSchemas
+                ? `${exportBase}ObjectSchema`
+                : `${exportBase}Object${Transformer.zodSchemaSuffix}`;
+            // Create alias using the original input type name for consistency
+            const alias = Transformer.exportTypedSchemas
+                ? `${inputTypeName}ObjectSchema`
+                : `${inputTypeName}Object${Transformer.zodSchemaSuffix}`;
+            const ext = this.getImportFileExtension();
+            const baseDir = from === 'objects' ? './objects' : '../objects';
+            return `import { ${importName} as ${alias} } from '${baseDir}/${base}${ext}'`;
+        }
+        catch (error) {
+            // Log error for debugging and fallback to legacy naming
+            logger_1.logger.warn('Failed to generate custom input import for', inputTypeName, error);
+            const baseDir = from === 'objects' ? 'root' : 'results';
+            // Use pattern-aware object input import helper as a fallback
+            return this.generateObjectInputImport(inputTypeName, baseDir);
+        }
+    }
+    /**
+     * Generate enum import honoring naming.enum patterns, aliasing to stable identifiers.
+     */
+    generateEnumImport(enumName, expectedAlias, from = 'objects') {
+        try {
+            const cfg = (0, naming_resolver_1.resolveEnumNaming)(Transformer.getGeneratorConfig());
+            // Generate the file name using the custom pattern
+            const file = (0, naming_resolver_1.generateFileName)(cfg.filePattern, enumName, undefined, undefined, enumName);
+            const base = file.replace(/\.ts$/, '');
+            // Generate export name using the custom pattern
+            const exportName = (0, naming_resolver_1.generateExportName)(cfg.exportNamePattern, enumName, undefined, undefined, enumName);
+            const ext = this.getImportFileExtension();
+            const baseDir = from === 'objects' ? '../enums' : './enums';
+            const finalAlias = expectedAlias || `${enumName}Schema`;
+            // Only use alias if export name differs from expected alias
+            if (exportName === finalAlias) {
+                return `import { ${exportName} } from '${baseDir}/${base}${ext}'`;
+            }
+            else {
+                return `import { ${exportName} as ${finalAlias} } from '${baseDir}/${base}${ext}'`;
+            }
+        }
+        catch (error) {
+            // Fallback to legacy naming
+            logger_1.logger.warn('Failed to generate custom enum import for', enumName, error);
+            const baseDir = from === 'objects' ? '../enums' : './enums';
+            return `import { ${enumName}Schema } from '${baseDir}/${enumName}.schema${this.getImportFileExtension()}'`;
+        }
+    }
+    /**
+     * Generate input import for object schemas honoring naming.input patterns.
+     * Similar to generateInputImport but for object-to-object imports using './' prefix.
+     */
+    generateObjectInputImport(inputTypeName, from = 'objects') {
+        try {
+            const cfg = (0, naming_resolver_1.resolveInputNaming)(Transformer.getGeneratorConfig());
+            // Extract model name - fallback to inputTypeName if extraction fails
+            const model = Transformer.extractModelNameFromContext(inputTypeName) || inputTypeName;
+            // Generate the file name using the custom pattern
+            const file = (0, naming_resolver_1.generateFileName)(cfg.filePattern, model, undefined, inputTypeName);
+            const base = file.replace(/\.ts$/, '');
+            // Generate export name using the custom pattern
+            const resolvedExportName = (0, naming_resolver_1.generateExportName)(cfg.exportNamePattern, model, undefined, inputTypeName) || inputTypeName;
+            const exportBase = resolvedExportName.replace(/ObjectSchema$|Schema$/, '');
+            const importName = Transformer.exportTypedSchemas
+                ? `${exportBase}ObjectSchema`
+                : `${exportBase}Object${Transformer.zodSchemaSuffix}`;
+            // Create alias using the original input type name for consistency
+            const alias = Transformer.exportTypedSchemas
+                ? `${inputTypeName}ObjectSchema`
+                : `${inputTypeName}Object${Transformer.zodSchemaSuffix}`;
+            const ext = this.getImportFileExtension();
+            const baseDir = from === 'objects' ? '.' : from === 'root' ? './objects' : '../objects';
+            return `import { ${importName} as ${alias} } from '${baseDir}/${base}${ext}'`;
+        }
+        catch (error) {
+            // Log error for debugging and fallback to legacy naming
+            logger_1.logger.warn('Failed to generate custom object input import for', inputTypeName, error);
+            const schemaName = Transformer.exportTypedSchemas
+                ? `${inputTypeName}ObjectSchema`
+                : `${inputTypeName}Object${Transformer.zodSchemaSuffix}`;
+            const baseDir = from === 'objects' ? '.' : from === 'root' ? './objects' : '../objects';
+            return `import { ${schemaName} } from '${baseDir}/${inputTypeName}.schema${this.getImportFileExtension()}'`;
+        }
+    }
+    /**
+     * Generate schema file name with collision detection and custom naming support
+     */
+    static generateSchemaFileName(modelName, operation) {
+        let fileName = `${operation}${modelName}.schema.ts`; // Default fallback
+        try {
+            const schemaNamingConfig = (0, naming_resolver_1.resolveSchemaNaming)(Transformer.getGeneratorConfig());
+            fileName = (0, naming_resolver_1.generateFileName)(schemaNamingConfig.filePattern, modelName, operation);
+        }
+        catch {
+            // Use fallback naming
+        }
+        return fileName;
+    }
+    /**
+     * Check for and handle file path collisions
+     */
+    static checkSchemaFileCollision(filePath, modelName, operation) {
+        const existingOperation = this.usedSchemaFilePaths.get(filePath);
+        if (existingOperation) {
+            const errorMsg = `Schema file collision detected: Both "${existingOperation.modelName}.${existingOperation.operation}" and "${modelName}.${operation}" would generate file "${filePath}". ` +
+                `This will cause operations to overwrite each other. ` +
+                `Consider including {Operation} in your schema.filePattern (e.g., "{kebab}-{operation}-schema.ts") to avoid collisions.`;
+            logger_1.logger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+        // Register this path as used
+        this.usedSchemaFilePaths.set(filePath, { modelName, operation });
+    }
+    /**
+     * Generate schema file with collision detection and consistent naming
+     */
+    static async writeSchemaFile(modelName, operation, content) {
+        const fileName = this.generateSchemaFileName(modelName, operation);
+        const fullPath = path_1.default.join(Transformer.getSchemasPath(), fileName);
+        // Check for collisions
+        this.checkSchemaFileCollision(fullPath, modelName, operation);
+        // Write the file (avoid double index updates; we handle export add explicitly)
+        await (0, writeFileSafely_1.writeFileSafely)(fullPath, content, false);
+        // Add to index exports
+        (0, writeIndexFile_1.addIndexExport)(fullPath);
+        logger_1.logger.debug(`✅ Generated schema: ${fileName}`);
+    }
+    /**
+     * Clear collision detection state (called at start of generation)
+     */
+    static clearSchemaFileCollisions() {
+        this.usedSchemaFilePaths.clear();
+    }
+    /**
+     * Generate import statement with validation - only if target will be generated
+     */
+    static generateValidatedImportStatement(importName, importPath, modelName) {
+        // Check if the target schema should be generated
+        if (!Transformer.shouldGenerateImport(importName, modelName)) {
+            return '';
+        }
+        const extension = Transformer.getImportFileExtension();
+        return `import { ${importName} } from '${importPath}${extension}'`;
+    }
+    /**
+     * Check if an import should be generated based on filtering rules
+     */
+    static shouldGenerateImport(importName, relatedModelName) {
+        // If a related model is specified, check if it's enabled
+        if (relatedModelName && !Transformer.isModelEnabled(relatedModelName)) {
+            return false;
+        }
+        // Check if the import represents a schema that would be filtered out
+        const extractedModelName = Transformer.extractModelFromImportName(importName);
+        if (extractedModelName && !Transformer.isModelEnabled(extractedModelName)) {
+            return false;
+        }
+        // Default: generate the import
+        return true;
+    }
+    /**
+     * Extract model name from import name
+     */
+    static extractModelFromImportName(importName) {
+        // Common patterns for import names
+        // NOTE: More specific patterns (with "Unchecked") must come BEFORE general patterns
+        const patterns = [
+            /^(\w+?)UncheckedCreateInputObjectSchema$/,
+            /^(\w+?)UncheckedUpdateInputObjectSchema$/,
+            /^(\w+)WhereInputObjectSchema$/,
+            /^(\w+)WhereUniqueInputObjectSchema$/,
+            /^(\w+)CreateInputObjectSchema$/,
+            /^(\w+)UpdateInputObjectSchema$/,
+            /^(\w+)SelectObjectSchema$/,
+            /^(\w+)IncludeObjectSchema$/,
+            /^(\w+)ScalarFieldEnumSchema$/,
+            /^(\w+)OrderByWithRelationInputObjectSchema$/,
+            /^(\w+)OrderByWithAggregationInputObjectSchema$/,
+        ];
+        for (const pattern of patterns) {
+            const match = importName.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    /**
+     * Get import file extension (static version)
+     */
+    static getImportFileExtension() {
+        const isNewPrismaClientGenerator = this.prismaClientProvider === 'prisma-client' ||
+            this.prismaClientConfig.moduleFormat !== undefined ||
+            this.prismaClientConfig.runtime !== undefined;
+        if (isNewPrismaClientGenerator &&
+            this.prismaClientConfig.moduleFormat === 'esm' &&
+            this.prismaClientConfig.importFileExtension) {
+            return `.${this.prismaClientConfig.importFileExtension}`;
+        }
+        return '';
+    }
+    generateSchemaImports() {
+        // Get the file extension to use for imports (for ESM support)
+        const importExtension = this.getImportFileExtension();
+        return [...this.schemaImports]
+            .map((name) => {
+            const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(name);
+            if (isModelQueryType) {
+                try {
+                    // Use naming resolver to get custom patterns
+                    const schemaCfg = (0, naming_resolver_1.resolveSchemaNaming)(Transformer.getGeneratorConfig());
+                    // Generate filename using custom pattern
+                    const op = queryName.charAt(0).toUpperCase() + queryName.slice(1);
+                    const fileName = (0, naming_resolver_1.generateFileName)(schemaCfg.filePattern, modelName, op);
+                    const baseName = fileName.replace(/\.ts$/, '');
+                    // Generate export name using custom pattern
+                    const exportName = (0, naming_resolver_1.generateExportName)(schemaCfg.exportNamePattern, modelName, op);
+                    // Use the resolved export name, but alias to what resolveModelQuerySchemaName expects for compatibility
+                    const aliasName = this.resolveModelQuerySchemaName(modelName, queryName);
+                    return `import { ${exportName} as ${aliasName} } from '../${baseName}${importExtension}'`;
+                }
+                catch {
+                    // Fallback to legacy hardcoded naming if naming resolver fails
+                    const op = queryName.charAt(0).toUpperCase() + queryName.slice(1);
+                    return `import { ${this.resolveModelQuerySchemaName(modelName, queryName)} } from '../${op}${modelName}.schema${importExtension}'`;
+                }
+            }
+            else if (Transformer.enumNames.includes(name)) {
+                const normalized = this.normalizeEnumName(name);
+                if (normalized && normalized !== name) {
+                    // Use naming resolver for normalized enum imports with original name as alias
+                    return this.generateEnumImport(normalized, `${name}Schema`);
+                }
+                else {
+                    // Use naming resolver for regular enum imports
+                    return this.generateEnumImport(name);
+                }
+            }
+            else {
+                // Use naming resolver for input object imports
+                return this.generateObjectInputImport(name);
+            }
+        })
+            .join(';\r\n');
+    }
+    checkIsModelQueryType(type) {
+        const modelQueryTypeSuffixToQueryName = {
+            FindManyArgs: 'findMany',
+        };
+        for (const modelQueryType of ['FindManyArgs']) {
+            if (type.includes(modelQueryType)) {
+                const modelQueryTypeSuffixIndex = type.indexOf(modelQueryType);
+                return {
+                    isModelQueryType: true,
+                    modelName: type.substring(0, modelQueryTypeSuffixIndex),
+                    queryName: modelQueryTypeSuffixToQueryName[modelQueryType],
+                };
+            }
+        }
+        return { isModelQueryType: false };
+    }
+    resolveModelQuerySchemaName(modelName, queryName) {
+        // Match exported identifiers from generateDualSchemaExports (e.g., PostFindManySchema)
+        const baseName = `${modelName}${queryName[0].toUpperCase()}${queryName.slice(1)}`;
+        return Transformer.exportTypedSchemas
+            ? `${baseName}Schema`
+            : `${baseName}${Transformer.zodSchemaSuffix}`;
+    }
+    wrapWithZodObject(zodStringFields, useStrictObject = false) {
+        let wrapped = '';
+        const fieldsText = Array.isArray(zodStringFields)
+            ? zodStringFields.filter(Boolean).join(',\n  ')
+            : zodStringFields;
+        wrapped += useStrictObject ? 'z.strictObject({' : 'z.object({';
+        wrapped += '\n';
+        wrapped += '  ' + fieldsText;
+        wrapped += '\n';
+        wrapped += '})';
+        return wrapped;
+    }
+    /**
+     * Compose an operation schema object definition with strict-mode handling.
+     * For Zod v4 targets, `.strict()` clones the schema def and spreads its shape,
+     * invoking `get select/include` getters at module-init time and crashing on
+     * circular imports. z.strictObject keeps identical strictness semantics while
+     * leaving the shape lazy until first parse.
+     */
+    composeObjectDefinition(body, strictSuffix) {
+        var _a, _b;
+        const target = ((_b = (_a = Transformer.getGeneratorConfig()) === null || _a === void 0 ? void 0 : _a.zodImportTarget) !== null && _b !== void 0 ? _b : 'auto');
+        if (target === 'v4' && strictSuffix === '.strict()') {
+            return `z.strictObject({ ${body} })`;
+        }
+        return `z.object({ ${body} })${strictSuffix}`;
+    }
+    async generateModelSchemas() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        const cfg = Transformer.getGeneratorConfig();
+        if ((cfg === null || cfg === void 0 ? void 0 : cfg.emit) && cfg.emit.crud === false) {
+            logger_1.logger.debug('⏭️  emit.crud=false (skipping all CRUD operation schema generation)');
+            return;
+        }
+        // Perform comprehensive filter validation
+        const isValid = Transformer.performFilterValidation(this.models);
+        if (!isValid) {
+            throw new Error('Filter validation failed. Please fix the configuration errors above.');
+        }
+        // Log model filtering information
+        Transformer.logModelFiltering(this.models);
+        // Clear schema file collision tracking at start of generation
+        Transformer.clearSchemaFileCollisions();
+        for (const modelOperation of this.modelOperations) {
+            try {
+                const { model: modelName, findUnique, findFirst, findMany, 
+                // @ts-expect-error - Legacy API compatibility
+                createOne, createMany, 
+                // @ts-expect-error - Legacy API compatibility
+                deleteOne, 
+                // @ts-expect-error - Legacy API compatibility
+                updateOne, deleteMany, updateMany, 
+                // @ts-expect-error - Legacy API compatibility
+                upsertOne, aggregate, groupBy, } = modelOperation;
+                // Skip generation for disabled models based on configuration
+                if (!Transformer.isModelEnabled(modelName)) {
+                    continue;
+                }
+                // Log operation filtering information for this model
+                const allOperations = [
+                    findUnique,
+                    findFirst,
+                    findMany,
+                    createOne,
+                    createMany,
+                    deleteOne,
+                    deleteMany,
+                    updateOne,
+                    updateMany,
+                    upsertOne,
+                    aggregate,
+                    groupBy,
+                    'count',
+                ].filter(Boolean); // Remove undefined operations
+                Transformer.logOperationFiltering(modelName, allOperations);
+                const model = (0, helpers_1.findModelByName)(this.models, modelName);
+                const { selectImport, includeImport, selectZodSchemaLine, includeZodSchemaLine, selectZodSchemaLineLazy, includeZodSchemaLineLazy, selectValueExpr, includeValueExpr, } = this.resolveSelectIncludeImportAndZodSchemaLine(model);
+                const { orderByImport, orderByZodSchemaLine } = this.resolveOrderByWithRelationImportAndZodSchemaLine(model);
+                if (findUnique && Transformer.isOperationEnabled(modelName, 'findUnique')) {
+                    const imports = [
+                        selectImport,
+                        includeImport,
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                    ];
+                    // Add Prisma type import for explicit type binding
+                    const crudDir = Transformer.getSchemasPath();
+                    const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                    const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                    // Generate dual schema exports for FindUnique operation
+                    const strictModeSuffix = ((_a = Transformer.getStrictModeResolver()) === null || _a === void 0 ? void 0 : _a.getOperationStrictModeSuffix(modelName, 'findUnique')) || '';
+                    const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}`, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'FindUnique', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}FindUniqueArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'FindUnique', schemaContent + dualExports);
+                }
+                // Generate findUniqueOrThrow schema (same as findUnique but with error-throwing behavior)
+                if (Transformer.isOperationEnabled(modelName, 'findUniqueOrThrow')) {
+                    const imports = [
+                        selectImport,
+                        includeImport,
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                    ];
+                    // Add Prisma type import for explicit type binding
+                    const crudDir = Transformer.getSchemasPath();
+                    const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                    const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                    // Generate dual schema exports for FindUniqueOrThrow operation
+                    const strictModeSuffix = ((_b = Transformer.getStrictModeResolver()) === null || _b === void 0 ? void 0 : _b.getOperationStrictModeSuffix(modelName, 'findUniqueOrThrow')) || '';
+                    const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}`, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'FindUniqueOrThrow', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}FindUniqueOrThrowArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'FindUniqueOrThrow', schemaContent + dualExports);
+                }
+                if (Transformer.isOperationEnabled(modelName, 'findFirst')) {
+                    const shouldInline = this.shouldInlineSelectSchema(model);
+                    // Build imports based on aggressive inlining strategy
+                    const baseImports = [
+                        includeImport, // Include always external
+                        orderByImport,
+                        this.generateInputImport(`${modelName}WhereInput`),
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                        this.generateEnumImport(`${this.getPascalCaseModelName(modelName)}ScalarFieldEnum`, `${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema`, 'root'),
+                    ];
+                    // Add select import only if NOT inlining, add inline imports if inlining
+                    const imports = shouldInline
+                        ? [...baseImports, ...this.generateInlineSelectImports(model, 'FindFirst')]
+                        : [...baseImports, selectImport];
+                    // Determine select field reference based on dual export strategy
+                    const cfg1 = Transformer.getGeneratorConfig();
+                    const target1 = ((_c = cfg1 === null || cfg1 === void 0 ? void 0 : cfg1.zodImportTarget) !== null && _c !== void 0 ? _c : 'auto');
+                    const selectFieldReference = shouldInline
+                        ? Transformer.exportTypedSchemas
+                            ? `${modelName}FindFirstSelect${Transformer.typedSchemaSuffix}.optional()`
+                            : `${modelName}FindFirstSelect${Transformer.zodSchemaSuffix}.optional()`
+                        : selectValueExpr || selectZodSchemaLineLazy.replace('select: ', '').replace(',', '');
+                    const selectField = target1 === 'v4'
+                        ? `get select(){ return ${selectFieldReference}; },`
+                        : `select: ${selectFieldReference},`;
+                    const includeFieldRef1 = this.resolveIncludeFieldReference(includeValueExpr, includeZodSchemaLineLazy, target1 === 'v4');
+                    const includeField = includeFieldRef1
+                        ? target1 === 'v4'
+                            ? `get include(){ return ${includeFieldRef1}; },`
+                            : `include: ${includeFieldRef1},`
+                        : '';
+                    const schemaFields = `${selectField} ${includeField} ${orderByZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional(), cursor: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema, ${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema.array()]).optional()`
+                        .trim()
+                        .replace(/,\s*,/g, ',');
+                    // Add Prisma type import for explicit type binding
+                    const crudDir = Transformer.getSchemasPath();
+                    const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                    let schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                    // Add inline select schema definitions (dual export pattern)
+                    if (shouldInline) {
+                        schemaContent += `// Select schema needs to be in file to prevent circular imports\n//------------------------------------------------------\n\n${this.generateDualSelectSchemaExports(model, 'FindFirst')}\n\n`;
+                    }
+                    // Generate dual schema exports for FindFirst operation
+                    const strictModeSuffix = ((_d = Transformer.getStrictModeResolver()) === null || _d === void 0 ? void 0 : _d.getOperationStrictModeSuffix(modelName, 'findFirst')) || '';
+                    const schemaObjectDefinition = this.composeObjectDefinition(schemaFields, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'FindFirst', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}FindFirstArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'FindFirst', schemaContent + dualExports);
+                }
+                // Generate findFirstOrThrow schema (same as findFirst but with error-throwing behavior)
+                if (Transformer.isOperationEnabled(modelName, 'findFirstOrThrow')) {
+                    const shouldInline = this.shouldInlineSelectSchema(model);
+                    // Build imports based on aggressive inlining strategy
+                    const baseImports = [
+                        includeImport, // Include always external
+                        orderByImport,
+                        this.generateInputImport(`${modelName}WhereInput`),
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                        this.generateEnumImport(`${this.getPascalCaseModelName(modelName)}ScalarFieldEnum`, `${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema`, 'root'),
+                    ];
+                    // Add select import only if NOT inlining, add inline imports if inlining
+                    const imports = shouldInline
+                        ? [...baseImports, ...this.generateInlineSelectImports(model, 'FindFirstOrThrow')]
+                        : [...baseImports, selectImport];
+                    // Determine select field reference based on dual export strategy
+                    const cfg2 = Transformer.getGeneratorConfig();
+                    const target2 = ((_e = cfg2 === null || cfg2 === void 0 ? void 0 : cfg2.zodImportTarget) !== null && _e !== void 0 ? _e : 'auto');
+                    const selectFieldReference = shouldInline
+                        ? Transformer.exportTypedSchemas
+                            ? `${modelName}FindFirstOrThrowSelect${Transformer.typedSchemaSuffix}.optional()`
+                            : `${modelName}FindFirstOrThrowSelect${Transformer.zodSchemaSuffix}.optional()`
+                        : selectValueExpr || selectZodSchemaLineLazy.replace('select: ', '').replace(',', '');
+                    const selectField = target2 === 'v4'
+                        ? `get select(){ return ${selectFieldReference}; },`
+                        : `select: ${selectFieldReference},`;
+                    const includeFieldRef2 = this.resolveIncludeFieldReference(includeValueExpr, includeZodSchemaLineLazy, target2 === 'v4');
+                    const includeField = includeFieldRef2
+                        ? target2 === 'v4'
+                            ? `get include(){ return ${includeFieldRef2}; },`
+                            : `include: ${includeFieldRef2},`
+                        : '';
+                    const schemaFields = `${selectField} ${includeField} ${orderByZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional(), cursor: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema, ${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema.array()]).optional()`
+                        .trim()
+                        .replace(/,\s*,/g, ',');
+                    // Add Prisma type import for explicit type binding
+                    const crudDir = Transformer.getSchemasPath();
+                    const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                    let schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                    // Add inline select schema definitions (dual export pattern)
+                    if (shouldInline) {
+                        schemaContent += `// Select schema needs to be in file to prevent circular imports\n//------------------------------------------------------\n\n${this.generateDualSelectSchemaExports(model, 'FindFirstOrThrow')}\n\n`;
+                    }
+                    const strictModeSuffix = ((_f = Transformer.getStrictModeResolver()) === null || _f === void 0 ? void 0 : _f.getOperationStrictModeSuffix(modelName, 'findFirstOrThrow')) || '';
+                    const schemaObjectDefinition = this.composeObjectDefinition(schemaFields, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'FindFirstOrThrow', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}FindFirstOrThrowArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'FindFirstOrThrow', schemaContent + dualExports);
+                }
+                if (findMany && Transformer.isOperationEnabled(modelName, 'findMany')) {
+                    const shouldInline = this.shouldInlineSelectSchema(model);
+                    // Build imports based on aggressive inlining strategy
+                    const baseImports = [
+                        includeImport, // Include always external
+                        orderByImport,
+                        this.generateInputImport(`${modelName}WhereInput`),
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                        this.generateEnumImport(`${this.getPascalCaseModelName(modelName)}ScalarFieldEnum`, `${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema`, 'root'),
+                    ];
+                    // Add select import only if NOT inlining, add inline imports if inlining
+                    const imports = shouldInline
+                        ? [...baseImports, ...this.generateInlineSelectImports(model, 'FindMany')]
+                        : [...baseImports, selectImport];
+                    // Determine select/include field reference based on dual export strategy and zod target
+                    const cfg3 = Transformer.getGeneratorConfig();
+                    const target3 = ((_g = cfg3 === null || cfg3 === void 0 ? void 0 : cfg3.zodImportTarget) !== null && _g !== void 0 ? _g : 'auto');
+                    const selectFieldReference = shouldInline
+                        ? Transformer.exportTypedSchemas
+                            ? `${modelName}FindManySelect${Transformer.typedSchemaSuffix}.optional()`
+                            : `${modelName}FindManySelect${Transformer.zodSchemaSuffix}.optional()`
+                        : selectValueExpr || selectZodSchemaLineLazy.replace('select: ', '').replace(',', '');
+                    const selectField = target3 === 'v4'
+                        ? `get select(){ return ${selectFieldReference}; },`
+                        : `select: ${selectFieldReference},`;
+                    const includeFieldRef3 = this.resolveIncludeFieldReference(includeValueExpr, includeZodSchemaLineLazy, target3 === 'v4');
+                    const includeField = includeFieldRef3
+                        ? target3 === 'v4'
+                            ? `get include(){ return ${includeFieldRef3}; },`
+                            : `include: ${includeFieldRef3},`
+                        : '';
+                    const schemaFields = `${selectField} ${includeField} ${orderByZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional(), cursor: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema, ${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema.array()]).optional()`
+                        .trim()
+                        .replace(/,\s*,/g, ',');
+                    // Add Prisma type import for explicit type binding
+                    const crudDir2 = Transformer.getSchemasPath();
+                    const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir2);
+                    let schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                    // Add inline select schema definitions (dual export pattern)
+                    if (shouldInline) {
+                        schemaContent += `// Select schema needs to be in file to prevent circular imports\n//------------------------------------------------------\n\n${this.generateDualSelectSchemaExports(model, 'FindMany')}\n\n`;
+                    }
+                    // Generate dual schema exports for FindMany operation
+                    const strictModeSuffix = ((_h = Transformer.getStrictModeResolver()) === null || _h === void 0 ? void 0 : _h.getOperationStrictModeSuffix(modelName, 'findMany')) || '';
+                    const schemaObjectDefinition = this.composeObjectDefinition(schemaFields, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'FindMany', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}FindManyArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'FindMany', schemaContent + dualExports);
+                }
+                // Generate count schema aligned with Prisma <Model>CountArgs
+                if (Transformer.isOperationEnabled(modelName, 'count')) {
+                    // Build imports
+                    const imports = [
+                        orderByImport,
+                        this.generateInputImport(`${modelName}WhereInput`),
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                        this.generateInputImport(`${this.getAggregateInputName(modelName, 'CountAggregateInput')}`),
+                    ];
+                    // Add Prisma type import for explicit type binding
+                    const crudDirCount = Transformer.getSchemasPath();
+                    const prismaImportPathCount = Transformer.resolvePrismaImportPath(crudDirCount);
+                    const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPathCount)}${this.generateImportStatements(imports)}`;
+                    const strictModeSuffix = ((_j = Transformer.getStrictModeResolver()) === null || _j === void 0 ? void 0 : _j.getOperationStrictModeSuffix(modelName, 'count')) ||
+                        '';
+                    const countSchemaObject = this.composeObjectDefinition(`${orderByZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional(), cursor: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'CountAggregateInput')}`)} ]).optional()`, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'Count', countSchemaObject, `Prisma.${this.getPrismaTypeName(modelName)}CountArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'Count', schemaContent + dualExports);
+                }
+                if (createOne && Transformer.isOperationEnabled(modelName, 'createOne')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    const isMinimalMode = (cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal';
+                    const imports = [selectImport, includeImport];
+                    let dataUnion;
+                    if (isMinimalMode) {
+                        // In minimal mode, prefer UncheckedCreateInput to avoid relation field issues
+                        imports.push(this.generateInputImport(`${modelName}UncheckedCreateInput`));
+                        dataUnion = Transformer.getObjectSchemaName(`${modelName}UncheckedCreateInput`);
+                    }
+                    else {
+                        // In full mode, use both CreateInput and UncheckedCreateInput
+                        imports.push(this.generateInputImport(`${modelName}CreateInput`), this.generateInputImport(`${modelName}UncheckedCreateInput`));
+                        dataUnion = `z.union([${Transformer.getObjectSchemaName(`${modelName}CreateInput`)}, ${Transformer.getObjectSchemaName(`${modelName}UncheckedCreateInput`)}])`;
+                    }
+                    // Add Prisma type import for explicit type binding
+                    const crudDir = Transformer.getSchemasPath();
+                    const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                    const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                    // Generate dual schema exports for CreateOne operation
+                    const strictModeSuffix = ((_k = Transformer.getStrictModeResolver()) === null || _k === void 0 ? void 0 : _k.getOperationStrictModeSuffix(modelName, 'createOne')) || '';
+                    const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} data: ${dataUnion}`, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'CreateOne', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}CreateArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'CreateOne', schemaContent + dualExports);
+                }
+                if (createMany && Transformer.isOperationEnabled(modelName, 'createMany')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        logger_1.logger.debug(`⏭️  Minimal mode: skipping ${modelName}.createMany`);
+                    }
+                    else {
+                        const imports = [this.generateInputImport(`${modelName}CreateManyInput`)];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for CreateMany operation
+                        const strictModeSuffix = ((_l = Transformer.getStrictModeResolver()) === null || _l === void 0 ? void 0 : _l.getOperationStrictModeSuffix(modelName, 'createMany')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`data: z.union([ ${Transformer.getObjectSchemaName(`${modelName}CreateManyInput`)}, z.array(${Transformer.getObjectSchemaName(`${modelName}CreateManyInput`)}) ]), ${Transformer.provider === 'postgresql' || Transformer.provider === 'cockroachdb'
+                            ? 'skipDuplicates: z.boolean().optional()'
+                            : ''}`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'CreateMany', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}CreateManyArgs`);
+                        // Use the standardized schema file generation with collision detection
+                        await Transformer.writeSchemaFile(modelName, 'CreateMany', schemaContent + dualExports);
+                    }
+                }
+                // Generate createManyAndReturn schema (same as createMany but returns created records)
+                if (Transformer.isOperationEnabled(modelName, 'createManyAndReturn')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        logger_1.logger.debug(`⏭️  Minimal mode: skipping ${modelName}.createManyAndReturn`);
+                    }
+                    else {
+                        const imports = [selectImport, this.generateInputImport(`${modelName}CreateManyInput`)];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for CreateManyAndReturn operation
+                        const strictModeSuffix = ((_m = Transformer.getStrictModeResolver()) === null || _m === void 0 ? void 0 : _m.getOperationStrictModeSuffix(modelName, 'createManyAndReturn')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} data: z.union([ ${Transformer.getObjectSchemaName(`${modelName}CreateManyInput`)}, z.array(${Transformer.getObjectSchemaName(`${modelName}CreateManyInput`)}) ]), ${Transformer.provider === 'postgresql' || Transformer.provider === 'cockroachdb'
+                            ? 'skipDuplicates: z.boolean().optional()'
+                            : ''}`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'CreateManyAndReturn', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}CreateManyAndReturnArgs`);
+                        // Use the standardized schema file generation with collision detection
+                        await Transformer.writeSchemaFile(modelName, 'CreateManyAndReturn', schemaContent + dualExports);
+                    }
+                }
+                if (deleteOne && Transformer.isOperationEnabled(modelName, 'deleteOne')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        const ops = cfg === null || cfg === void 0 ? void 0 : cfg.minimalOperations;
+                        if (Array.isArray(ops) && !ops.includes('delete') && !ops.includes('deleteOne')) {
+                            logger_1.logger.debug(`⏭️  Minimal mode (custom ops): skipping ${modelName}.deleteOne`);
+                        }
+                        else {
+                            const imports = [
+                                selectImport,
+                                includeImport,
+                                this.generateInputImport(`${modelName}WhereUniqueInput`),
+                            ];
+                            // Add Prisma type import for explicit type binding
+                            const crudDir = Transformer.getSchemasPath();
+                            const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                            const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                            // Generate dual schema exports for DeleteOne operation
+                            const strictModeSuffix = ((_o = Transformer.getStrictModeResolver()) === null || _o === void 0 ? void 0 : _o.getOperationStrictModeSuffix(modelName, 'deleteOne')) || '';
+                            const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}`, strictModeSuffix);
+                            const dualExports = this.generateDualSchemaExports(modelName, 'DeleteOne', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}DeleteArgs`);
+                            await Transformer.writeSchemaFile(modelName, 'DeleteOne', schemaContent + dualExports);
+                        }
+                    }
+                    else {
+                        const imports = [
+                            selectImport,
+                            includeImport,
+                            this.generateInputImport(`${modelName}WhereUniqueInput`),
+                        ];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for DeleteOne operation
+                        const strictModeSuffix = ((_p = Transformer.getStrictModeResolver()) === null || _p === void 0 ? void 0 : _p.getOperationStrictModeSuffix(modelName, 'deleteOne')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'DeleteOne', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}DeleteArgs`);
+                        await Transformer.writeSchemaFile(modelName, 'DeleteOne', schemaContent + dualExports);
+                    }
+                }
+                if (deleteMany && Transformer.isOperationEnabled(modelName, 'deleteMany')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        logger_1.logger.debug(`⏭️  Minimal mode: skipping ${modelName}.deleteMany`);
+                    }
+                    else {
+                        const imports = [this.generateInputImport(`${modelName}WhereInput`)];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for DeleteMany operation
+                        const strictModeSuffix = ((_q = Transformer.getStrictModeResolver()) === null || _q === void 0 ? void 0 : _q.getOperationStrictModeSuffix(modelName, 'deleteMany')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional()`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'DeleteMany', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}DeleteManyArgs`);
+                        await Transformer.writeSchemaFile(modelName, 'DeleteMany', schemaContent + dualExports);
+                    }
+                }
+                if (updateOne && Transformer.isOperationEnabled(modelName, 'updateOne')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        const ops = cfg === null || cfg === void 0 ? void 0 : cfg.minimalOperations;
+                        if (Array.isArray(ops) && !ops.includes('update') && !ops.includes('updateOne')) {
+                            logger_1.logger.debug(`⏭️  Minimal mode (custom ops): skipping ${modelName}.updateOne`);
+                            // Do not generate
+                        }
+                        else {
+                            const imports = [
+                                selectImport,
+                                includeImport,
+                                this.generateInputImport(`${modelName}UpdateInput`),
+                                this.generateInputImport(`${modelName}UncheckedUpdateInput`),
+                                this.generateInputImport(`${modelName}WhereUniqueInput`),
+                            ];
+                            // Add Prisma type import for explicit type binding
+                            const crudDir = Transformer.getSchemasPath();
+                            const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                            const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                            // Generate dual schema exports for UpdateOne operation
+                            const strictModeSuffix = ((_r = Transformer.getStrictModeResolver()) === null || _r === void 0 ? void 0 : _r.getOperationStrictModeSuffix(modelName, 'updateOne')) || '';
+                            const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${Transformer.getObjectSchemaName(`${modelName}UpdateInput`)}, ${Transformer.getObjectSchemaName(`${modelName}UncheckedUpdateInput`)}]), where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}`, strictModeSuffix);
+                            const dualExports = this.generateDualSchemaExports(modelName, 'UpdateOne', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}UpdateArgs`);
+                            await Transformer.writeSchemaFile(modelName, 'UpdateOne', schemaContent + dualExports);
+                        }
+                    }
+                    else {
+                        const imports = [
+                            selectImport,
+                            includeImport,
+                            this.generateInputImport(`${modelName}UpdateInput`),
+                            this.generateInputImport(`${modelName}UncheckedUpdateInput`),
+                            this.generateInputImport(`${modelName}WhereUniqueInput`),
+                        ];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for UpdateOne operation
+                        const strictModeSuffix = ((_s = Transformer.getStrictModeResolver()) === null || _s === void 0 ? void 0 : _s.getOperationStrictModeSuffix(modelName, 'updateOne')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${Transformer.getObjectSchemaName(`${modelName}UpdateInput`)}, ${Transformer.getObjectSchemaName(`${modelName}UncheckedUpdateInput`)}]), where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'UpdateOne', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}UpdateArgs`);
+                        await Transformer.writeSchemaFile(modelName, 'UpdateOne', schemaContent + dualExports);
+                    }
+                }
+                if (updateMany && Transformer.isOperationEnabled(modelName, 'updateMany')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        logger_1.logger.debug(`⏭️  Minimal mode: skipping ${modelName}.updateMany`);
+                    }
+                    else {
+                        const imports = [
+                            this.generateInputImport(`${modelName}UpdateManyMutationInput`),
+                            this.generateInputImport(`${modelName}WhereInput`),
+                        ];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for UpdateMany operation
+                        const strictModeSuffix = ((_t = Transformer.getStrictModeResolver()) === null || _t === void 0 ? void 0 : _t.getOperationStrictModeSuffix(modelName, 'updateMany')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`data: ${Transformer.getObjectSchemaName(`${modelName}UpdateManyMutationInput`)}, where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional()`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'UpdateMany', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}UpdateManyArgs`);
+                        await Transformer.writeSchemaFile(modelName, 'UpdateMany', schemaContent + dualExports);
+                    }
+                }
+                // Generate updateManyAndReturn schema (same as updateMany but returns updated records)
+                if (Transformer.isOperationEnabled(modelName, 'updateManyAndReturn')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        logger_1.logger.debug(`⏭️  Minimal mode: skipping ${modelName}.updateManyAndReturn`);
+                    }
+                    else {
+                        const imports = [
+                            selectImport,
+                            this.generateInputImport(`${modelName}UpdateManyMutationInput`),
+                            this.generateInputImport(`${modelName}WhereInput`),
+                        ];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for UpdateManyAndReturn operation
+                        const strictModeSuffix = ((_u = Transformer.getStrictModeResolver()) === null || _u === void 0 ? void 0 : _u.getOperationStrictModeSuffix(modelName, 'updateManyAndReturn')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} data: ${Transformer.getObjectSchemaName(`${modelName}UpdateManyMutationInput`)}, where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional()`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'UpdateManyAndReturn', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}UpdateManyAndReturnArgs`);
+                        await Transformer.writeSchemaFile(modelName, 'UpdateManyAndReturn', schemaContent + dualExports);
+                    }
+                }
+                if (upsertOne && Transformer.isOperationEnabled(modelName, 'upsertOne')) {
+                    const cfg = Transformer.getGeneratorConfig();
+                    if ((cfg === null || cfg === void 0 ? void 0 : cfg.mode) === 'minimal') {
+                        logger_1.logger.debug(`⏭️  Minimal mode: skipping ${modelName}.upsertOne`);
+                    }
+                    else {
+                        const imports = [
+                            selectImport,
+                            includeImport,
+                            this.generateInputImport(`${modelName}WhereUniqueInput`),
+                            this.generateInputImport(`${modelName}CreateInput`),
+                            this.generateInputImport(`${modelName}UncheckedCreateInput`),
+                            this.generateInputImport(`${modelName}UpdateInput`),
+                            this.generateInputImport(`${modelName}UncheckedUpdateInput`),
+                        ];
+                        // Add Prisma type import for explicit type binding
+                        const crudDir = Transformer.getSchemasPath();
+                        const prismaImportPath = Transformer.resolvePrismaImportPath(crudDir);
+                        const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPath)}${this.generateImportStatements(imports)}`;
+                        // Generate dual schema exports for UpsertOne operation
+                        const strictModeSuffix = ((_v = Transformer.getStrictModeResolver()) === null || _v === void 0 ? void 0 : _v.getOperationStrictModeSuffix(modelName, 'upsertOne')) || '';
+                        const schemaObjectDefinition = this.composeObjectDefinition(`${selectZodSchemaLine} ${includeZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}, create: z.union([ ${Transformer.getObjectSchemaName(`${modelName}CreateInput`)}, ${Transformer.getObjectSchemaName(`${modelName}UncheckedCreateInput`)} ]), update: z.union([ ${Transformer.getObjectSchemaName(`${modelName}UpdateInput`)}, ${Transformer.getObjectSchemaName(`${modelName}UncheckedUpdateInput`)} ])`, strictModeSuffix);
+                        const dualExports = this.generateDualSchemaExports(modelName, 'UpsertOne', schemaObjectDefinition, `Prisma.${this.getPrismaTypeName(modelName)}UpsertArgs`);
+                        await Transformer.writeSchemaFile(modelName, 'UpsertOne', schemaContent + dualExports);
+                    }
+                }
+                if (aggregate && Transformer.isOperationEnabled(modelName, 'aggregate')) {
+                    const imports = [
+                        orderByImport,
+                        this.generateInputImport(`${modelName}WhereInput`),
+                        this.generateInputImport(`${modelName}WhereUniqueInput`),
+                    ];
+                    const aggregateOperations = [];
+                    // All models support count, min, max operations - no complex detection needed
+                    imports.push(this.generateInputImport(`${this.getAggregateInputName(modelName, 'CountAggregateInput')}`), this.generateInputImport(`${this.getAggregateInputName(modelName, 'MinAggregateInput')}`), this.generateInputImport(`${this.getAggregateInputName(modelName, 'MaxAggregateInput')}`));
+                    // Only include Avg/Sum imports for models with numeric fields
+                    const hasNumericFields = this.modelHasNumericFields(modelName);
+                    if (hasNumericFields) {
+                        imports.push(this.generateInputImport(`${this.getAggregateInputName(modelName, 'AvgAggregateInput')}`), this.generateInputImport(`${this.getAggregateInputName(modelName, 'SumAggregateInput')}`));
+                    }
+                    aggregateOperations.push(`_count: z.union([ z.literal(true), ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'CountAggregateInput')}`)} ]).optional()`, `_min: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'MinAggregateInput')}`)}.optional()`, `_max: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'MaxAggregateInput')}`)}.optional()`);
+                    // Only include _avg and _sum for models with numeric fields
+                    if (hasNumericFields) {
+                        aggregateOperations.push(`_avg: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'AvgAggregateInput')}`)}.optional()`, `_sum: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'SumAggregateInput')}`)}.optional()`);
+                    }
+                    // Add Prisma type import for explicit type binding
+                    const crudDirAggregate = Transformer.getSchemasPath();
+                    const prismaImportPathAggregate = Transformer.resolvePrismaImportPath(crudDirAggregate);
+                    const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPathAggregate)}${this.generateImportStatements(imports)}`;
+                    // Generate dual schema exports for Aggregate operation
+                    const strictModeSuffix = ((_w = Transformer.getStrictModeResolver()) === null || _w === void 0 ? void 0 : _w.getOperationStrictModeSuffix(modelName, 'aggregate')) || '';
+                    const aggregateSchemaObject = this.composeObjectDefinition(`${orderByZodSchemaLine} where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional(), cursor: ${Transformer.getObjectSchemaName(`${modelName}WhereUniqueInput`)}.optional(), take: z.number().optional(), skip: z.number().optional(), ${aggregateOperations.join(', ')}`, strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'Aggregate', aggregateSchemaObject, `Prisma.${this.getPrismaTypeName(modelName, 'Aggregate')}AggregateArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'Aggregate', schemaContent + dualExports);
+                }
+                if (groupBy && Transformer.isOperationEnabled(modelName, 'groupBy')) {
+                    const imports = [
+                        this.generateInputImport(`${modelName}WhereInput`),
+                        this.generateInputImport(`${modelName}OrderByWithAggregationInput`),
+                        this.generateInputImport(`${modelName}ScalarWhereWithAggregatesInput`),
+                        this.generateEnumImport(`${this.getPascalCaseModelName(modelName)}ScalarFieldEnum`, `${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema`, 'root'),
+                        this.generateInputImport(`${this.getAggregateInputName(modelName, 'CountAggregateInput')}`),
+                        this.generateInputImport(`${this.getAggregateInputName(modelName, 'MinAggregateInput')}`),
+                        this.generateInputImport(`${this.getAggregateInputName(modelName, 'MaxAggregateInput')}`),
+                    ];
+                    // Only include Avg/Sum imports for models with numeric fields
+                    const hasNumericFieldsForGroupBy = this.modelHasNumericFields(modelName);
+                    if (hasNumericFieldsForGroupBy) {
+                        imports.push(this.generateInputImport(`${this.getAggregateInputName(modelName, 'AvgAggregateInput')}`), this.generateInputImport(`${this.getAggregateInputName(modelName, 'SumAggregateInput')}`));
+                    }
+                    // Add Prisma type import for explicit type binding
+                    const crudDirGroupBy = Transformer.getSchemasPath();
+                    const prismaImportPathGroupBy = Transformer.resolvePrismaImportPath(crudDirGroupBy);
+                    const schemaContent = `${Transformer.prismaTypeImportLine(prismaImportPathGroupBy)}${this.generateImportStatements(imports)}`;
+                    // Generate dual schema exports for GroupBy operation
+                    const baseFields = [
+                        `where: ${Transformer.getObjectSchemaName(`${modelName}WhereInput`)}.optional()`,
+                        `orderBy: z.union([${Transformer.getObjectSchemaName(`${modelName}OrderByWithAggregationInput`)}, ${Transformer.getObjectSchemaName(`${modelName}OrderByWithAggregationInput`)}.array()]).optional()`,
+                        `having: ${Transformer.getObjectSchemaName(`${modelName}ScalarWhereWithAggregatesInput`)}.optional()`,
+                        'take: z.number().optional()',
+                        'skip: z.number().optional()',
+                        `by: z.array(${this.getPascalCaseModelName(modelName)}ScalarFieldEnumSchema)`,
+                        `_count: z.union([ z.literal(true), ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'CountAggregateInput')}`)} ]).optional()`,
+                        `_min: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'MinAggregateInput')}`)}.optional()`,
+                        `_max: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'MaxAggregateInput')}`)}.optional()`,
+                    ];
+                    // Only include _avg and _sum for models with numeric fields
+                    if (hasNumericFieldsForGroupBy) {
+                        baseFields.push(`_avg: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'AvgAggregateInput')}`)}.optional()`, `_sum: ${Transformer.getObjectSchemaName(`${this.getAggregateInputName(modelName, 'SumAggregateInput')}`)}.optional()`);
+                    }
+                    const strictModeSuffix = ((_x = Transformer.getStrictModeResolver()) === null || _x === void 0 ? void 0 : _x.getOperationStrictModeSuffix(modelName, 'groupBy')) || '';
+                    const groupBySchemaObject = this.composeObjectDefinition(baseFields.join(', '), strictModeSuffix);
+                    const dualExports = this.generateDualSchemaExports(modelName, 'GroupBy', groupBySchemaObject, `Prisma.${this.getPrismaTypeName(modelName)}GroupByArgs`);
+                    // Use the standardized schema file generation with collision detection
+                    await Transformer.writeSchemaFile(modelName, 'GroupBy', schemaContent + dualExports);
+                }
+            }
+            catch (err) {
+                // Log error with contextual information before continuing to next model
+                logger_1.logger.error(`Failed to generate schemas for model "${modelOperation.model}":`, err);
+                continue;
+            }
+        }
+    }
+    /**
+     * Generate result schemas for all enabled models
+     */
+    async generateResultSchemas() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const config = Transformer.getGeneratorConfig();
+        if ((config === null || config === void 0 ? void 0 : config.emit) && config.emit.results === false) {
+            logger_1.logger.debug('⏭️  emit.results=false (skipping result schema generation)');
+            return;
+        }
+        // Check if result schemas are enabled globally
+        if ((config === null || config === void 0 ? void 0 : config.mode) === 'minimal') {
+            logger_1.logger.debug('⏭️  Skipping result schema generation in minimal mode');
+            return;
+        }
+        // `variants` also accepts the array form of custom variants, which has no pure/input/result keys.
+        const builtInVariants = Array.isArray(config === null || config === void 0 ? void 0 : config.variants) ? undefined : config === null || config === void 0 ? void 0 : config.variants;
+        if (((_a = builtInVariants === null || builtInVariants === void 0 ? void 0 : builtInVariants.result) === null || _a === void 0 ? void 0 : _a.enabled) === false) {
+            logger_1.logger.debug('⏭️  Result schema generation is disabled globally');
+            return;
+        }
+        const generatorConfig = Transformer.getGeneratorConfig();
+        if (!generatorConfig) {
+            throw new Error('Generator config not available for result schema generation');
+        }
+        // The typed-JSON context is where the *file* sits, which the generator cannot know:
+        // a relative `typedJson.schemaModule` has to resolve from `results/`, and in
+        // single-file mode from wherever the bundle lands. It is inert unless the user set
+        // `typedJson.applyToResults`.
+        const resultGenerator = new results_1.ResultSchemaGenerator(generatorConfig, {
+            outputSubdir: Transformer.typedJsonOutputSubdir('results'),
+            importExtension: Transformer.getImportFileExtension(),
+            singleFile: (0, singleFileAggregator_1.isSingleFileEnabled)(),
+        });
+        // Determine which pure model schemas (schemas/models/<Model>.schema.ts) are
+        // emitted so relation fields in result schemas can reference them instead of
+        // falling back to z.unknown(). Reuse the exact pure-model emission predicate
+        // (see prisma-generator.ts) and the shared pure-model naming resolver.
+        //
+        // Single-file mode intentionally yields an empty map: the aggregator inlines
+        // every schema into one bundle and strips relative imports, and result
+        // schemas are emitted before pure models in that bundle, so a forward
+        // reference would not resolve. Relations therefore degrade to the safe
+        // z.unknown() fallback in single-file mode.
+        // Mirror BOTH gates that guard pure-model emission in prisma-generator.ts:
+        //  1) the emit gate:            emit.pureModels ?? !!pureModels   (call site)
+        //  2) generatePureModelSchemas: returns early unless pureModels is truthy
+        // so files exist only when the emit gate is on AND pureModels is truthy.
+        // Using both avoids referencing models/ files that were never written
+        // (e.g. emit.pureModels=true while pureModels is falsy).
+        const emitPureModelsGate = (_c = (_b = generatorConfig.emit) === null || _b === void 0 ? void 0 : _b.pureModels) !== null && _c !== void 0 ? _c : !!generatorConfig.pureModels;
+        const pureModelsEmitted = emitPureModelsGate && !!generatorConfig.pureModels;
+        const importExtension = Transformer.getImportFileExtension();
+        const availablePureModels = new Map();
+        if (pureModelsEmitted && !(0, singleFileAggregator_1.isSingleFileEnabled)()) {
+            const namingResolved = (0, naming_resolver_1.resolvePureModelNaming)(generatorConfig);
+            for (const candidate of this.models) {
+                if (!Transformer.isModelEnabled(candidate.name))
+                    continue;
+                const modelFileName = (0, naming_resolver_1.applyPattern)(namingResolved.filePattern, candidate.name, namingResolved.schemaSuffix, namingResolved.typeSuffix);
+                const modelExportName = (0, naming_resolver_1.applyPattern)(namingResolved.exportNamePattern, candidate.name, namingResolved.schemaSuffix, namingResolved.typeSuffix);
+                availablePureModels.set(candidate.name, {
+                    exportName: modelExportName,
+                    fileBase: modelFileName.replace(/\.ts$/, ''),
+                });
+            }
+        }
+        resultGenerator.setAvailablePureModels(availablePureModels);
+        const opSuffix = (op) => {
+            switch (op) {
+                case 'findUnique':
+                    return 'FindUnique';
+                case 'findFirst':
+                    return 'FindFirst';
+                case 'findMany':
+                    return 'FindMany';
+                case 'create':
+                    return 'Create';
+                case 'createMany':
+                    return 'CreateMany';
+                case 'update':
+                    return 'Update';
+                case 'updateMany':
+                    return 'UpdateMany';
+                case 'upsert':
+                    return 'Upsert';
+                case 'delete':
+                    return 'Delete';
+                case 'deleteMany':
+                    return 'DeleteMany';
+                case 'aggregate':
+                    return 'Aggregate';
+                case 'groupBy':
+                    return 'GroupBy';
+                case 'count':
+                    return 'Count';
+                default:
+                    return op;
+            }
+        };
+        for (const model of this.models) {
+            // Skip generation for disabled models
+            if (!Transformer.isModelEnabled(model.name)) {
+                continue;
+            }
+            // Check if result schemas are enabled for this specific model
+            const modelConfig = (_d = config === null || config === void 0 ? void 0 : config.models) === null || _d === void 0 ? void 0 : _d[model.name];
+            if (((_f = (_e = modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.variants) === null || _e === void 0 ? void 0 : _e.result) === null || _f === void 0 ? void 0 : _f.enabled) === false) {
+                logger_1.logger.debug(`⏭️  Result schema generation is disabled for model: ${model.name}`);
+                continue;
+            }
+            logger_1.logger.debug(`🎯 Generating result schemas for model: ${model.name}`);
+            // Generate all result schemas for this model
+            const resultSchemas = resultGenerator.generateAllResultSchemas(model);
+            // Create results directory if it doesn't exist
+            const resultsPath = path_1.default.join(Transformer.getSchemasPath(), 'results');
+            // Write each result schema to appropriate file
+            for (const resultSchema of resultSchemas) {
+                const fileName = `${model.name}${opSuffix(resultSchema.operationType)}Result.schema.ts`;
+                const filePath = path_1.default.join(resultsPath, fileName);
+                // Generate imports only for schemas that are actually used
+                const imports = [];
+                // Add zod import
+                imports.push(this.generateImportZodStatement());
+                // Only add other imports if they're actually referenced in the schema
+                if (resultSchema.dependencies && resultSchema.dependencies.length > 0) {
+                    resultSchema.dependencies.forEach((dep) => {
+                        // Derive input base from common exported identifiers
+                        const base = dep
+                            .replace(/(ObjectSchema|ObjectZodSchema|Schema)$/, '')
+                            .replace(/(Select|Include)$/, '$1'); // keep Select/Include tokens
+                        const isSelectOrInclude = /(Select|Include)(ObjectSchema|ObjectZodSchema|Schema)?$/.test(dep);
+                        imports.push(isSelectOrInclude
+                            ? this.generateObjectInputImport(base, 'results')
+                            : this.generateInputImport(base, 'results'));
+                    });
+                }
+                // Import pure model schemas referenced by relation fields from ../models.
+                // These are distinct from `dependencies` (which route through ../objects).
+                if (resultSchema.modelDependencies && resultSchema.modelDependencies.length > 0) {
+                    const seenModelImports = new Set();
+                    for (const depModelName of resultSchema.modelDependencies) {
+                        const info = availablePureModels.get(depModelName);
+                        if (!info)
+                            continue; // safety: only import models known to be emitted
+                        if (seenModelImports.has(info.exportName))
+                            continue; // de-dupe
+                        seenModelImports.add(info.exportName);
+                        imports.push(`import { ${info.exportName} } from '../models/${info.fileBase}${importExtension}';\n`);
+                    }
+                }
+                // Typed-JSON replacements, already merged per module and filtered to the names
+                // this file mentions. Empty unless `typedJson.applyToResults` is on, which is
+                // what keeps the emitted bytes identical for everyone who did not ask for this.
+                for (const typedJsonImport of (_g = resultSchema.typedJsonImports) !== null && _g !== void 0 ? _g : []) {
+                    imports.push(`${typedJsonImport.importStatement};\n`);
+                }
+                await (0, writeFileSafely_1.writeFileSafely)(filePath, `${imports.join('')}${resultSchema.zodSchema}`);
+            }
+        }
+        // Generate consolidated index file for all result schemas
+        const resultIndexPath = path_1.default.join(Transformer.getSchemasPath(), 'results', 'index.ts');
+        // `importExtension` is already resolved above for this method.
+        const allExports = [];
+        // Collect all result schema exports for all processed models
+        for (const model of this.models) {
+            if (!Transformer.isModelEnabled(model.name)) {
+                continue;
+            }
+            const modelConfig = (_h = config === null || config === void 0 ? void 0 : config.models) === null || _h === void 0 ? void 0 : _h[model.name];
+            if (((_k = (_j = modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.variants) === null || _j === void 0 ? void 0 : _j.result) === null || _k === void 0 ? void 0 : _k.enabled) === false) {
+                continue;
+            }
+            const resultSchemas = resultGenerator.generateAllResultSchemas(model);
+            for (const resultSchema of resultSchemas) {
+                allExports.push(`export { ${resultSchema.schemaName} } from './${model.name}${opSuffix(resultSchema.operationType)}Result.schema${importExtension}';`);
+            }
+        }
+        if (allExports.length > 0) {
+            await (0, writeFileSafely_1.writeFileSafely)(resultIndexPath, allExports.join('\n') + '\n');
+            // Add results index to main index exports
+            (0, writeIndexFile_1.addIndexExport)(resultIndexPath);
+        }
+    }
+    generateImportStatements(imports) {
+        var _a;
+        let generatedImports = this.generateImportZodStatement();
+        // Filter out empty, undefined, and invalid imports
+        const validImports = Transformer.cleanAndValidateImports(imports);
+        // Log import management if any filtering occurred
+        Transformer.logImportManagement(imports, validImports, this.name);
+        // Ensure each import has a semicolon and join with newlines
+        const formattedImports = validImports.map((imp) => (imp.endsWith(';') ? imp : imp + ';'));
+        generatedImports += (_a = formattedImports.join('\n')) !== null && _a !== void 0 ? _a : '';
+        generatedImports += '\n\n';
+        return generatedImports;
+    }
+    /**
+     * Clean and validate import array, removing empty and invalid imports
+     */
+    static cleanAndValidateImports(imports) {
+        return imports
+            .filter((importItem) => {
+            // Remove undefined/null/empty imports
+            if (!importItem || importItem.trim() === '') {
+                return false;
+            }
+            // Extract import information for validation
+            const importInfo = Transformer.parseImportStatement(importItem);
+            if (!importInfo) {
+                return true; // Keep imports we can't parse (might be external libraries)
+            }
+            // Check if the import should be generated based on filtering rules
+            return Transformer.shouldGenerateImport(importInfo.importName, importInfo.relatedModel);
+        })
+            .filter((importItem, index, array) => {
+            // Remove duplicate imports
+            return array.indexOf(importItem) === index;
+        });
+    }
+    /**
+     * Parse import statement to extract information
+     */
+    static parseImportStatement(importStatement) {
+        // Support: import { X } from '...'; import { X as Y } from '...'; import type { X as Y } from '...'; default imports as fallback
+        const match = importStatement.match(/import\s*(?:type\s*)?\{\s*(\w+)(?:\s+as\s+\w+)?\s*\}\s*from\s*['"]([^'"]+)['"]/) || importStatement.match(/import\s*(?:type\s*)?(\w+)\s*from\s*['"]([^'"]+)['"]/);
+        if (!match) {
+            return null;
+        }
+        const importName = match[1];
+        const importPath = match[2];
+        const relatedModel = Transformer.extractModelFromImportName(importName);
+        return {
+            importName,
+            importPath,
+            relatedModel: relatedModel || undefined,
+        };
+    }
+    /**
+     * Log import management information
+     */
+    static logImportManagement(originalImports, cleanedImports, context) {
+        const originalCount = originalImports.filter((imp) => imp && imp.trim()).length;
+        const cleanedCount = cleanedImports.length;
+        if (originalCount !== cleanedCount) {
+            const contextStr = context ? ` for ${context}` : '';
+            logger_1.logger.debug(`   📦 Import cleanup${contextStr}: ${originalCount - cleanedCount} filtered (${cleanedCount}/${originalCount} kept)`);
+        }
+    }
+    /**
+     * Validate filter combinations and detect conflicts
+     */
+    static validateFilterCombinations(allModels) {
+        const config = this.getGeneratorConfig();
+        const result = {
+            isValid: true,
+            warnings: [],
+            errors: [],
+            suggestions: [],
+        };
+        if (!config) {
+            return result; // No configuration to validate
+        }
+        // Check model dependencies and relationships
+        this.validateModelDependencies(allModels, result);
+        // Check operation consistency
+        this.validateOperationConsistency(allModels, result);
+        // Check field exclusion conflicts
+        this.validateFieldExclusions(allModels, result);
+        // Check variant consistency
+        this.validateVariantConsistency(result);
+        // Check mode consistency
+        this.validateModeConsistency(result);
+        return result;
+    }
+    /**
+     * Validate model dependencies and relationships
+     */
+    static validateModelDependencies(allModels, result) {
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        for (const model of allModels) {
+            if (!this.isModelEnabled(model.name))
+                continue;
+            // Check if this model has relationships to disabled models
+            const disabledRelations = model.fields.filter((field) => {
+                return field.kind === 'object' && field.relationName && !this.isModelEnabled(field.type);
+            });
+            if (disabledRelations.length > 0) {
+                const disabledModels = disabledRelations.map((f) => f.type);
+                result.warnings.push(`Model "${model.name}" has relations to disabled models: ${disabledModels.join(', ')}. ` +
+                    `This may cause incomplete schema generation.`);
+                result.suggestions.push(`Consider enabling models [${disabledModels.join(', ')}] or removing relation fields ` +
+                    `[${disabledRelations.map((f) => f.name).join(', ')}] from ${model.name}`);
+            }
+        }
+    }
+    /**
+     * Validate operation consistency across models
+     */
+    static validateOperationConsistency(allModels, result) {
+        var _a;
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        const enabledModels = allModels.filter((m) => this.isModelEnabled(m.name));
+        for (const model of enabledModels) {
+            const modelConfig = (_a = config.models) === null || _a === void 0 ? void 0 : _a[model.name];
+            if (!(modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.operations))
+                continue;
+            // Check for operations that require relationships
+            const requiresRelations = ['aggregate', 'groupBy'];
+            const hasEnabledRelations = (0, model_helpers_1.checkModelHasEnabledModelRelation)(model);
+            for (const operation of requiresRelations) {
+                if (modelConfig.operations.includes(operation) && !hasEnabledRelations) {
+                    result.warnings.push(`Model "${model.name}" has "${operation}" operation enabled but no active relationships. ` +
+                        `This operation may not function as expected.`);
+                }
+            }
+            // Check for circular dependencies in custom operations
+            if (modelConfig.operations.length === 0) {
+                result.warnings.push(`Model "${model.name}" has no operations enabled. Consider disabling the model entirely.`);
+            }
+        }
+    }
+    /**
+     * Validate field exclusion conflicts
+     */
+    static validateFieldExclusions(allModels, result) {
+        var _a;
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        const enabledModels = allModels.filter((m) => this.isModelEnabled(m.name));
+        for (const model of enabledModels) {
+            const modelConfig = (_a = config.models) === null || _a === void 0 ? void 0 : _a[model.name];
+            if (!(modelConfig === null || modelConfig === void 0 ? void 0 : modelConfig.variants))
+                continue;
+            // Check each variant for field exclusion conflicts
+            Object.entries(modelConfig.variants).forEach(([variantName, variantConfig]) => {
+                if (!(variantConfig === null || variantConfig === void 0 ? void 0 : variantConfig.excludeFields))
+                    return;
+                const variant = variantName;
+                // Check if all fields would be excluded
+                const totalFields = model.fields.length;
+                const excludedFields = variantConfig.excludeFields.length;
+                if (excludedFields >= totalFields) {
+                    result.errors.push(`Model "${model.name}" ${variant} variant excludes all fields. This will result in empty schemas.`);
+                    result.isValid = false;
+                }
+                // Check for required fields being excluded
+                const requiredFields = model.fields.filter((f) => f.isRequired && f.kind === 'scalar');
+                const excludedRequiredFields = requiredFields.filter((f) => variantConfig.excludeFields && variantConfig.excludeFields.includes(f.name));
+                if (excludedRequiredFields.length > 0 && variant === 'input') {
+                    result.warnings.push(`Model "${model.name}" ${variant} variant excludes required fields: ` +
+                        `${excludedRequiredFields.map((f) => f.name).join(', ')}. This may cause validation issues.`);
+                }
+            });
+        }
+    }
+    /**
+     * Validate variant consistency
+     */
+    static validateVariantConsistency(result) {
+        const config = this.getGeneratorConfig();
+        if (!(config === null || config === void 0 ? void 0 : config.variants))
+            return;
+        // Check if variants are configured but no models use them
+        // `variants` also accepts the array form of custom variants, which has no pure/input/result keys.
+        const builtInForWarning = Array.isArray(config.variants) ? undefined : config.variants;
+        const configuredVariants = Object.keys(builtInForWarning !== null && builtInForWarning !== void 0 ? builtInForWarning : {});
+        const enabledVariants = configuredVariants.filter((variant) => { var _a; return (_a = builtInForWarning === null || builtInForWarning === void 0 ? void 0 : builtInForWarning[variant]) === null || _a === void 0 ? void 0 : _a.enabled; });
+        if (enabledVariants.length === 0) {
+            result.warnings.push('Variants are configured but none are enabled. Consider enabling at least one variant or removing variant configuration.');
+        }
+        // Check for conflicting variant settings
+        if (config.mode === 'minimal' && enabledVariants.includes('result')) {
+            result.warnings.push('Minimal mode with result variant enabled may generate more schemas than expected. ' +
+                'Consider using only pure and input variants in minimal mode.');
+        }
+    }
+    /**
+     * Validate mode consistency
+     */
+    static validateModeConsistency(result) {
+        const config = this.getGeneratorConfig();
+        if (!config)
+            return;
+        // Check if minimal mode has models configured
+        if (config.mode === 'minimal' && (!config.models || Object.keys(config.models).length === 0)) {
+            // In minimal mode, absence of explicit model configuration should default to "all models enabled".
+            // Provide a non-blocking suggestion instead of an error so generation can proceed.
+            result.warnings.push('Minimal mode without explicit model configuration: generating schemas for all models with minimal constraints.');
+            result.suggestions.push('Optionally add model configurations to fine-tune which models/operations are emitted in minimal mode.');
+        }
+        // Check if custom mode has meaningful configuration
+        if (config.mode === 'custom' && (!config.models || Object.keys(config.models).length === 0)) {
+            result.warnings.push('Custom mode without model configurations will behave like full mode. Consider adding specific model settings.');
+        }
+    }
+    /**
+     * Log filter validation results
+     */
+    static logFilterValidation(validationResult) {
+        const { isValid, errors, warnings, suggestions } = validationResult;
+        if (errors.length > 0) {
+            logger_1.logger.warn('❌ Filter Validation Errors:');
+            errors.forEach((error) => logger_1.logger.warn(`   • ${error}`));
+        }
+        if (warnings.length > 0) {
+            logger_1.logger.warn('⚠️  Filter Validation Warnings:');
+            warnings.forEach((warning) => logger_1.logger.warn(`   • ${warning}`));
+        }
+        if (suggestions.length > 0) {
+            logger_1.logger.info('💡 Suggestions:');
+            suggestions.forEach((suggestion) => logger_1.logger.info(`   • ${suggestion}`));
+        }
+        if (isValid && errors.length === 0 && warnings.length === 0) {
+            logger_1.logger.debug('✅ Filter configuration validation passed');
+        }
+    }
+    /**
+     * Perform comprehensive filter validation
+     */
+    static performFilterValidation(allModels) {
+        const validationResult = this.validateFilterCombinations(allModels);
+        this.logFilterValidation(validationResult);
+        return validationResult.isValid;
+    }
+    resolveSelectIncludeImportAndZodSchemaLine(model) {
+        var _a;
+        const { name: modelName } = model;
+        // Log relationship preservation information
+        Transformer.logRelationshipPreservation(model);
+        const selectImport = Transformer.shouldGenerateSelectSchema(model)
+            ? this.generateObjectInputImport(`${modelName}Select`, 'root')
+            : '';
+        const includeImport = Transformer.shouldGenerateIncludeSchema(model)
+            ? this.generateObjectInputImport(`${modelName}Include`, 'root')
+            : '';
+        let selectZodSchemaLine = '';
+        let includeZodSchemaLine = '';
+        let selectZodSchemaLineLazy = '';
+        let includeZodSchemaLineLazy = '';
+        let selectValueExpr = '';
+        let includeValueExpr = '';
+        const cfg = Transformer.getGeneratorConfig();
+        const target = ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.zodImportTarget) !== null && _a !== void 0 ? _a : 'auto');
+        if (Transformer.shouldGenerateSelectSchema(model)) {
+            const selectSchemaName = Transformer.exportTypedSchemas
+                ? `${modelName}SelectObjectSchema`
+                : `${modelName}SelectObject${Transformer.zodSchemaSuffix}`;
+            const zodSelectObjectSchema = `${selectSchemaName}.optional()`;
+            selectValueExpr = zodSelectObjectSchema;
+            if (target === 'v4') {
+                selectZodSchemaLine = `get select(){ return ${zodSelectObjectSchema}; },`;
+                selectZodSchemaLineLazy = selectZodSchemaLine;
+            }
+            else {
+                selectZodSchemaLine = `select: ${zodSelectObjectSchema},`;
+                selectZodSchemaLineLazy = `select: z.lazy(() => ${zodSelectObjectSchema}),`;
+            }
+        }
+        if (Transformer.shouldGenerateIncludeSchema(model)) {
+            const includeSchemaName = Transformer.exportTypedSchemas
+                ? `${modelName}IncludeObjectSchema`
+                : `${modelName}IncludeObject${Transformer.zodSchemaSuffix}`;
+            const zodIncludeObjectSchema = `${includeSchemaName}.optional()`;
+            includeValueExpr = zodIncludeObjectSchema;
+            if (target === 'v4') {
+                includeZodSchemaLine = `get include(){ return ${zodIncludeObjectSchema}; },`;
+                includeZodSchemaLineLazy = includeZodSchemaLine;
+            }
+            else {
+                includeZodSchemaLine = `include: ${zodIncludeObjectSchema},`;
+                includeZodSchemaLineLazy = `include: z.lazy(() => ${zodIncludeObjectSchema}),`;
+            }
+        }
+        return {
+            selectImport,
+            includeImport,
+            selectZodSchemaLine,
+            includeZodSchemaLine,
+            selectZodSchemaLineLazy,
+            includeZodSchemaLineLazy,
+            selectValueExpr,
+            includeValueExpr,
+        };
+    }
+    resolveIncludeFieldReference(includeValueExpr, includeZodSchemaLineLazy, isV4Target = false) {
+        if (!includeValueExpr && !includeZodSchemaLineLazy) {
+            return '';
+        }
+        if (isV4Target) {
+            return includeValueExpr !== null && includeValueExpr !== void 0 ? includeValueExpr : '';
+        }
+        if (includeZodSchemaLineLazy) {
+            return includeZodSchemaLineLazy.replace('include: ', '').replace(',', '').trim();
+        }
+        return includeValueExpr !== null && includeValueExpr !== void 0 ? includeValueExpr : '';
+    }
+    resolveOrderByWithRelationImportAndZodSchemaLine(model) {
+        var _a;
+        const { name: modelName } = model;
+        let modelOrderBy = '';
+        if (['postgresql', 'mysql'].includes(Transformer.provider) &&
+            ((_a = Transformer.previewFeatures) === null || _a === void 0 ? void 0 : _a.includes('fullTextSearch'))) {
+            modelOrderBy = `${modelName}OrderByWithRelationAndSearchRelevanceInput`;
+        }
+        else {
+            modelOrderBy = `${modelName}OrderByWithRelationInput`;
+        }
+        const orderByImport = this.generateInputImport(modelOrderBy);
+        const orderByZodSchemaLine = `orderBy: z.union([${Transformer.getObjectSchemaName(modelOrderBy)}, ${Transformer.getObjectSchemaName(modelOrderBy)}.array()]).optional(),`;
+        return { orderByImport, orderByZodSchemaLine };
+    }
+    /**
+     * Determines if a select schema should be inlined to avoid circular dependencies.
+     * Following community generator approach: ALWAYS inline select schemas.
+     * Use lazy loading only for specific relation fields within the inlined schema.
+     */
+    shouldInlineSelectSchema(_model) {
+        // Community generator approach: Always inline select schemas
+        // This prevents circular imports by keeping select definitions local
+        // Use z.lazy() only for relation fields within the inlined schema
+        return true; // Always inline - aggressive inlining like community generator
+    }
+    /**
+     * Resolves the nested-args schema a relation field should union with inside an
+     * inline select schema, mirroring the gating used for objects/<Model>Select.schema.ts
+     * (see select-helpers/include-helpers). Returns null when only booleans are allowed
+     * (minimal mode, select+include both disabled, or the related model disabled).
+     */
+    resolveInlineSelectRelationTarget(field) {
+        if (!field.relationName)
+            return null;
+        const config = Transformer.getGeneratorConfig();
+        if ((config === null || config === void 0 ? void 0 : config.mode) === 'minimal')
+            return null;
+        if (!Transformer.isGenerateSelect && !Transformer.isGenerateInclude)
+            return null;
+        if (!Transformer.isModelEnabled(field.type))
+            return null;
+        if (field.isList && (0, model_helpers_1.isOperationEnabledForModel)(field.type, 'findMany')) {
+            return { kind: 'query', modelName: field.type };
+        }
+        return { kind: 'args', typeName: `${field.type}Args` };
+    }
+    /**
+     * Resolves the <Model>CountOutputTypeArgs reference for the `_count` field of an
+     * inline select schema, or null when `_count` must remain boolean-only.
+     */
+    resolveInlineSelectCountArgsReference(model) {
+        const config = Transformer.getGeneratorConfig();
+        if ((config === null || config === void 0 ? void 0 : config.mode) === 'minimal')
+            return null;
+        if (!Transformer.isGenerateSelect)
+            return null;
+        return Transformer.getObjectSchemaName(`${model.name}CountOutputTypeArgs`);
+    }
+    /**
+     * Resolve the actual exported identifier of a model query schema file, matching the
+     * naming used by generateDualSchemaExports (typed export when enabled, Zod export
+     * otherwise, honoring naming.schema.exportNamePattern).
+     */
+    resolveModelQueryExportName(modelName, operationType) {
+        var _a, _b;
+        let baseExportName = `${modelName}${operationType}`;
+        try {
+            const schemaNamingConfig = (_b = (_a = Transformer.getGeneratorConfig()) === null || _a === void 0 ? void 0 : _a.naming) === null || _b === void 0 ? void 0 : _b.schema;
+            if (schemaNamingConfig === null || schemaNamingConfig === void 0 ? void 0 : schemaNamingConfig.exportNamePattern) {
+                const customExportName = (0, naming_resolver_1.generateExportName)(schemaNamingConfig.exportNamePattern, modelName, operationType);
+                if (customExportName) {
+                    baseExportName = customExportName;
+                }
+            }
+        }
+        catch {
+            // Fallback to default naming
+        }
+        if (Transformer.exportTypedSchemas) {
+            return baseExportName.endsWith('Schema')
+                ? baseExportName
+                : `${baseExportName}${Transformer.typedSchemaSuffix}`;
+        }
+        return `${baseExportName}${Transformer.zodSchemaSuffix}`;
+    }
+    /**
+     * Generate an import statement for a root-level model query schema file
+     * (e.g. findManyPost.schema.ts), honoring naming.schema patterns. `from`
+     * selects the relative prefix: './' for root-level CRUD files, '../' for
+     * files inside objects/.
+     */
+    generateModelQueryImport(modelName, queryName, from = 'objects') {
+        const importExtension = this.getImportFileExtension();
+        const prefix = from === 'objects' ? '..' : '.';
+        const operation = queryName.charAt(0).toUpperCase() + queryName.slice(1);
+        const aliasName = this.resolveModelQuerySchemaName(modelName, queryName);
+        try {
+            const schemaCfg = (0, naming_resolver_1.resolveSchemaNaming)(Transformer.getGeneratorConfig());
+            const fileName = (0, naming_resolver_1.generateFileName)(schemaCfg.filePattern, modelName, operation);
+            const baseName = fileName.replace(/\.ts$/, '');
+            const exportName = this.resolveModelQueryExportName(modelName, operation);
+            if (exportName === aliasName) {
+                return `import { ${exportName} } from '${prefix}/${baseName}${importExtension}'`;
+            }
+            return `import { ${exportName} as ${aliasName} } from '${prefix}/${baseName}${importExtension}'`;
+        }
+        catch {
+            // Fallback to legacy hardcoded naming if naming resolver fails
+            return `import { ${aliasName} } from '${prefix}/${operation}${modelName}.schema${importExtension}'`;
+        }
+    }
+    /**
+     * Generates the additional imports needed for inlined select schemas.
+     * Returns import statements for the model query / Args schemas referenced by
+     * relation-field unions (mirroring objects/<Model>Select.schema.ts imports).
+     */
+    generateInlineSelectImports(model, operation) {
+        const imports = [];
+        for (const field of model.fields) {
+            const relationTarget = this.resolveInlineSelectRelationTarget(field);
+            if (!relationTarget)
+                continue;
+            if (relationTarget.kind === 'query') {
+                // A self list relation inside the findMany file references an export declared
+                // later in the same file; z.lazy defers the dereference, so no import is needed.
+                if (operation === 'FindMany' && relationTarget.modelName === model.name)
+                    continue;
+                imports.push(this.generateModelQueryImport(relationTarget.modelName, 'findMany', 'root'));
+            }
+            else {
+                imports.push(this.generateObjectInputImport(relationTarget.typeName, 'root'));
+            }
+        }
+        const hasArrayRelations = model.fields.some((field) => field.relationName && field.isList);
+        if (hasArrayRelations && this.resolveInlineSelectCountArgsReference(model)) {
+            imports.push(this.generateObjectInputImport(`${model.name}CountOutputTypeArgs`, 'root'));
+        }
+        // Remove duplicates
+        return [...new Set(imports)];
+    }
+    /**
+     * Generates dual schema exports: typed version and Zod-method-friendly version
+     */
+    generateDualSchemaExports(modelName, operationType, schemaDefinition, prismaType) {
+        var _a;
+        const exports = [];
+        // Use schema naming configuration if available
+        let baseExportName = `${modelName}${operationType}`;
+        try {
+            const config = Transformer.getGeneratorConfig();
+            const schemaNamingConfig = (_a = config === null || config === void 0 ? void 0 : config.naming) === null || _a === void 0 ? void 0 : _a.schema;
+            if (schemaNamingConfig === null || schemaNamingConfig === void 0 ? void 0 : schemaNamingConfig.exportNamePattern) {
+                const customExportName = (0, naming_resolver_1.generateExportName)(schemaNamingConfig.exportNamePattern, modelName, operationType);
+                if (customExportName) {
+                    baseExportName = customExportName;
+                }
+            }
+        }
+        catch {
+            // Fallback to default naming if there's an error
+        }
+        // Generate typed schema (perfect inference, no methods) - KEEP PRISMA TYPING
+        if (Transformer.exportTypedSchemas) {
+            const typedName = baseExportName.endsWith('Schema')
+                ? baseExportName
+                : `${baseExportName}${Transformer.typedSchemaSuffix}`;
+            exports.push(`export const ${typedName}: z.ZodType<${prismaType}> = ${schemaDefinition} as unknown as z.ZodType<${prismaType}>;`);
+        }
+        // Generate Zod schema (methods available, loose inference)
+        if (Transformer.exportZodSchemas) {
+            const zodName = `${baseExportName}${Transformer.zodSchemaSuffix}`;
+            exports.push(`export const ${zodName} = ${schemaDefinition};`);
+        }
+        return exports.join('\n\n');
+    }
+    /**
+     * Generates dual select schema exports for inlined schemas
+     */
+    generateDualSelectSchemaExports(model, operation) {
+        const modelName = model.name;
+        const schemaDefinition = this.generateInlineSelectSchemaDefinition(model);
+        const exports = [];
+        // Generate typed select schema - KEEP PRISMA TYPING
+        if (Transformer.exportTypedSchemas) {
+            const typedName = `${modelName}${operation ? operation : ''}Select${Transformer.typedSchemaSuffix}`;
+            exports.push(`export const ${typedName}: z.ZodType<Prisma.${this.getPrismaTypeName(modelName)}Select> = ${schemaDefinition} as unknown as z.ZodType<Prisma.${this.getPrismaTypeName(modelName)}Select>;`);
+        }
+        // Generate Zod select schema
+        if (Transformer.exportZodSchemas) {
+            const zodName = `${modelName}${operation ? operation : ''}Select${Transformer.zodSchemaSuffix}`;
+            exports.push(`export const ${zodName} = ${schemaDefinition};`);
+        }
+        return exports.join('\n\n');
+    }
+    /**
+     * Generates just the schema definition without export statement
+     */
+    generateInlineSelectSchemaDefinition(model) {
+        var _a;
+        const { fields } = model;
+        // Generate field definitions for the select schema
+        const selectFields = [];
+        for (const field of fields) {
+            const { name: fieldName } = field;
+            const relationTarget = this.resolveInlineSelectRelationTarget(field);
+            if (relationTarget) {
+                // Relation selection mirrors objects/<Model>Select.schema.ts: Prisma's
+                // <Model>Select accepts boolean OR nested args (select/include/where/...).
+                const reference = relationTarget.kind === 'query'
+                    ? this.resolveModelQuerySchemaName(relationTarget.modelName, 'findMany')
+                    : Transformer.getObjectSchemaName(relationTarget.typeName);
+                selectFields.push(`    ${fieldName}: z.union([z.boolean(), z.lazy(() => ${reference})]).optional()`);
+            }
+            else {
+                // Scalar field (or relation without a generated nested-args schema): boolean only
+                selectFields.push(`    ${fieldName}: z.boolean().optional()`);
+            }
+        }
+        // Add _count field if model has array relations (for aggregation support)
+        const hasArrayRelations = fields.some((field) => field.relationName && field.isList);
+        if (hasArrayRelations) {
+            const countArgsReference = this.resolveInlineSelectCountArgsReference(model);
+            selectFields.push(countArgsReference
+                ? `    _count: z.union([z.boolean(), z.lazy(() => ${countArgsReference})]).optional()`
+                : `    _count: z.boolean().optional()`);
+        }
+        // Apply strict mode based on configuration for object schemas
+        const strictModeSuffix = ((_a = Transformer.getStrictModeResolver()) === null || _a === void 0 ? void 0 : _a.getObjectStrictModeSuffix(model.name)) || '';
+        return `z.object({
+${selectFields.join(',\n')}
+  })${strictModeSuffix}`;
+    }
+}
+Transformer.enumNames = [];
+Transformer.rawOpsMap = {};
+Transformer.outputPath = './generated';
+Transformer.prismaClientOutputPath = '@prisma/client';
+Transformer.isCustomPrismaClientOutputPath = false;
+Transformer.prismaClientProvider = 'prisma-client-js';
+Transformer.prismaClientEntryBasenameCache = new Map();
+Transformer.prismaClientConfig = {};
+Transformer.isGenerateSelect = false;
+Transformer.isGenerateInclude = false;
+Transformer.generatorConfig = null;
+Transformer.strictModeResolver = null;
+Transformer.usedSchemaFilePaths = new Map();
+// Dual schema export configuration
+Transformer.exportTypedSchemas = true; // Export z.ZodType<Prisma.Type> versions (type-safe)
+Transformer.exportZodSchemas = true; // Export pure Zod versions (method-friendly)
+Transformer.typedSchemaSuffix = 'Schema'; // Suffix for typed schemas (PostFindManySchema)
+Transformer.zodSchemaSuffix = 'ZodSchema'; // Suffix for Zod schemas (PostFindManyZodSchema)
+Transformer.jsonHelpersWritten = false;
+Transformer.decimalHelpersWritten = false;
+// Track generated files for safe cleanup
+Transformer.currentManifest = null;
+/**
+ * The per-field copies of Prisma's shared update-operations inputs, planned once per
+ * generate. Empty unless `typedJson` is configured and some column is annotated.
+ */
+Transformer.typedFieldUpdateOperationsPlan = typed_field_update_operations_1.EMPTY_TYPED_FIELD_UPDATE_OPERATIONS_PLAN;
+/**
+ * Shared regex patterns for model-specific enum detection
+ */
+Transformer.modelEnumPatterns = [
+    /^(\w+)ScalarFieldEnum$/,
+    /^(\w+)OrderByRelevanceFieldEnum$/,
+];
+exports.default = Transformer;
+//# sourceMappingURL=transformer.js.map