@n8n/workflow-sdk 0.2.0

package/dist/generate-types/generate-zod-schemas.js

@@ -0,0 +1,1129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDefaultsForDisplayOptions = extractDefaultsForDisplayOptions;
+exports.mapPropertyToZodSchema = mapPropertyToZodSchema;
+exports.generateSchemaPropertyLine = generateSchemaPropertyLine;
+exports.stripDiscriminatorKeysFromDisplayOptions = stripDiscriminatorKeysFromDisplayOptions;
+exports.mergeDisplayOptions = mergeDisplayOptions;
+exports.mergePropertiesByName = mergePropertiesByName;
+exports.generateConditionalSchemaLine = generateConditionalSchemaLine;
+exports.generateSubnodeConfigSchemaCode = generateSubnodeConfigSchemaCode;
+exports.getSubnodeSchemaImports = getSubnodeSchemaImports;
+exports.generateSingleVersionSchemaFile = generateSingleVersionSchemaFile;
+exports.generateSchemaIndexFile = generateSchemaIndexFile;
+exports.generateDiscriminatorSchemaFile = generateDiscriminatorSchemaFile;
+exports.generateResourceIndexSchemaFile = generateResourceIndexSchemaFile;
+exports.generateSplitVersionIndexSchemaFile = generateSplitVersionIndexSchemaFile;
+exports.planSplitVersionSchemaFiles = planSplitVersionSchemaFiles;
+const generate_types_1 = require("./generate-types");
+const INDENT = '  ';
+const CUSTOM_API_CALL_KEY = '__CUSTOM_API_CALL__';
+function isCustomApiCall(operation) {
+    return operation === CUSTOM_API_CALL_KEY;
+}
+const GENERIC_AUTH_TYPE_VALUES = [
+    'httpBasicAuth',
+    'httpBearerAuth',
+    'httpDigestAuth',
+    'httpHeaderAuth',
+    'httpQueryAuth',
+    'httpCustomAuth',
+    'oAuth1Api',
+    'oAuth2Api',
+];
+const RESERVED_WORDS = new Set([
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'import',
+    'in',
+    'instanceof',
+    'new',
+    'null',
+    'return',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+const AI_TYPE_TO_SCHEMA_FIELD = {
+    ai_languageModel: {
+        fieldName: 'model',
+        schemaName: 'languageModelInstanceSchema',
+        isArray: false,
+        canBeMultiple: true,
+    },
+    ai_memory: {
+        fieldName: 'memory',
+        schemaName: 'memoryInstanceSchema',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_tool: {
+        fieldName: 'tools',
+        schemaName: 'toolInstanceSchema',
+        isArray: true,
+        canBeMultiple: false,
+    },
+    ai_outputParser: {
+        fieldName: 'outputParser',
+        schemaName: 'outputParserInstanceSchema',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_embedding: {
+        fieldName: 'embedding',
+        schemaName: 'embeddingInstanceSchema',
+        isArray: false,
+        canBeMultiple: true,
+    },
+    ai_vectorStore: {
+        fieldName: 'vectorStore',
+        schemaName: 'vectorStoreInstanceSchema',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_retriever: {
+        fieldName: 'retriever',
+        schemaName: 'retrieverInstanceSchema',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_document: {
+        fieldName: 'documentLoader',
+        schemaName: 'documentLoaderInstanceSchema',
+        isArray: false,
+        canBeMultiple: true,
+    },
+    ai_textSplitter: {
+        fieldName: 'textSplitter',
+        schemaName: 'textSplitterInstanceSchema',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_reranker: {
+        fieldName: 'reranker',
+        schemaName: 'rerankerInstanceSchema',
+        isArray: false,
+        canBeMultiple: false,
+    },
+};
+function isPropertyOptional(prop) {
+    const hasDefault = 'default' in prop && prop.default !== undefined;
+    return !prop.required || hasDefault;
+}
+function hasRequiredSubnodeFields(aiInputTypes) {
+    return aiInputTypes.some((input) => input.required && !input.displayOptions);
+}
+function hasConditionalSubnodeFields(aiInputTypes) {
+    return aiInputTypes.some((input) => input.displayOptions);
+}
+function hasDisplayOptions(properties) {
+    return properties.some((prop) => {
+        if (!prop.displayOptions)
+            return false;
+        const stripped = stripDiscriminatorKeysFromDisplayOptions(prop.displayOptions, ['@version']);
+        return stripped !== undefined;
+    });
+}
+function toPascalCase(str) {
+    return str
+        .replace(/[-_]+/g, ' ')
+        .replace(/\./g, ' ')
+        .split(' ')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+function toSnakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '')
+        .replace(/[-\s]+/g, '_');
+}
+function formatZodLiteral(value) {
+    if (typeof value === 'string') {
+        const escaped = value
+            .replace(/\\/g, '\\\\')
+            .replace(/'/g, "\\'")
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t');
+        return `'${escaped}'`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}
+function quotePropertyName(name) {
+    const needsQuoting = RESERVED_WORDS.has(name) || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+    if (needsQuoting) {
+        return `'${name.replace(/'/g, "\\'")}'`;
+    }
+    return name;
+}
+function extractDefaultsForDisplayOptions(displayOptions, allProperties) {
+    const defaults = {};
+    const referencedProps = new Set();
+    if (displayOptions.show) {
+        for (const key of Object.keys(displayOptions.show)) {
+            if (!key.startsWith('@') && !key.startsWith('/')) {
+                const baseProp = key.split('.')[0];
+                referencedProps.add(baseProp);
+            }
+        }
+    }
+    if (displayOptions.hide) {
+        for (const key of Object.keys(displayOptions.hide)) {
+            if (!key.startsWith('@') && !key.startsWith('/')) {
+                const baseProp = key.split('.')[0];
+                referencedProps.add(baseProp);
+            }
+        }
+    }
+    for (const propName of referencedProps) {
+        const prop = allProperties.find((p) => p.name === propName);
+        if (prop && prop.default !== undefined) {
+            defaults[propName] = prop.default;
+        }
+    }
+    return defaults;
+}
+function generateResourceLocatorZodSchema(prop) {
+    if (prop.modes && prop.modes.length > 0) {
+        const modeSchema = prop.modes.length === 1
+            ? `z.literal('${prop.modes[0].name}')`
+            : `z.union([${prop.modes.map((m) => `z.literal('${m.name}')`).join(', ')}])`;
+        const objectSchema = `z.object({ __rl: z.literal(true), mode: ${modeSchema}, value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() })`;
+        return `z.union([${objectSchema}, expressionSchema])`;
+    }
+    return 'resourceLocatorValueSchema';
+}
+function mapNestedPropertyToZodSchema(prop) {
+    const result = mapNestedPropertyToZodSchemaInner(prop);
+    if (prop.noDataExpression) {
+        return stripExpressionFromZodSchema(result);
+    }
+    return result;
+}
+function mapNestedPropertyToZodSchemaInner(prop) {
+    if (['notice', 'curlImport', 'credentials'].includes(prop.type)) {
+        return '';
+    }
+    if (prop.type === 'resourceLocator') {
+        return generateResourceLocatorZodSchema(prop);
+    }
+    if (prop.type === 'resourceMapper') {
+        return 'resourceMapperValueSchema';
+    }
+    if (prop.typeOptions?.loadOptionsMethod || prop.typeOptions?.loadOptionsDependsOn) {
+        if (prop.type === 'multiOptions') {
+            return 'z.array(z.string())';
+        }
+        return 'stringOrExpression';
+    }
+    switch (prop.type) {
+        case 'string':
+        case 'dateTime':
+        case 'color':
+        case 'credentialsSelect':
+            return 'stringOrExpression';
+        case 'number':
+            return 'numberOrExpression';
+        case 'boolean':
+            return 'booleanOrExpression';
+        case 'options':
+            if (prop.options && prop.options.length > 0) {
+                const literals = prop.options
+                    .filter((opt) => opt.value !== undefined)
+                    .map((opt) => `z.literal(${formatZodLiteral(opt.value)})`);
+                if (literals.length > 0) {
+                    return `z.union([${literals.join(', ')}, expressionSchema])`;
+                }
+            }
+            return 'stringOrExpression';
+        case 'multiOptions':
+            if (prop.options && prop.options.length > 0) {
+                const literals = prop.options
+                    .filter((opt) => opt.value !== undefined)
+                    .map((opt) => `z.literal(${formatZodLiteral(opt.value)})`);
+                if (literals.length > 0) {
+                    return `z.array(z.union([${literals.join(', ')}]))`;
+                }
+            }
+            return 'z.array(z.string())';
+        case 'json':
+            return 'z.union([iDataObjectSchema, z.string()])';
+        case 'filter':
+            return 'filterValueSchema';
+        case 'assignmentCollection':
+            return 'assignmentCollectionValueSchema';
+        case 'hidden':
+            return 'z.unknown()';
+        default:
+            return 'z.unknown()';
+    }
+}
+function generateFixedCollectionZodSchema(prop) {
+    if (!prop.options || prop.options.length === 0) {
+        return 'z.record(z.string(), z.unknown())';
+    }
+    const isMultipleValues = prop.typeOptions?.multipleValues === true;
+    const groups = [];
+    for (const group of prop.options) {
+        if (group.value !== undefined || !group.values) {
+            continue;
+        }
+        const groupName = quotePropertyName(group.name);
+        const nestedProps = [];
+        for (const nestedProp of group.values) {
+            if (['notice', 'curlImport', 'credentials'].includes(nestedProp.type)) {
+                continue;
+            }
+            const nestedSchema = mapNestedPropertyToZodSchema(nestedProp);
+            if (nestedSchema) {
+                const quotedName = quotePropertyName(nestedProp.name);
+                nestedProps.push(`${quotedName}: ${nestedSchema}.optional()`);
+            }
+        }
+        if (nestedProps.length > 0) {
+            const innerSchema = `z.object({ ${nestedProps.join(', ')} })`;
+            const groupSchema = isMultipleValues ? `z.array(${innerSchema})` : innerSchema;
+            groups.push(`${groupName}: ${groupSchema}.optional()`);
+        }
+    }
+    if (groups.length === 0) {
+        return 'z.record(z.string(), z.unknown())';
+    }
+    return `z.object({ ${groups.join(', ')} })`;
+}
+function generateCollectionZodSchema(prop) {
+    if (!prop.options || prop.options.length === 0) {
+        return 'z.record(z.string(), z.unknown())';
+    }
+    const nestedProps = [];
+    for (const nestedProp of prop.options) {
+        if (nestedProp.values !== undefined) {
+            continue;
+        }
+        const asNodeProp = nestedProp;
+        if (['notice', 'curlImport', 'credentials'].includes(asNodeProp.type)) {
+            continue;
+        }
+        const nestedSchema = mapNestedPropertyToZodSchema(asNodeProp);
+        if (nestedSchema) {
+            const quotedName = quotePropertyName(nestedProp.name);
+            nestedProps.push(`${quotedName}: ${nestedSchema}.optional()`);
+        }
+    }
+    if (nestedProps.length === 0) {
+        return 'z.record(z.string(), z.unknown())';
+    }
+    return `z.object({ ${nestedProps.join(', ')} })`;
+}
+function mapPropertyToZodSchema(prop) {
+    const result = mapPropertyToZodSchemaInner(prop);
+    if (prop.noDataExpression) {
+        return stripExpressionFromZodSchema(result);
+    }
+    return result;
+}
+function stripExpressionFromZodSchema(schema) {
+    if (schema === 'stringOrExpression')
+        return 'z.string()';
+    if (schema === 'numberOrExpression')
+        return 'z.number()';
+    if (schema === 'booleanOrExpression')
+        return 'z.boolean()';
+    return schema.replace(/,\s*expressionSchema/g, '');
+}
+function mapPropertyToZodSchemaInner(prop) {
+    if (prop.type === 'credentialsSelect' && prop.name === 'genericAuthType') {
+        const literals = GENERIC_AUTH_TYPE_VALUES.map((v) => `z.literal('${v}')`);
+        return `z.union([${literals.join(', ')}, expressionSchema])`;
+    }
+    if (prop.type === 'resourceLocator') {
+        return generateResourceLocatorZodSchema(prop);
+    }
+    if (prop.type === 'resourceMapper') {
+        return 'resourceMapperValueSchema';
+    }
+    if (prop.typeOptions?.loadOptionsMethod || prop.typeOptions?.loadOptionsDependsOn) {
+        switch (prop.type) {
+            case 'options':
+                return 'stringOrExpression';
+            case 'multiOptions':
+                return 'z.array(z.string())';
+            default:
+                return 'stringOrExpression';
+        }
+    }
+    switch (prop.type) {
+        case 'string':
+            return 'stringOrExpression';
+        case 'number':
+            return 'numberOrExpression';
+        case 'boolean':
+            return 'booleanOrExpression';
+        case 'options':
+            if (prop.options && prop.options.length > 0) {
+                const literals = prop.options
+                    .filter((opt) => opt.value !== undefined)
+                    .map((opt) => `z.literal(${formatZodLiteral(opt.value)})`);
+                if (literals.length > 0) {
+                    return `z.union([${literals.join(', ')}, expressionSchema])`;
+                }
+            }
+            return 'stringOrExpression';
+        case 'multiOptions':
+            if (prop.options && prop.options.length > 0) {
+                const literals = prop.options
+                    .filter((opt) => opt.value !== undefined)
+                    .map((opt) => `z.literal(${formatZodLiteral(opt.value)})`);
+                if (literals.length > 0) {
+                    return `z.array(z.union([${literals.join(', ')}]))`;
+                }
+            }
+            return 'z.array(z.string())';
+        case 'json':
+            return 'z.union([iDataObjectSchema, z.string()])';
+        case 'filter':
+            return 'filterValueSchema';
+        case 'assignmentCollection':
+            return 'assignmentCollectionValueSchema';
+        case 'fixedCollection':
+            return generateFixedCollectionZodSchema(prop);
+        case 'collection':
+            return generateCollectionZodSchema(prop);
+        case 'dateTime':
+        case 'color':
+            return 'stringOrExpression';
+        case 'hidden':
+            return 'z.unknown()';
+        case 'notice':
+        case 'curlImport':
+        case 'credentials':
+            return '';
+        case 'credentialsSelect':
+            return 'stringOrExpression';
+        default:
+            return 'z.unknown()';
+    }
+}
+function generateSchemaPropertyLine(prop, optional) {
+    const zodSchema = mapPropertyToZodSchema(prop);
+    if (!zodSchema) {
+        return '';
+    }
+    const propName = quotePropertyName(prop.name);
+    const schema = optional ? `${zodSchema}.optional()` : zodSchema;
+    return `${INDENT}${propName}: ${schema},`;
+}
+function stripDiscriminatorKeysFromDisplayOptions(displayOptions, discriminatorKeys) {
+    const result = {};
+    if (displayOptions.show) {
+        const cleanedShow = {};
+        for (const [key, values] of Object.entries(displayOptions.show)) {
+            if (!discriminatorKeys.includes(key)) {
+                cleanedShow[key] = values;
+            }
+        }
+        if (Object.keys(cleanedShow).length > 0) {
+            result.show = cleanedShow;
+        }
+    }
+    if (displayOptions.hide) {
+        const cleanedHide = {};
+        for (const [key, values] of Object.entries(displayOptions.hide)) {
+            if (!discriminatorKeys.includes(key)) {
+                cleanedHide[key] = values;
+            }
+        }
+        if (Object.keys(cleanedHide).length > 0) {
+            result.hide = cleanedHide;
+        }
+    }
+    if (!result.show && !result.hide) {
+        return undefined;
+    }
+    return result;
+}
+function mergeDisplayOptions(existing, incoming) {
+    const merged = { ...existing };
+    if (incoming.show) {
+        merged.show = merged.show ?? {};
+        for (const [key, values] of Object.entries(incoming.show)) {
+            const existingValues = merged.show[key] ?? [];
+            const combined = [...existingValues];
+            for (const val of values) {
+                const isDuplicate = combined.some((existingVal) => JSON.stringify(existingVal) === JSON.stringify(val));
+                if (!isDuplicate) {
+                    combined.push(val);
+                }
+            }
+            merged.show[key] = combined;
+        }
+    }
+    if (incoming.hide) {
+        merged.hide = merged.hide ?? {};
+        for (const [key, values] of Object.entries(incoming.hide)) {
+            const existingValues = merged.hide[key] ?? [];
+            const combined = [...existingValues];
+            for (const val of values) {
+                const isDuplicate = combined.some((existingVal) => JSON.stringify(existingVal) === JSON.stringify(val));
+                if (!isDuplicate) {
+                    combined.push(val);
+                }
+            }
+            merged.hide[key] = combined;
+        }
+    }
+    return merged;
+}
+function mergePropertiesByName(properties) {
+    const propsByName = new Map();
+    for (const prop of properties) {
+        if (['notice', 'curlImport', 'credentials'].includes(prop.type)) {
+            continue;
+        }
+        const existing = propsByName.get(prop.name);
+        if (existing) {
+            if (prop.displayOptions && existing.displayOptions) {
+                existing.displayOptions = mergeDisplayOptions(existing.displayOptions, prop.displayOptions);
+            }
+            else if (prop.displayOptions && !existing.displayOptions) {
+            }
+            if ((prop.type === 'collection' || prop.type === 'fixedCollection') &&
+                prop.options &&
+                existing.options) {
+                const existingOptionNames = new Set(existing.options.map((o) => o.name));
+                for (const opt of prop.options) {
+                    if (!existingOptionNames.has(opt.name)) {
+                        existing.options.push(opt);
+                    }
+                }
+            }
+        }
+        else {
+            propsByName.set(prop.name, {
+                ...prop,
+                options: prop.options ? [...prop.options] : undefined,
+            });
+        }
+    }
+    return propsByName;
+}
+function generateConditionalSchemaLine(prop, allProperties = []) {
+    const zodSchema = mapPropertyToZodSchema(prop);
+    if (!zodSchema) {
+        return '';
+    }
+    const propName = quotePropertyName(prop.name);
+    const required = !isPropertyOptional(prop);
+    const displayOptionsStr = JSON.stringify(prop.displayOptions);
+    const defaults = prop.displayOptions
+        ? extractDefaultsForDisplayOptions(prop.displayOptions, allProperties)
+        : {};
+    const defaultsStr = Object.keys(defaults).length > 0 ? `, defaults: ${JSON.stringify(defaults)}` : '';
+    return `${INDENT}${propName}: resolveSchema({ parameters, schema: ${zodSchema}, required: ${required}, displayOptions: ${displayOptionsStr}${defaultsStr} }),`;
+}
+function generateSubnodeConfigSchemaCode(aiInputTypes, schemaName, allProperties) {
+    if (aiInputTypes.length === 0) {
+        return null;
+    }
+    const hasConditional = hasConditionalSubnodeFields(aiInputTypes);
+    const lines = [];
+    if (hasConditional) {
+        lines.push(`function get${schemaName}SubnodeConfigSchema({ parameters, resolveSchema }) {`);
+        lines.push(`${INDENT}return z.object({`);
+    }
+    else {
+        lines.push(`const ${schemaName}SubnodeConfigSchema = z.object({`);
+    }
+    for (const aiInput of aiInputTypes) {
+        const fieldInfo = AI_TYPE_TO_SCHEMA_FIELD[aiInput.type];
+        if (!fieldInfo) {
+            continue;
+        }
+        let schemaStr;
+        if (fieldInfo.isArray) {
+            schemaStr = `z.array(${fieldInfo.schemaName})`;
+        }
+        else if (fieldInfo.canBeMultiple) {
+            schemaStr = `z.union([${fieldInfo.schemaName}, z.array(${fieldInfo.schemaName})])`;
+        }
+        else {
+            schemaStr = fieldInfo.schemaName;
+        }
+        if (aiInput.displayOptions) {
+            const displayOptionsStr = JSON.stringify(aiInput.displayOptions);
+            const indent = hasConditional ? INDENT.repeat(2) : INDENT;
+            let defaultsStr = '';
+            if (allProperties) {
+                const defaults = extractDefaultsForDisplayOptions(aiInput.displayOptions, allProperties);
+                if (Object.keys(defaults).length > 0) {
+                    defaultsStr = `, defaults: ${JSON.stringify(defaults)}`;
+                }
+            }
+            lines.push(`${indent}${fieldInfo.fieldName}: resolveSchema({ parameters, schema: ${schemaStr}, required: ${aiInput.required}, displayOptions: ${displayOptionsStr}${defaultsStr} }),`);
+        }
+        else if (!aiInput.required) {
+            const indent = hasConditional ? INDENT.repeat(2) : INDENT;
+            lines.push(`${indent}${fieldInfo.fieldName}: ${schemaStr}.optional(),`);
+        }
+        else {
+            const indent = hasConditional ? INDENT.repeat(2) : INDENT;
+            lines.push(`${indent}${fieldInfo.fieldName}: ${schemaStr},`);
+        }
+    }
+    if (hasConditional) {
+        lines.push(`${INDENT}});`);
+        lines.push('}');
+        lines.push(`exports.get${schemaName}SubnodeConfigSchema = get${schemaName}SubnodeConfigSchema;`);
+    }
+    else {
+        lines.push('});');
+        lines.push(`exports.${schemaName}SubnodeConfigSchema = ${schemaName}SubnodeConfigSchema;`);
+    }
+    return lines.join('\n');
+}
+function getSubnodeSchemaImports(aiInputTypes) {
+    const imports = [];
+    for (const aiInput of aiInputTypes) {
+        const fieldInfo = AI_TYPE_TO_SCHEMA_FIELD[aiInput.type];
+        if (fieldInfo && !imports.includes(fieldInfo.schemaName)) {
+            imports.push(fieldInfo.schemaName);
+        }
+    }
+    return imports;
+}
+function generateSingleVersionSchemaFile(node, specificVersion) {
+    const filteredProperties = (0, generate_types_1.filterPropertiesForVersion)(node.properties, specificVersion);
+    const filteredNode = {
+        ...node,
+        properties: filteredProperties,
+        version: specificVersion,
+    };
+    const aiInputTypes = (0, generate_types_1.extractAIInputTypesFromBuilderHint)(filteredNode);
+    const subnodeSchemaImports = getSubnodeSchemaImports(aiInputTypes);
+    const hasAiInputs = aiInputTypes.length > 0;
+    const needsResolveSchema = hasDisplayOptions(filteredProperties) ||
+        (hasAiInputs && hasConditionalSubnodeFields(aiInputTypes));
+    const lines = [];
+    const helpers = [
+        'z',
+        'expressionSchema',
+        'stringOrExpression',
+        'numberOrExpression',
+        'booleanOrExpression',
+        'resourceLocatorValueSchema',
+        'resourceMapperValueSchema',
+        'filterValueSchema',
+        'assignmentCollectionValueSchema',
+        'iDataObjectSchema',
+    ];
+    if (needsResolveSchema) {
+        helpers.push('resolveSchema');
+    }
+    for (const schemaImport of subnodeSchemaImports) {
+        helpers.push(schemaImport);
+    }
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${specificVersion} - Zod Validation Schemas`);
+    lines.push(' *');
+    lines.push(' * These schemas validate node configuration at runtime.');
+    lines.push(' * Use .parse() for strict validation or .safeParse() for error handling.');
+    lines.push(' *');
+    lines.push(' * Schema helpers (z, expressionSchema, etc.) are passed as parameters');
+    lines.push(' * by the schema-validator, not imported from external files.');
+    lines.push(' *');
+    lines.push(' * @generated - CommonJS JavaScript for runtime loading');
+    lines.push(' */');
+    lines.push('');
+    lines.push(`module.exports = function getSchema({ parameters, ${helpers.join(', ')} }) {`);
+    if (hasAiInputs && hasConditionalSubnodeFields(aiInputTypes)) {
+        lines.push('');
+        lines.push(`${INDENT}// Helper function for conditional subnode schema`);
+        lines.push(`${INDENT}function getSubnodesSchema() {`);
+        lines.push(`${INDENT.repeat(2)}return z.object({`);
+        for (const aiInput of aiInputTypes) {
+            const fieldInfo = AI_TYPE_TO_SCHEMA_FIELD[aiInput.type];
+            if (!fieldInfo)
+                continue;
+            let schemaStr;
+            if (fieldInfo.isArray) {
+                schemaStr = `z.array(${fieldInfo.schemaName})`;
+            }
+            else if (fieldInfo.canBeMultiple) {
+                schemaStr = `z.union([${fieldInfo.schemaName}, z.array(${fieldInfo.schemaName})])`;
+            }
+            else {
+                schemaStr = fieldInfo.schemaName;
+            }
+            if (aiInput.displayOptions) {
+                const displayOptionsStr = JSON.stringify(aiInput.displayOptions);
+                const defaults = extractDefaultsForDisplayOptions(aiInput.displayOptions, filteredProperties);
+                const defaultsStr = Object.keys(defaults).length > 0 ? `, defaults: ${JSON.stringify(defaults)}` : '';
+                lines.push(`${INDENT.repeat(3)}${fieldInfo.fieldName}: resolveSchema({ parameters, schema: ${schemaStr}, required: ${aiInput.required}, displayOptions: ${displayOptionsStr}${defaultsStr} }),`);
+            }
+            else if (!aiInput.required) {
+                lines.push(`${INDENT.repeat(3)}${fieldInfo.fieldName}: ${schemaStr}.optional(),`);
+            }
+            else {
+                lines.push(`${INDENT.repeat(3)}${fieldInfo.fieldName}: ${schemaStr},`);
+            }
+        }
+        lines.push(`${INDENT.repeat(2)}}).strict();`);
+        lines.push(`${INDENT}}`);
+    }
+    if (hasAiInputs && !hasConditionalSubnodeFields(aiInputTypes)) {
+        lines.push('');
+        lines.push(`${INDENT}// Static subnode schema`);
+        lines.push(`${INDENT}const subnodesSchema = z.object({`);
+        for (const aiInput of aiInputTypes) {
+            const fieldInfo = AI_TYPE_TO_SCHEMA_FIELD[aiInput.type];
+            if (!fieldInfo)
+                continue;
+            let schemaStr;
+            if (fieldInfo.isArray) {
+                schemaStr = `z.array(${fieldInfo.schemaName})`;
+            }
+            else if (fieldInfo.canBeMultiple) {
+                schemaStr = `z.union([${fieldInfo.schemaName}, z.array(${fieldInfo.schemaName})])`;
+            }
+            else {
+                schemaStr = fieldInfo.schemaName;
+            }
+            if (!aiInput.required) {
+                lines.push(`${INDENT.repeat(2)}${fieldInfo.fieldName}: ${schemaStr}.optional(),`);
+            }
+            else {
+                lines.push(`${INDENT.repeat(2)}${fieldInfo.fieldName}: ${schemaStr},`);
+            }
+        }
+        lines.push(`${INDENT}}).strict();`);
+    }
+    lines.push('');
+    lines.push(`${INDENT}// Parameters schema`);
+    lines.push(`${INDENT}const parametersSchema = z.object({`);
+    const propsByName = mergePropertiesByName(filteredProperties);
+    const allPropsArray = Array.from(propsByName.values());
+    for (const prop of allPropsArray) {
+        if (prop.displayOptions) {
+            const strippedDisplayOptions = stripDiscriminatorKeysFromDisplayOptions(prop.displayOptions, [
+                '@version',
+            ]);
+            if (strippedDisplayOptions) {
+                const propWithStripped = {
+                    ...prop,
+                    displayOptions: strippedDisplayOptions,
+                };
+                const propLine = generateConditionalSchemaLine(propWithStripped, allPropsArray);
+                if (propLine) {
+                    lines.push(INDENT + propLine);
+                }
+            }
+            else {
+                const propLine = generateSchemaPropertyLine(prop, isPropertyOptional(prop));
+                if (propLine) {
+                    lines.push(INDENT + propLine);
+                }
+            }
+        }
+        else {
+            const propLine = generateSchemaPropertyLine(prop, isPropertyOptional(prop));
+            if (propLine) {
+                lines.push(INDENT + propLine);
+            }
+        }
+    }
+    lines.push(`${INDENT}});`);
+    lines.push('');
+    lines.push(`${INDENT}// Return combined config schema`);
+    lines.push(`${INDENT}return z.object({`);
+    lines.push(`${INDENT.repeat(2)}parameters: parametersSchema.optional(),`);
+    if (hasAiInputs) {
+        const subnodesOptional = !hasRequiredSubnodeFields(aiInputTypes);
+        if (hasConditionalSubnodeFields(aiInputTypes)) {
+            lines.push(`${INDENT.repeat(2)}subnodes: getSubnodesSchema()${subnodesOptional ? '.optional()' : ''},`);
+        }
+        else {
+            lines.push(`${INDENT.repeat(2)}subnodes: subnodesSchema${subnodesOptional ? '.optional()' : ''},`);
+        }
+    }
+    lines.push(`${INDENT}});`);
+    lines.push('};');
+    return lines.join('\n');
+}
+function generateSchemaIndexFile(node, versions) {
+    const sortedVersions = [...versions].sort((a, b) => b - a);
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node Schemas`);
+    lines.push(' *');
+    lines.push(' * Re-exports all version-specific Zod validation schemas.');
+    lines.push(' */');
+    lines.push('');
+    for (const version of sortedVersions) {
+        const fileName = `v${String(version).replace('.', '')}`;
+        lines.push(`export * from './${fileName}.schema';`);
+    }
+    return lines.join('\n');
+}
+function generateDiscriminatorSchemaFile(node, version, combo, props, _importDepth, aiInputTypes = []) {
+    const hasAiInputs = aiInputTypes.length > 0;
+    const discriminatorKeys = [
+        ...Object.keys(combo).filter((k) => combo[k] !== undefined),
+        '@version',
+    ];
+    const hasRemainingDisplayOptions = props.some((prop) => {
+        if (!prop.displayOptions)
+            return false;
+        const stripped = stripDiscriminatorKeysFromDisplayOptions(prop.displayOptions, discriminatorKeys);
+        return stripped !== undefined;
+    });
+    const hasConditionalAiInputs = hasAiInputs && hasConditionalSubnodeFields(aiInputTypes);
+    const lines = [];
+    const comboDesc = Object.entries(combo)
+        .filter(([_, v]) => v !== undefined)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ');
+    const helpers = [
+        'z',
+        'expressionSchema',
+        'stringOrExpression',
+        'numberOrExpression',
+        'booleanOrExpression',
+        'resourceLocatorValueSchema',
+        'resourceMapperValueSchema',
+        'filterValueSchema',
+        'assignmentCollectionValueSchema',
+        'iDataObjectSchema',
+    ];
+    if (hasRemainingDisplayOptions || hasConditionalAiInputs) {
+        helpers.push('resolveSchema');
+    }
+    if (hasAiInputs) {
+        const subnodeImports = getSubnodeSchemaImports(aiInputTypes);
+        for (const schemaImport of subnodeImports) {
+            helpers.push(schemaImport);
+        }
+    }
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${version} - Zod Schema`);
+    lines.push(` * Discriminator: ${comboDesc}`);
+    lines.push(' *');
+    lines.push(' * Use .parse() for strict validation or .safeParse() for error handling.');
+    lines.push(' *');
+    lines.push(' * Schema helpers (z, expressionSchema, etc.) are passed as parameters');
+    lines.push(' * by the schema-validator, not imported from external files.');
+    lines.push(' *');
+    lines.push(' * @generated - CommonJS JavaScript for runtime loading');
+    lines.push(' */');
+    lines.push('');
+    lines.push(`module.exports = function getSchema({ parameters, ${helpers.join(', ')} }) {`);
+    if (hasConditionalAiInputs) {
+        lines.push('');
+        lines.push(`${INDENT}// Helper function for conditional subnode schema`);
+        lines.push(`${INDENT}function getSubnodesSchema() {`);
+        lines.push(`${INDENT.repeat(2)}return z.object({`);
+        for (const aiInput of aiInputTypes) {
+            const fieldInfo = AI_TYPE_TO_SCHEMA_FIELD[aiInput.type];
+            if (!fieldInfo)
+                continue;
+            let schemaStr;
+            if (fieldInfo.isArray) {
+                schemaStr = `z.array(${fieldInfo.schemaName})`;
+            }
+            else if (fieldInfo.canBeMultiple) {
+                schemaStr = `z.union([${fieldInfo.schemaName}, z.array(${fieldInfo.schemaName})])`;
+            }
+            else {
+                schemaStr = fieldInfo.schemaName;
+            }
+            if (aiInput.displayOptions) {
+                const displayOptionsStr = JSON.stringify(aiInput.displayOptions);
+                const defaults = extractDefaultsForDisplayOptions(aiInput.displayOptions, props);
+                const defaultsStr = Object.keys(defaults).length > 0 ? `, defaults: ${JSON.stringify(defaults)}` : '';
+                lines.push(`${INDENT.repeat(3)}${fieldInfo.fieldName}: resolveSchema({ parameters, schema: ${schemaStr}, required: ${aiInput.required}, displayOptions: ${displayOptionsStr}${defaultsStr} }),`);
+            }
+            else if (!aiInput.required) {
+                lines.push(`${INDENT.repeat(3)}${fieldInfo.fieldName}: ${schemaStr}.optional(),`);
+            }
+            else {
+                lines.push(`${INDENT.repeat(3)}${fieldInfo.fieldName}: ${schemaStr},`);
+            }
+        }
+        lines.push(`${INDENT.repeat(2)}}).strict();`);
+        lines.push(`${INDENT}}`);
+    }
+    if (hasAiInputs && !hasConditionalAiInputs) {
+        lines.push('');
+        lines.push(`${INDENT}// Static subnode schema`);
+        lines.push(`${INDENT}const subnodesSchema = z.object({`);
+        for (const aiInput of aiInputTypes) {
+            const fieldInfo = AI_TYPE_TO_SCHEMA_FIELD[aiInput.type];
+            if (!fieldInfo)
+                continue;
+            let schemaStr;
+            if (fieldInfo.isArray) {
+                schemaStr = `z.array(${fieldInfo.schemaName})`;
+            }
+            else if (fieldInfo.canBeMultiple) {
+                schemaStr = `z.union([${fieldInfo.schemaName}, z.array(${fieldInfo.schemaName})])`;
+            }
+            else {
+                schemaStr = fieldInfo.schemaName;
+            }
+            if (!aiInput.required) {
+                lines.push(`${INDENT.repeat(2)}${fieldInfo.fieldName}: ${schemaStr}.optional(),`);
+            }
+            else {
+                lines.push(`${INDENT.repeat(2)}${fieldInfo.fieldName}: ${schemaStr},`);
+            }
+        }
+        lines.push(`${INDENT}}).strict();`);
+    }
+    lines.push('');
+    lines.push(`${INDENT}return z.object({`);
+    lines.push(`${INDENT.repeat(2)}parameters: z.object({`);
+    for (const [key, value] of Object.entries(combo)) {
+        if (value !== undefined) {
+            const discProp = node.properties?.find((p) => p.name === key);
+            const hasMatchingDefault = discProp?.default === value;
+            if (hasMatchingDefault) {
+                lines.push(`${INDENT.repeat(3)}${key}: z.literal('${value}').default('${value}'),`);
+            }
+            else {
+                lines.push(`${INDENT.repeat(3)}${key}: z.literal('${value}'),`);
+            }
+        }
+    }
+    const propsByName = mergePropertiesByName(props);
+    const allPropsArray = Array.from(propsByName.values());
+    for (const prop of allPropsArray) {
+        if (prop.displayOptions) {
+            const strippedDisplayOptions = stripDiscriminatorKeysFromDisplayOptions(prop.displayOptions, discriminatorKeys);
+            if (strippedDisplayOptions) {
+                const propWithStrippedOptions = {
+                    ...prop,
+                    displayOptions: strippedDisplayOptions,
+                };
+                const propLine = generateConditionalSchemaLine(propWithStrippedOptions, allPropsArray);
+                if (propLine) {
+                    lines.push(INDENT.repeat(2) + propLine);
+                }
+            }
+            else {
+                const propLine = generateSchemaPropertyLine(prop, isPropertyOptional(prop));
+                if (propLine) {
+                    lines.push(INDENT.repeat(2) + propLine);
+                }
+            }
+        }
+        else {
+            const propLine = generateSchemaPropertyLine(prop, isPropertyOptional(prop));
+            if (propLine) {
+                lines.push(INDENT.repeat(2) + propLine);
+            }
+        }
+    }
+    lines.push(`${INDENT.repeat(2)}}).optional(),`);
+    if (hasAiInputs) {
+        const subnodesOptional = !hasRequiredSubnodeFields(aiInputTypes);
+        if (hasConditionalAiInputs) {
+            lines.push(`${INDENT.repeat(2)}subnodes: getSubnodesSchema()${subnodesOptional ? '.optional()' : ''},`);
+        }
+        else {
+            lines.push(`${INDENT.repeat(2)}subnodes: subnodesSchema${subnodesOptional ? '.optional()' : ''},`);
+        }
+    }
+    lines.push(`${INDENT}});`);
+    lines.push('};');
+    return lines.join('\n');
+}
+function generateResourceIndexSchemaFile(node, _version, resource, operations) {
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} - ${toPascalCase(resource)} Resource - Zod Schema Factory`);
+    lines.push(' * Exports a factory that unions all operation schemas for this resource.');
+    lines.push(' *');
+    lines.push(' * Schema helpers (z, expressionSchema, etc.) are passed as parameters');
+    lines.push(' * by the schema-validator, not imported from external files.');
+    lines.push(' *');
+    lines.push(' * @generated - CommonJS JavaScript for runtime loading');
+    lines.push(' */');
+    lines.push('');
+    for (const op of operations.sort()) {
+        const fileName = `operation_${toSnakeCase(op)}.schema`;
+        const importName = `get${toPascalCase(op)}Schema`;
+        lines.push(`const ${importName} = require('./${fileName}');`);
+    }
+    lines.push('');
+    const operationProp = node.properties.find((p) => p.name === 'operation');
+    const operationDefault = operationProp?.default;
+    lines.push('module.exports = function getSchema(helpers) {');
+    lines.push(`${INDENT}const { parameters, z } = helpers;`);
+    if (operationDefault !== undefined) {
+        const defaultValueStr = typeof operationDefault === 'string'
+            ? `'${operationDefault}'`
+            : JSON.stringify(operationDefault);
+        lines.push(`${INDENT}// Apply operation default if not set`);
+        lines.push(`${INDENT}const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: ${defaultValueStr} } : parameters;`);
+    }
+    const paramsVar = operationDefault !== undefined ? 'effectiveParams' : 'parameters';
+    const helpersArg = operationDefault !== undefined ? `{ ...helpers, parameters: ${paramsVar} }` : 'helpers';
+    if (operations.length === 1) {
+        const importName = `get${toPascalCase(operations[0])}Schema`;
+        lines.push(`${INDENT}return ${importName}(${helpersArg});`);
+    }
+    else {
+        lines.push(`${INDENT}return z.union([`);
+        for (const op of operations.sort()) {
+            const importName = `get${toPascalCase(op)}Schema`;
+            lines.push(`${INDENT.repeat(2)}${importName}(${helpersArg}),`);
+        }
+        lines.push(`${INDENT}]);`);
+    }
+    lines.push('};');
+    return lines.join('\n');
+}
+function generateSplitVersionIndexSchemaFile(node, version, tree) {
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${version} - Zod Schema Factory`);
+    lines.push(' * Exports a factory that unions all discriminator schemas.');
+    lines.push(' *');
+    lines.push(' * Schema helpers (z, expressionSchema, etc.) are passed as parameters');
+    lines.push(' * by the schema-validator, not imported from external files.');
+    lines.push(' *');
+    lines.push(' * @generated - CommonJS JavaScript for runtime loading');
+    lines.push(' */');
+    lines.push('');
+    const importNames = [];
+    let discriminatorDefault;
+    if (tree.type === 'resource_operation' && tree.resources) {
+        for (const [resource] of tree.resources) {
+            const resourceDir = `resource_${toSnakeCase(resource)}`;
+            const importName = `get${toPascalCase(resource)}Schema`;
+            importNames.push(importName);
+            lines.push(`const ${importName} = require('./${resourceDir}/index.schema');`);
+        }
+        const resourceProp = node.properties.find((p) => p.name === 'resource');
+        if (resourceProp?.default !== undefined) {
+            discriminatorDefault = { name: 'resource', value: resourceProp.default };
+        }
+    }
+    else if (tree.type === 'single' && tree.discriminatorName && tree.discriminatorValues) {
+        const discName = tree.discriminatorName;
+        for (const value of tree.discriminatorValues.sort()) {
+            const fileName = `${discName}_${toSnakeCase(value)}.schema`;
+            const importName = `get${toPascalCase(value)}Schema`;
+            importNames.push(importName);
+            lines.push(`const ${importName} = require('./${fileName}');`);
+        }
+        const discProp = node.properties.find((p) => p.name === discName);
+        if (discProp?.default !== undefined) {
+            discriminatorDefault = { name: discName, value: discProp.default };
+        }
+    }
+    lines.push('');
+    lines.push('module.exports = function getSchema(helpers) {');
+    lines.push(`${INDENT}const { parameters, z } = helpers;`);
+    if (discriminatorDefault) {
+        const defaultValueStr = typeof discriminatorDefault.value === 'string'
+            ? `'${discriminatorDefault.value}'`
+            : JSON.stringify(discriminatorDefault.value);
+        lines.push(`${INDENT}// Apply discriminator default if not set`);
+        lines.push(`${INDENT}const effectiveParams = parameters.${discriminatorDefault.name} === undefined ? { ...parameters, ${discriminatorDefault.name}: ${defaultValueStr} } : parameters;`);
+    }
+    const paramsVar = discriminatorDefault ? 'effectiveParams' : 'parameters';
+    const helpersArg = discriminatorDefault ? `{ ...helpers, parameters: ${paramsVar} }` : 'helpers';
+    if (importNames.length === 1) {
+        lines.push(`${INDENT}return ${importNames[0]}(${helpersArg});`);
+    }
+    else if (importNames.length > 1) {
+        lines.push(`${INDENT}return z.union([`);
+        for (const importName of importNames) {
+            lines.push(`${INDENT.repeat(2)}${importName}(${helpersArg}),`);
+        }
+        lines.push(`${INDENT}]);`);
+    }
+    else {
+        lines.push(`${INDENT}return z.object({});`);
+    }
+    lines.push('};');
+    return lines.join('\n');
+}
+function planSplitVersionSchemaFiles(node, version) {
+    const files = new Map();
+    const combinations = (0, generate_types_1.extractDiscriminatorCombinations)(node);
+    const tree = (0, generate_types_1.buildDiscriminatorTree)(combinations);
+    const versionFilteredNode = {
+        ...node,
+        properties: (0, generate_types_1.filterPropertiesForVersion)(node.properties, version),
+        version,
+    };
+    if (tree.type === 'resource_operation' && tree.resources) {
+        for (const [resource, operations] of tree.resources) {
+            const resourceDir = `resource_${toSnakeCase(resource)}`;
+            for (const operation of operations) {
+                if (isCustomApiCall(operation))
+                    continue;
+                const combo = { resource, operation };
+                const versionFilteredProps = (0, generate_types_1.filterPropertiesForVersion)(node.properties, version);
+                const nodeForCombination = { ...node, properties: versionFilteredProps };
+                const props = (0, generate_types_1.getPropertiesForCombination)(nodeForCombination, combo);
+                const fileName = `operation_${toSnakeCase(operation)}.schema.js`;
+                const filePath = `${resourceDir}/${fileName}`;
+                const comboAiInputTypes = (0, generate_types_1.extractAIInputTypesFromBuilderHint)(versionFilteredNode, combo);
+                const content = generateDiscriminatorSchemaFile(node, version, combo, props, 5, comboAiInputTypes);
+                files.set(filePath, content);
+            }
+            const filteredOperations = operations.filter((op) => !isCustomApiCall(op));
+            const resourceIndexContent = generateResourceIndexSchemaFile(node, version, resource, filteredOperations);
+            files.set(`${resourceDir}/index.schema.js`, resourceIndexContent);
+        }
+    }
+    else if (tree.type === 'single' && tree.discriminatorName && tree.discriminatorValues) {
+        const discName = tree.discriminatorName;
+        for (const value of tree.discriminatorValues) {
+            const combo = { [discName]: value };
+            const versionFilteredProps = (0, generate_types_1.filterPropertiesForVersion)(node.properties, version);
+            const nodeForCombination = { ...node, properties: versionFilteredProps };
+            const props = (0, generate_types_1.getPropertiesForCombination)(nodeForCombination, combo);
+            const fileName = `${discName}_${toSnakeCase(value)}.schema.js`;
+            const comboAiInputTypes = (0, generate_types_1.extractAIInputTypesFromBuilderHint)(versionFilteredNode, combo);
+            const content = generateDiscriminatorSchemaFile(node, version, combo, props, 4, comboAiInputTypes);
+            files.set(fileName, content);
+        }
+    }
+    files.set('index.schema.js', generateSplitVersionIndexSchemaFile(node, version, tree));
+    return files;
+}
+//# sourceMappingURL=generate-zod-schemas.js.map