@n8n/workflow-sdk 0.2.0

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

@@ -0,0 +1,2569 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSchemasForNode = discoverSchemasForNode;
+exports.jsonSchemaToTypeScript = jsonSchemaToTypeScript;
+exports.findSchemaForOperation = findSchemaForOperation;
+exports.mapPropertyType = mapPropertyType;
+exports.extractDiscriminatorCombinations = extractDiscriminatorCombinations;
+exports.getPropertiesForCombination = getPropertiesForCombination;
+exports.propertyAppliesToVersion = propertyAppliesToVersion;
+exports.filterPropertiesForVersion = filterPropertiesForVersion;
+exports.generateDiscriminatedUnion = generateDiscriminatedUnion;
+exports.generatePropertyJSDoc = generatePropertyJSDoc;
+exports.generateNodeJSDoc = generateNodeJSDoc;
+exports.generatePropertyLine = generatePropertyLine;
+exports.groupVersionsByProperties = groupVersionsByProperties;
+exports.getHighestVersion = getHighestVersion;
+exports.versionToTypeName = versionToTypeName;
+exports.nodeNameToFileName = nodeNameToFileName;
+exports.getPackageName = getPackageName;
+exports.buildDiscriminatorPath = buildDiscriminatorPath;
+exports.hasDiscriminatorPattern = hasDiscriminatorPattern;
+exports.buildDiscriminatorTree = buildDiscriminatorTree;
+exports.generateSharedFile = generateSharedFile;
+exports.generateDiscriminatorFile = generateDiscriminatorFile;
+exports.generateResourceIndexFile = generateResourceIndexFile;
+exports.generateSplitVersionIndexFile = generateSplitVersionIndexFile;
+exports.planSplitVersionFiles = planSplitVersionFiles;
+exports.versionToFileName = versionToFileName;
+exports.generateSingleVersionTypeFile = generateSingleVersionTypeFile;
+exports.generateVersionIndexFile = generateVersionIndexFile;
+exports.generateNodeTypeFile = generateNodeTypeFile;
+exports.generateIndexFile = generateIndexFile;
+exports.extractAIInputTypes = extractAIInputTypes;
+exports.extractAIInputTypesFromBuilderHint = extractAIInputTypesFromBuilderHint;
+exports.generateNarrowedSubnodeConfig = generateNarrowedSubnodeConfig;
+exports.getSubnodeInstanceTypeImports = getSubnodeInstanceTypeImports;
+exports.extractOutputTypes = extractOutputTypes;
+exports.groupNodesByOutputType = groupNodesByOutputType;
+exports.generateSubnodeUnionTypes = generateSubnodeUnionTypes;
+exports.generateSubnodesFile = generateSubnodesFile;
+exports.getSubnodeOutputType = getSubnodeOutputType;
+exports.loadNodeTypes = loadNodeTypes;
+exports.orchestrateGeneration = orchestrateGeneration;
+exports.generateTypes = generateTypes;
+const fs = __importStar(require("fs"));
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const generate_zod_schemas_1 = require("./generate-zod-schemas");
+const display_options_1 = require("../validation/display-options");
+const INDENT = '  ';
+const NODES_BASE_TYPES = path.resolve(__dirname, '../../../../nodes-base/dist/types/nodes.json');
+const NODES_LANGCHAIN_TYPES = path.resolve(__dirname, '../../../nodes-langchain/dist/types/nodes.json');
+const DEV_OUTPUT_PATH = path.resolve(__dirname, '../../dist/node-definitions');
+const NODES_BASE_DIST = path.resolve(__dirname, '../../../../nodes-base/dist/nodes');
+const DISCRIMINATOR_FIELDS = ['resource', 'operation', 'mode'];
+const CUSTOM_API_CALL_KEY = '__CUSTOM_API_CALL__';
+const ASSIGNMENT_TYPE_JSDOC = `/**
+ * Assignment type determines how the value is interpreted.
+ * - string: Direct string value or expression evaluating to string
+ * - number: Direct number value or expression evaluating to number
+ * - boolean: Direct boolean value or expression evaluating to boolean
+ * - array: Expression that evaluates to an array, e.g. ={{ [1, 2, 3] }} or ={{ $json.items }}
+ * - object: Expression that evaluates to a plain object (not an array — use the array type for arrays), e.g. ={{ { key: 'value' } }} or ={{ $json.data }}
+ * - binary: Property name of binary data in the input item, or expression to access binary data from previous nodes, e.g. ={{ $('Node').item.binary.data }}
+ */`;
+function generateFilterTypeDeclaration(exported) {
+    const prefix = exported ? 'export type' : 'type';
+    return `${prefix} FilterValue = { conditions: Array<{ leftValue: unknown; operator: { type: string; operation: string }; rightValue: unknown }> };`;
+}
+function generateAssignmentTypeDeclarations(exported) {
+    const prefix = exported ? 'export type' : 'type';
+    return `${ASSIGNMENT_TYPE_JSDOC}
+${prefix} AssignmentType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'binary';
+${prefix} AssignmentCollectionValue = { assignments: Array<{ id: string; name: string; value: unknown; type: AssignmentType }> };`;
+}
+function isCustomApiCall(operation) {
+    return operation === CUSTOM_API_CALL_KEY;
+}
+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 GENERIC_AUTH_TYPE_VALUES = [
+    'httpBasicAuth',
+    'httpBearerAuth',
+    'httpDigestAuth',
+    'httpHeaderAuth',
+    'httpQueryAuth',
+    'httpCustomAuth',
+    'oAuth1Api',
+    'oAuth2Api',
+];
+const AI_TYPE_TO_SUBNODE_FIELD = {
+    ai_languageModel: {
+        fieldName: 'model',
+        instanceType: 'LanguageModelInstance',
+        isArray: false,
+        canBeMultiple: true,
+    },
+    ai_memory: {
+        fieldName: 'memory',
+        instanceType: 'MemoryInstance',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_tool: {
+        fieldName: 'tools',
+        instanceType: 'ToolInstance',
+        isArray: true,
+        canBeMultiple: false,
+    },
+    ai_outputParser: {
+        fieldName: 'outputParser',
+        instanceType: 'OutputParserInstance',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_embedding: {
+        fieldName: 'embedding',
+        instanceType: 'EmbeddingInstance',
+        isArray: false,
+        canBeMultiple: true,
+    },
+    ai_vectorStore: {
+        fieldName: 'vectorStore',
+        instanceType: 'VectorStoreInstance',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_retriever: {
+        fieldName: 'retriever',
+        instanceType: 'RetrieverInstance',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_document: {
+        fieldName: 'documentLoader',
+        instanceType: 'DocumentLoaderInstance',
+        isArray: false,
+        canBeMultiple: true,
+    },
+    ai_textSplitter: {
+        fieldName: 'textSplitter',
+        instanceType: 'TextSplitterInstance',
+        isArray: false,
+        canBeMultiple: false,
+    },
+    ai_reranker: {
+        fieldName: 'reranker',
+        instanceType: 'RerankerInstance',
+        isArray: false,
+        canBeMultiple: false,
+    },
+};
+const schemaCache = new Map();
+function findNestedSchemaDir(dir, targetNames) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const entryPath = path.join(dir, entry.name);
+        if (targetNames.includes(entry.name)) {
+            const schemaPath = path.join(entryPath, '__schema__');
+            if (fs.existsSync(schemaPath)) {
+                return schemaPath;
+            }
+        }
+        if (entry.name !== '__schema__' && entry.name !== 'node_modules') {
+            const found = findNestedSchemaDir(entryPath, targetNames);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function findSchemaDirectory(baseName, schemaPath) {
+    if (schemaPath) {
+        const explicitPath = path.join(NODES_BASE_DIST, schemaPath, '__schema__');
+        if (fs.existsSync(explicitPath)) {
+            return explicitPath;
+        }
+    }
+    const possibleNames = [
+        baseName.charAt(0).toUpperCase() + baseName.slice(1),
+        baseName,
+        baseName.toUpperCase(),
+    ];
+    for (const folderName of possibleNames) {
+        const flatPath = path.join(NODES_BASE_DIST, folderName, '__schema__');
+        if (fs.existsSync(flatPath)) {
+            return flatPath;
+        }
+    }
+    return findNestedSchemaDir(NODES_BASE_DIST, possibleNames);
+}
+function discoverSchemasForNode(nodeName, version, schemaPath) {
+    const cacheKey = `${nodeName}:${version}`;
+    if (schemaCache.has(cacheKey)) {
+        return schemaCache.get(cacheKey);
+    }
+    const schemas = [];
+    const baseName = nodeName.split('.').pop() ?? '';
+    const schemaDir = findSchemaDirectory(baseName, schemaPath);
+    if (!schemaDir) {
+        schemaCache.set(cacheKey, schemas);
+        return schemas;
+    }
+    const versionDir = findVersionDirectory(schemaDir, version);
+    if (!versionDir) {
+        schemaCache.set(cacheKey, schemas);
+        return schemas;
+    }
+    try {
+        const entries = fs.readdirSync(versionDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.json')) {
+                const operationName = entry.name.replace('.json', '');
+                const filePath = path.join(versionDir, entry.name);
+                try {
+                    const schemaContent = fs.readFileSync(filePath, 'utf-8');
+                    const schema = JSON.parse(schemaContent);
+                    schemas.push({
+                        resource: '',
+                        operation: operationName,
+                        schema,
+                    });
+                }
+                catch {
+                }
+                continue;
+            }
+            if (!entry.isDirectory())
+                continue;
+            const resourceDir = path.join(versionDir, entry.name);
+            const operations = fs.readdirSync(resourceDir, { withFileTypes: true });
+            for (const opEntry of operations) {
+                if (!opEntry.isFile() || !opEntry.name.endsWith('.json'))
+                    continue;
+                const operationName = opEntry.name.replace('.json', '');
+                const schemaPath = path.join(resourceDir, opEntry.name);
+                try {
+                    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+                    const schema = JSON.parse(schemaContent);
+                    schemas.push({
+                        resource: entry.name,
+                        operation: operationName,
+                        schema,
+                    });
+                }
+                catch {
+                }
+            }
+        }
+    }
+    catch {
+    }
+    schemaCache.set(cacheKey, schemas);
+    return schemas;
+}
+function findVersionDirectory(schemaDir, version) {
+    const exactPath = path.join(schemaDir, `v${version}.0.0`);
+    if (fs.existsSync(exactPath)) {
+        return exactPath;
+    }
+    try {
+        const entries = fs.readdirSync(schemaDir, { withFileTypes: true });
+        const versionDirs = entries
+            .filter((e) => e.isDirectory() && /^v\d+(\.\d+)*$/.test(e.name))
+            .map((e) => {
+            const match = e.name.match(/^v(\d+)/);
+            return {
+                name: e.name,
+                majorVersion: match ? parseInt(match[1], 10) : 0,
+            };
+        })
+            .filter((v) => v.majorVersion <= version)
+            .sort((a, b) => b.majorVersion - a.majorVersion);
+        if (versionDirs.length > 0) {
+            return path.join(schemaDir, versionDirs[0].name);
+        }
+    }
+    catch {
+    }
+    return undefined;
+}
+function jsonSchemaToTypeScript(schema, indent = 0) {
+    const indentStr = INDENT.repeat(indent);
+    const nextIndent = INDENT.repeat(indent + 1);
+    if (Array.isArray(schema.type)) {
+        const types = schema.type.map((t) => jsonSchemaToTypeScript({ ...schema, type: t }, indent));
+        return types.join(' | ');
+    }
+    if (schema.enum) {
+        return schema.enum
+            .map((v) => {
+            if (typeof v === 'string')
+                return `'${v}'`;
+            if (v === null)
+                return 'null';
+            if (typeof v === 'object')
+                return JSON.stringify(v);
+            return String(v);
+        })
+            .join(' | ');
+    }
+    if (schema.const !== undefined) {
+        if (typeof schema.const === 'string')
+            return `'${schema.const}'`;
+        if (schema.const === null)
+            return 'null';
+        if (typeof schema.const === 'object')
+            return JSON.stringify(schema.const);
+        return String(schema.const);
+    }
+    if (schema.oneOf || schema.anyOf) {
+        const variants = schema.oneOf ?? schema.anyOf ?? [];
+        return variants.map((v) => jsonSchemaToTypeScript(v, indent)).join(' | ');
+    }
+    if (schema.allOf) {
+        return schema.allOf.map((v) => jsonSchemaToTypeScript(v, indent)).join(' & ');
+    }
+    switch (schema.type) {
+        case 'string':
+            return 'string';
+        case 'integer':
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'null':
+            return 'null';
+        case 'array':
+            if (schema.items) {
+                return `Array<${jsonSchemaToTypeScript(schema.items, indent)}>`;
+            }
+            return 'unknown[]';
+        case 'object':
+            if (schema.properties && Object.keys(schema.properties).length > 0) {
+                const required = new Set(schema.required ?? []);
+                const props = Object.entries(schema.properties).map(([key, propSchema]) => {
+                    const optional = required.has(key) ? '' : '?';
+                    const quotedKey = needsQuoting(key) ? `'${key}'` : key;
+                    const propType = jsonSchemaToTypeScript(propSchema, indent + 1);
+                    return `${nextIndent}${quotedKey}${optional}: ${propType};`;
+                });
+                return `{\n${props.join('\n')}\n${indentStr}}`;
+            }
+            if (schema.additionalProperties) {
+                if (typeof schema.additionalProperties === 'boolean') {
+                    return 'Record<string, unknown>';
+                }
+                return `Record<string, ${jsonSchemaToTypeScript(schema.additionalProperties, indent)}>`;
+            }
+            return 'Record<string, unknown>';
+        default:
+            return 'unknown';
+    }
+}
+function findSchemaForOperation(schemas, resource, operation) {
+    return schemas.find((s) => s.resource.toLowerCase() === resource.toLowerCase() && s.operation === operation);
+}
+function generateResourceLocatorType(prop) {
+    if (prop.modes && prop.modes.length > 0) {
+        const modeNames = prop.modes.map((m) => `'${m.name}'`).join(' | ');
+        return `{ __rl: true; mode: ${modeNames}; value: string; cachedResultName?: string }`;
+    }
+    return '{ __rl: true; mode: string; value: string; cachedResultName?: string }';
+}
+function mapNestedPropertyType(prop, discriminatorContext) {
+    const result = mapNestedPropertyTypeInner(prop, discriminatorContext);
+    if (prop.noDataExpression) {
+        return stripExpressionFromType(result);
+    }
+    return result;
+}
+function mapNestedPropertyTypeInner(prop, discriminatorContext) {
+    if (prop.typeOptions?.loadOptionsMethod || prop.typeOptions?.loadOptionsDependsOn) {
+        switch (prop.type) {
+            case 'options':
+                return 'string | Expression<string>';
+            case 'multiOptions':
+                return 'string[]';
+            case 'resourceLocator':
+                return generateResourceLocatorType(prop);
+            case 'filter':
+                return 'FilterValue';
+            case 'assignmentCollection':
+                return 'AssignmentCollectionValue';
+            default:
+                return 'string | Expression<string>';
+        }
+    }
+    switch (prop.type) {
+        case 'string':
+            if (prop.builderHint?.placeholderSupported === false) {
+                return 'string | Expression<string>';
+            }
+            return 'string | Expression<string> | PlaceholderValue';
+        case 'number':
+            return 'number | Expression<number>';
+        case 'boolean':
+            return 'boolean | Expression<boolean>';
+        case 'options':
+            if (prop.options && prop.options.length > 0 && prop.options[0].value !== undefined) {
+                const values = prop.options.map((opt) => {
+                    if (typeof opt.value === 'string') {
+                        const escaped = opt.value
+                            .replace(/\\/g, '\\\\')
+                            .replace(/'/g, "\\'")
+                            .replace(/\n/g, '\\n')
+                            .replace(/\r/g, '\\r')
+                            .replace(/\t/g, '\\t');
+                        return `'${escaped}'`;
+                    }
+                    return String(opt.value);
+                });
+                const valueType = typeof prop.options[0].value;
+                const expressionType = valueType === 'number'
+                    ? 'Expression<number>'
+                    : valueType === 'boolean'
+                        ? 'Expression<boolean>'
+                        : 'Expression<string>';
+                return `${values.join(' | ')} | ${expressionType}`;
+            }
+            return 'string | Expression<string>';
+        case 'multiOptions':
+            if (prop.options && prop.options.length > 0 && prop.options[0].value !== undefined) {
+                const values = prop.options.map((opt) => {
+                    if (typeof opt.value === 'string') {
+                        return `'${opt.value}'`;
+                    }
+                    return String(opt.value);
+                });
+                return `Array<${values.join(' | ')}>`;
+            }
+            return 'string[]';
+        case 'json':
+            return 'IDataObject | string | Expression<string>';
+        case 'resourceLocator':
+            return generateResourceLocatorType(prop);
+        case 'filter':
+            return 'FilterValue';
+        case 'assignmentCollection':
+            return 'AssignmentCollectionValue';
+        case 'fixedCollection':
+            return generateFixedCollectionType(prop, discriminatorContext);
+        case 'collection':
+            return generateCollectionType(prop, discriminatorContext);
+        case 'dateTime':
+            return 'string | Expression<string>';
+        case 'color':
+            return 'string | Expression<string>';
+        case 'hidden':
+            return 'unknown';
+        case 'notice':
+        case 'curlImport':
+        case 'credentials':
+            return '';
+        case 'credentialsSelect':
+            return 'string | Expression<string>';
+        default:
+            return 'unknown';
+    }
+}
+function needsQuoting(name) {
+    return RESERVED_WORDS.has(name) || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+function quotePropertyName(name) {
+    if (needsQuoting(name)) {
+        return `'${name.replace(/'/g, "\\'")}'`;
+    }
+    return name;
+}
+function isPropertyOptional(prop) {
+    const hasDefault = 'default' in prop && prop.default !== undefined;
+    return !prop.required || hasDefault;
+}
+function generateNestedPropertyJSDoc(prop, indent, discriminatorContext) {
+    const lines = [];
+    const description = prop.description ?? prop.displayName;
+    if (description) {
+        const safeDescription = description
+            .replace(/\*\//g, '*\\/')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+        lines.push(`${indent}/** ${safeDescription}`);
+    }
+    else {
+        lines.push(`${indent}/**`);
+    }
+    if (prop.hint) {
+        const safeHint = prop.hint.replace(/\*\//g, '*\\/').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        lines.push(`${indent} * @hint ${safeHint}`);
+    }
+    if (prop.builderHint) {
+        const safeBuilderHint = prop.builderHint.message
+            .replace(/\*\//g, '*\\/')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+        lines.push(`${indent} * @builderHint ${safeBuilderHint}`);
+    }
+    if (prop.displayOptions) {
+        if (prop.displayOptions.show && Object.keys(prop.displayOptions.show).length > 0) {
+            const filteredShow = Object.entries(prop.displayOptions.show).filter(([key, values]) => {
+                if (key === '@version')
+                    return false;
+                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
+                if (discriminatorContext?.[normalizedKey] !== undefined) {
+                    const showValues = values;
+                    if (showValues.includes(discriminatorContext[normalizedKey]))
+                        return false;
+                }
+                return true;
+            });
+            if (filteredShow.length > 0) {
+                const showConditions = filteredShow
+                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
+                    .join(', ');
+                lines.push(`${indent} * @displayOptions.show { ${showConditions} }`);
+            }
+        }
+        if (prop.displayOptions.hide && Object.keys(prop.displayOptions.hide).length > 0) {
+            const filteredHide = Object.entries(prop.displayOptions.hide).filter(([key, values]) => {
+                if (key === '@version')
+                    return false;
+                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
+                if (discriminatorContext?.[normalizedKey] !== undefined) {
+                    const hideValues = values;
+                    if (hideValues.includes(discriminatorContext[normalizedKey]))
+                        return false;
+                }
+                return true;
+            });
+            if (filteredHide.length > 0) {
+                const hideConditions = filteredHide
+                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
+                    .join(', ');
+                lines.push(`${indent} * @displayOptions.hide { ${hideConditions} }`);
+            }
+        }
+    }
+    if (prop.default !== undefined && prop.default !== null && prop.default !== '') {
+        let defaultStr;
+        if (typeof prop.default === 'object') {
+            defaultStr = JSON.stringify(prop.default);
+        }
+        else {
+            defaultStr = String(prop.default);
+        }
+        if (!defaultStr.includes('\n')) {
+            lines.push(`${indent} * @default ${defaultStr}`);
+        }
+    }
+    lines.push(`${indent} */`);
+    return lines.join('\n');
+}
+function generateFixedCollectionType(prop, discriminatorContext) {
+    if (!prop.options || prop.options.length === 0) {
+        return 'Record<string, 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 nestedType = mapNestedPropertyType(nestedProp, discriminatorContext);
+            if (nestedType) {
+                const quotedName = quotePropertyName(nestedProp.name);
+                const jsDoc = generateNestedPropertyJSDoc(nestedProp, INDENT.repeat(3), discriminatorContext);
+                nestedProps.push(`${jsDoc}\n${INDENT.repeat(3)}${quotedName}?: ${nestedType}`);
+            }
+        }
+        if (nestedProps.length > 0) {
+            const innerType = `{\n${nestedProps.join(';\n')};\n${INDENT.repeat(2)}}`;
+            const groupType = isMultipleValues ? `Array<${innerType}>` : innerType;
+            const groupJsDocLines = [];
+            if (group.displayName || group.description) {
+                const desc = (group.description ?? group.displayName ?? '')
+                    .replace(/\*\//g, '*\\/')
+                    .replace(/</g, '&lt;')
+                    .replace(/>/g, '&gt;');
+                groupJsDocLines.push(`${INDENT.repeat(2)}/** ${desc}`);
+            }
+            if (group.builderHint) {
+                const safeBuilderHint = group.builderHint.message
+                    .replace(/\*\//g, '*\\/')
+                    .replace(/</g, '&lt;')
+                    .replace(/>/g, '&gt;');
+                if (groupJsDocLines.length === 0) {
+                    groupJsDocLines.push(`${INDENT.repeat(2)}/**`);
+                }
+                groupJsDocLines.push(`${INDENT.repeat(2)} * @builderHint ${safeBuilderHint}`);
+            }
+            if (groupJsDocLines.length > 0) {
+                groupJsDocLines.push(`${INDENT.repeat(2)} */`);
+                groups.push(`${groupJsDocLines.join('\n')}\n${INDENT.repeat(2)}${groupName}?: ${groupType}`);
+            }
+            else {
+                groups.push(`${groupName}?: ${groupType}`);
+            }
+        }
+    }
+    if (groups.length === 0) {
+        return 'Record<string, unknown>';
+    }
+    return `{\n${INDENT.repeat(2)}${groups.join(`;\n${INDENT.repeat(2)}`)};\n${INDENT}}`;
+}
+function mergeCollectionProperties(properties) {
+    const seenProps = new Map();
+    for (const prop of properties) {
+        if (['notice', 'curlImport', 'credentials'].includes(prop.type)) {
+            continue;
+        }
+        if (seenProps.has(prop.name)) {
+            const existingProp = seenProps.get(prop.name);
+            if ((prop.type === 'collection' || prop.type === 'fixedCollection') &&
+                prop.options &&
+                existingProp.options) {
+                const existingOptionNames = new Set(existingProp.options.map((o) => o.name));
+                for (const opt of prop.options) {
+                    if (!existingOptionNames.has(opt.name)) {
+                        existingProp.options.push(opt);
+                    }
+                }
+            }
+            continue;
+        }
+        seenProps.set(prop.name, {
+            ...prop,
+            options: prop.options ? [...prop.options] : undefined,
+        });
+    }
+    return Array.from(seenProps.values());
+}
+function generateCollectionType(prop, discriminatorContext) {
+    if (!prop.options || prop.options.length === 0) {
+        return 'Record<string, unknown>';
+    }
+    const nestedProps = [];
+    for (const nestedProp of prop.options) {
+        if (nestedProp.values !== undefined) {
+            continue;
+        }
+        const nestedType = nestedProp.type;
+        if (['notice', 'curlImport', 'credentials'].includes(nestedType)) {
+            continue;
+        }
+        const propType = mapNestedPropertyType(nestedProp, discriminatorContext);
+        if (propType) {
+            const quotedName = quotePropertyName(nestedProp.name);
+            const jsDoc = generateNestedPropertyJSDoc(nestedProp, INDENT.repeat(2), discriminatorContext);
+            nestedProps.push(`${jsDoc}\n${INDENT.repeat(2)}${quotedName}?: ${propType}`);
+        }
+    }
+    if (nestedProps.length === 0) {
+        return 'Record<string, unknown>';
+    }
+    return `{\n${nestedProps.join(';\n')};\n${INDENT}}`;
+}
+function stripExpressionFromType(typeStr) {
+    return typeStr
+        .replace(/\s*\|\s*Expression<[^>]+>/g, '')
+        .replace(/\s*\|\s*PlaceholderValue/g, '')
+        .trim();
+}
+function mapPropertyType(prop, discriminatorContext) {
+    const result = mapPropertyTypeInner(prop, discriminatorContext);
+    if (prop.noDataExpression) {
+        return stripExpressionFromType(result);
+    }
+    return result;
+}
+function mapPropertyTypeInner(prop, discriminatorContext) {
+    if (prop.type === 'credentialsSelect' && prop.name === 'genericAuthType') {
+        const values = GENERIC_AUTH_TYPE_VALUES.map((v) => `'${v}'`).join(' | ');
+        return `${values} | Expression<string>`;
+    }
+    if (prop.typeOptions?.loadOptionsMethod || prop.typeOptions?.loadOptionsDependsOn) {
+        switch (prop.type) {
+            case 'options':
+                return 'string | Expression<string>';
+            case 'multiOptions':
+                return 'string[]';
+            case 'resourceLocator':
+                return generateResourceLocatorType(prop);
+            case 'filter':
+                return 'FilterValue';
+            case 'assignmentCollection':
+                return 'AssignmentCollectionValue';
+            default:
+                return 'string | Expression<string>';
+        }
+    }
+    switch (prop.type) {
+        case 'string':
+            if (prop.builderHint?.placeholderSupported === false) {
+                return 'string | Expression<string>';
+            }
+            return 'string | Expression<string> | PlaceholderValue';
+        case 'number':
+            return 'number | Expression<number>';
+        case 'boolean':
+            return 'boolean | Expression<boolean>';
+        case 'options':
+            if (prop.options && prop.options.length > 0) {
+                const values = prop.options.map((opt) => {
+                    if (typeof opt.value === 'string') {
+                        const escaped = opt.value
+                            .replace(/\\/g, '\\\\')
+                            .replace(/'/g, "\\'")
+                            .replace(/\n/g, '\\n')
+                            .replace(/\r/g, '\\r')
+                            .replace(/\t/g, '\\t');
+                        return `'${escaped}'`;
+                    }
+                    return String(opt.value);
+                });
+                const valueType = typeof prop.options[0].value;
+                const expressionType = valueType === 'number'
+                    ? 'Expression<number>'
+                    : valueType === 'boolean'
+                        ? 'Expression<boolean>'
+                        : 'Expression<string>';
+                return `${values.join(' | ')} | ${expressionType}`;
+            }
+            return 'string | Expression<string>';
+        case 'multiOptions':
+            if (prop.options && prop.options.length > 0) {
+                const values = prop.options.map((opt) => {
+                    if (typeof opt.value === 'string') {
+                        return `'${opt.value}'`;
+                    }
+                    return String(opt.value);
+                });
+                return `Array<${values.join(' | ')}>`;
+            }
+            return 'string[]';
+        case 'json':
+            return 'IDataObject | string | Expression<string>';
+        case 'resourceLocator':
+            return generateResourceLocatorType(prop);
+        case 'filter':
+            return 'FilterValue';
+        case 'assignmentCollection':
+            return 'AssignmentCollectionValue';
+        case 'fixedCollection':
+            return generateFixedCollectionType(prop, discriminatorContext);
+        case 'collection':
+            return generateCollectionType(prop, discriminatorContext);
+        case 'dateTime':
+            return 'string | Expression<string>';
+        case 'color':
+            return 'string | Expression<string>';
+        case 'hidden':
+            return 'unknown';
+        case 'notice':
+        case 'curlImport':
+        case 'credentials':
+            return '';
+        case 'credentialsSelect':
+            return 'string | Expression<string>';
+        default:
+            return 'unknown';
+    }
+}
+function extractDiscriminatorCombinations(node) {
+    const combinations = [];
+    const resourceProp = node.properties.find((p) => p.name === 'resource' && p.type === 'options');
+    const operationProps = node.properties.filter((p) => p.name === 'operation' && p.type === 'options');
+    if (resourceProp && operationProps.length > 0) {
+        const resources = resourceProp.options?.map((o) => String(o.value)) ?? [];
+        for (const resource of resources) {
+            const opProp = operationProps.find((op) => {
+                const showResource = op.displayOptions?.show?.resource;
+                return showResource?.includes(resource);
+            });
+            if (opProp?.options) {
+                for (const opOption of opProp.options) {
+                    combinations.push({
+                        resource,
+                        operation: String(opOption.value),
+                    });
+                }
+            }
+        }
+        return combinations;
+    }
+    const otherDiscriminators = ['mode'];
+    for (const discName of otherDiscriminators) {
+        const discProp = node.properties.find((p) => p.name === discName && p.type === 'options' && p.options && p.options.length > 1);
+        if (discProp?.displayOptions) {
+            const hasNonVersionDisplayOptions = (discProp.displayOptions.show &&
+                Object.keys(discProp.displayOptions.show).some((k) => k !== '@version')) ||
+                (discProp.displayOptions.hide &&
+                    Object.keys(discProp.displayOptions.hide).some((k) => k !== '@version'));
+            if (hasNonVersionDisplayOptions) {
+                continue;
+            }
+        }
+        if (discProp?.options) {
+            const hasDependentProps = node.properties.some((p) => p.displayOptions?.show?.[discName] !== undefined ||
+                p.displayOptions?.hide?.[discName] !== undefined);
+            if (hasDependentProps) {
+                for (const opt of discProp.options) {
+                    combinations.push({
+                        [discName]: String(opt.value),
+                    });
+                }
+                return combinations;
+            }
+        }
+    }
+    return [];
+}
+function getPropertiesForCombination(node, combination) {
+    const result = [];
+    for (const prop of node.properties) {
+        if (DISCRIMINATOR_FIELDS.includes(prop.name)) {
+            continue;
+        }
+        if (['notice', 'curlImport', 'credentials'].includes(prop.type)) {
+            continue;
+        }
+        if (prop.displayOptions?.show) {
+            let matches = true;
+            for (const [key, conditions] of Object.entries(prop.displayOptions.show)) {
+                if (combination[key] !== undefined) {
+                    if (!(0, display_options_1.checkConditions)(conditions, [combination[key]])) {
+                        matches = false;
+                        break;
+                    }
+                }
+            }
+            if (matches) {
+                result.push(prop);
+            }
+        }
+        else if (prop.displayOptions?.hide) {
+            let excluded = false;
+            for (const [key, conditions] of Object.entries(prop.displayOptions.hide)) {
+                if (combination[key] !== undefined) {
+                    if ((0, display_options_1.checkConditions)(conditions, [combination[key]])) {
+                        excluded = true;
+                        break;
+                    }
+                }
+            }
+            if (!excluded) {
+                result.push(prop);
+            }
+        }
+        else {
+            result.push(prop);
+        }
+    }
+    return result;
+}
+function versionMatchesCondition(version, condition) {
+    if (typeof condition === 'number') {
+        return version === condition;
+    }
+    if (condition._cnd) {
+        const { gt, gte, lt, lte } = condition._cnd;
+        if (gt !== undefined && !(version > gt))
+            return false;
+        if (gte !== undefined && !(version >= gte))
+            return false;
+        if (lt !== undefined && !(version < lt))
+            return false;
+        if (lte !== undefined && !(version <= lte))
+            return false;
+        return true;
+    }
+    return false;
+}
+function propertyAppliesToVersion(prop, version) {
+    if (!prop.displayOptions) {
+        return true;
+    }
+    if (prop.displayOptions.show?.['@version']) {
+        const allowedVersions = prop.displayOptions.show['@version'];
+        const anyMatches = allowedVersions.some((cond) => versionMatchesCondition(version, cond));
+        if (!anyMatches) {
+            return false;
+        }
+    }
+    if (prop.displayOptions.hide?.['@version']) {
+        const hiddenVersions = prop.displayOptions.hide['@version'];
+        const anyMatches = hiddenVersions.some((cond) => versionMatchesCondition(version, cond));
+        if (anyMatches) {
+            return false;
+        }
+    }
+    return true;
+}
+function filterPropertiesForVersion(properties, version) {
+    return properties.filter((prop) => propertyAppliesToVersion(prop, version));
+}
+function generateDiscriminatedUnion(node) {
+    const combinations = extractDiscriminatorCombinations(node);
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const version = getHighestVersion(node.version);
+    const versionSuffix = versionToTypeName(version);
+    const lines = [];
+    if (combinations.length === 0) {
+        const configName = `${nodeName}${versionSuffix}Params`;
+        lines.push(`export interface ${configName} {`);
+        const mergedProps = mergeCollectionProperties(node.properties);
+        for (const prop of mergedProps) {
+            const propLine = generatePropertyLine(prop, isPropertyOptional(prop));
+            if (propLine) {
+                lines.push(propLine);
+            }
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    const configTypeNames = [];
+    for (const combo of combinations) {
+        const comboValues = Object.entries(combo)
+            .filter(([_, v]) => v !== undefined)
+            .map(([_, v]) => toPascalCase(v));
+        const configName = `${nodeName}${comboValues.join('')}Params`;
+        configTypeNames.push(configName);
+        const props = getPropertiesForCombination(node, combo);
+        let description;
+        for (const [key, value] of Object.entries(combo)) {
+            if (value === undefined)
+                continue;
+            const discProp = node.properties.find((p) => p.name === key && p.options?.some((o) => o.value === value));
+            if (discProp) {
+                description = discProp.options?.find((o) => o.value === value)?.description;
+                if (description)
+                    break;
+            }
+        }
+        if (description) {
+            lines.push(`/** ${description} */`);
+        }
+        lines.push(`export type ${configName} = {`);
+        for (const [key, value] of Object.entries(combo)) {
+            if (value !== undefined) {
+                lines.push(`${INDENT}${key}: '${value}';`);
+            }
+        }
+        const seenNames = new Set();
+        for (const prop of props) {
+            if (seenNames.has(prop.name)) {
+                continue;
+            }
+            seenNames.add(prop.name);
+            const propLine = generatePropertyLine(prop, isPropertyOptional(prop), combo);
+            if (propLine) {
+                lines.push(propLine);
+            }
+        }
+        lines.push('};');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function generatePropertyJSDoc(prop, discriminatorContext) {
+    const lines = ['/**'];
+    const description = prop.description ?? prop.displayName;
+    const safeDescription = description
+        .replace(/\*\//g, '*\\/')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+    lines.push(` * ${safeDescription}`);
+    if (prop.hint) {
+        const safeHint = prop.hint.replace(/\*\//g, '*\\/').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        lines.push(` * @hint ${safeHint}`);
+    }
+    if (prop.builderHint) {
+        const safeBuilderHint = prop.builderHint.message
+            .replace(/\*\//g, '*\\/')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+        lines.push(` * @builderHint ${safeBuilderHint}`);
+    }
+    if (prop.displayOptions) {
+        if (prop.displayOptions.show && Object.keys(prop.displayOptions.show).length > 0) {
+            const filteredShow = Object.entries(prop.displayOptions.show).filter(([key, values]) => {
+                if (key === '@version')
+                    return false;
+                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
+                if (discriminatorContext?.[normalizedKey] !== undefined) {
+                    const showValues = values;
+                    if (showValues.includes(discriminatorContext[normalizedKey]))
+                        return false;
+                }
+                return true;
+            });
+            if (filteredShow.length > 0) {
+                const showConditions = filteredShow
+                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
+                    .join(', ');
+                lines.push(` * @displayOptions.show { ${showConditions} }`);
+            }
+        }
+        if (prop.displayOptions.hide && Object.keys(prop.displayOptions.hide).length > 0) {
+            const filteredHide = Object.entries(prop.displayOptions.hide).filter(([key, values]) => {
+                if (key === '@version')
+                    return false;
+                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
+                if (discriminatorContext?.[normalizedKey] !== undefined) {
+                    const hideValues = values;
+                    if (hideValues.includes(discriminatorContext[normalizedKey]))
+                        return false;
+                }
+                return true;
+            });
+            if (filteredHide.length > 0) {
+                const hideConditions = filteredHide
+                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
+                    .join(', ');
+                lines.push(` * @displayOptions.hide { ${hideConditions} }`);
+            }
+        }
+    }
+    if (prop.default !== undefined && prop.default !== null && prop.default !== '') {
+        let defaultStr;
+        if (typeof prop.default === 'object') {
+            defaultStr = JSON.stringify(prop.default);
+        }
+        else {
+            defaultStr = String(prop.default);
+        }
+        if (!defaultStr.includes('\n')) {
+            lines.push(` * @default ${defaultStr}`);
+        }
+    }
+    lines.push(' */');
+    return lines.join('\n');
+}
+function generateNodeJSDoc(node) {
+    const lines = ['/**'];
+    lines.push(` * ${node.displayName} Node Types`);
+    lines.push(' *');
+    if (node.description) {
+        lines.push(` * ${node.description}`);
+    }
+    const subnodeType = getSubnodeOutputType(node);
+    if (subnodeType) {
+        lines.push(` * @subnodeType ${subnodeType}`);
+    }
+    lines.push(' */');
+    return lines.join('\n');
+}
+function generatePropertyLine(prop, optional, discriminatorContext) {
+    const tsType = mapPropertyType(prop, discriminatorContext);
+    if (!tsType) {
+        return '';
+    }
+    const lines = [];
+    const hasDisplayOptions = prop.displayOptions &&
+        ((prop.displayOptions.show && Object.keys(prop.displayOptions.show).length > 0) ||
+            (prop.displayOptions.hide && Object.keys(prop.displayOptions.hide).length > 0));
+    if (prop.description || hasDisplayOptions || prop.hint || prop.builderHint) {
+        lines.push(generatePropertyJSDoc(prop, discriminatorContext));
+    }
+    let propName = prop.name;
+    const needsQuoting = RESERVED_WORDS.has(propName) || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName);
+    if (needsQuoting) {
+        propName = `'${propName.replace(/'/g, "\\'")}'`;
+    }
+    const optionalMarker = optional ? '?' : '';
+    lines.push(`${INDENT}${propName}${optionalMarker}: ${tsType};`);
+    return lines.join(`\n${INDENT}`);
+}
+function groupVersionsByProperties(nodes) {
+    const groups = [];
+    for (const node of nodes) {
+        const versions = Array.isArray(node.version) ? node.version : [node.version];
+        const propsHash = JSON.stringify(node.properties.map((p) => p.name).sort());
+        const existing = groups.find((g) => JSON.stringify(g.properties.map((p) => p.name).sort()) === propsHash);
+        if (existing) {
+            existing.versions.push(...versions);
+            existing.highestVersion = Math.max(existing.highestVersion, ...versions);
+        }
+        else {
+            groups.push({
+                versions,
+                highestVersion: Math.max(...versions),
+                properties: node.properties,
+            });
+        }
+    }
+    return groups;
+}
+function getHighestVersion(version) {
+    if (Array.isArray(version)) {
+        return Math.max(...version);
+    }
+    return version;
+}
+function versionToTypeName(version) {
+    return `V${String(version).replace('.', '')}`;
+}
+function nodeNameToFileName(nodeName) {
+    const parts = nodeName.split('.');
+    return parts[parts.length - 1];
+}
+function getPackageName(nodeName) {
+    const parts = nodeName.split('.');
+    const pkg = parts[0];
+    if (pkg.startsWith('@n8n/')) {
+        return pkg.replace('@n8n/', '');
+    }
+    return pkg;
+}
+function getNodeBaseName(nodeName) {
+    const parts = nodeName.split('.');
+    return parts[parts.length - 1];
+}
+function getPackagePrefix(nodeName) {
+    const pkg = getPackageName(nodeName);
+    if (pkg === 'n8n-nodes-base') {
+        return '';
+    }
+    if (pkg.includes('langchain')) {
+        return 'Lc';
+    }
+    return '';
+}
+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 buildDiscriminatorPath(combo) {
+    const parts = [];
+    if (combo.resource && combo.operation) {
+        parts.push(`resource_${toSnakeCase(combo.resource)}`);
+        parts.push(`operation_${toSnakeCase(combo.operation)}`);
+        return parts.join('/');
+    }
+    for (const [key, value] of Object.entries(combo)) {
+        if (value !== undefined) {
+            parts.push(`${key}_${toSnakeCase(value)}`);
+        }
+    }
+    return parts.join('/');
+}
+function hasDiscriminatorPattern(node) {
+    const combinations = extractDiscriminatorCombinations(node);
+    if (combinations.length === 0) {
+        return false;
+    }
+    const first = combinations[0];
+    if (first.resource !== undefined && first.operation !== undefined) {
+        return true;
+    }
+    if (first.mode !== undefined) {
+        return true;
+    }
+    return false;
+}
+function buildDiscriminatorTree(combinations) {
+    if (combinations.length === 0) {
+        return { type: 'single' };
+    }
+    const first = combinations[0];
+    if (first.resource !== undefined && first.operation !== undefined) {
+        const resources = new Map();
+        for (const combo of combinations) {
+            if (combo.resource && combo.operation) {
+                if (!resources.has(combo.resource)) {
+                    resources.set(combo.resource, []);
+                }
+                resources.get(combo.resource).push(combo.operation);
+            }
+        }
+        return { type: 'resource_operation', resources };
+    }
+    const discName = Object.keys(first).find((k) => first[k] !== undefined);
+    if (discName) {
+        const values = combinations.map((c) => c[discName]).filter(Boolean);
+        return {
+            type: 'single',
+            discriminatorName: discName,
+            discriminatorValues: [...new Set(values)],
+        };
+    }
+    return { type: 'single' };
+}
+function generateSharedFile(node, version, _importDepth = 5) {
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const isTrigger = isTriggerNode(node);
+    const versionSuffix = versionToTypeName(version);
+    const filteredProperties = filterPropertiesForVersion(node.properties, version);
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${version} - Shared Types`);
+    lines.push(' * ');
+    lines.push(' * Contains credentials, base type, and helper types shared across all');
+    lines.push(' * resource/operation combinations.');
+    lines.push(' */');
+    lines.push('');
+    lines.push('');
+    const outputProps = filteredProperties.filter((p) => !['notice', 'curlImport', 'credentials'].includes(p.type));
+    const needsFilter = outputProps.some((p) => p.type === 'filter');
+    const needsAssignment = outputProps.some((p) => p.type === 'assignmentCollection');
+    if (needsFilter || needsAssignment) {
+        lines.push('// Helper types for special n8n fields');
+        if (needsFilter) {
+            lines.push(generateFilterTypeDeclaration(true));
+        }
+        if (needsAssignment) {
+            lines.push(generateAssignmentTypeDeclarations(true));
+        }
+        lines.push('');
+    }
+    const credTypeName = node.credentials && node.credentials.length > 0
+        ? `${nodeName}${versionSuffix}Credentials`
+        : undefined;
+    if (node.credentials && node.credentials.length > 0) {
+        lines.push(`export interface ${credTypeName} {`);
+        const seenCreds = new Set();
+        for (const cred of node.credentials) {
+            if (seenCreds.has(cred.name))
+                continue;
+            seenCreds.add(cred.name);
+            const optional = !cred.required ? '?' : '';
+            lines.push(`${INDENT}${cred.name}${optional}: CredentialReference;`);
+        }
+        const hasGenericAuthType = node.properties.some((p) => p.name === 'genericAuthType' && p.type === 'credentialsSelect');
+        if (hasGenericAuthType) {
+            lines.push(`${INDENT}/** Generic auth credentials - set the 'genericAuthType' config parameter to select which one to use */`);
+            for (const credName of GENERIC_AUTH_TYPE_VALUES) {
+                if (!seenCreds.has(credName)) {
+                    seenCreds.add(credName);
+                    lines.push(`${INDENT}${credName}?: CredentialReference;`);
+                }
+            }
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    const baseTypeName = `${nodeName}${versionSuffix}NodeBase`;
+    lines.push(`export interface ${baseTypeName} {`);
+    lines.push(`${INDENT}type: '${node.name}';`);
+    lines.push(`${INDENT}version: ${version};`);
+    if (credTypeName) {
+        lines.push(`${INDENT}credentials?: ${credTypeName};`);
+    }
+    if (isTrigger) {
+        lines.push(`${INDENT}isTrigger: true;`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function generateDiscriminatorFile(node, version, combo, props, schema, _importDepth = 5) {
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const versionSuffix = versionToTypeName(version);
+    const isTrigger = isTriggerNode(node);
+    const comboValues = Object.entries(combo)
+        .filter(([_, v]) => v !== undefined)
+        .map(([_, v]) => toPascalCase(v));
+    const comboSuffix = comboValues.join('');
+    const configName = `${nodeName}${versionSuffix}${comboSuffix}Params`;
+    const outputTypeName = `${nodeName}${versionSuffix}${comboSuffix}Output`;
+    const nodeTypeName = `${nodeName}${versionSuffix}${comboSuffix}Node`;
+    const aiInputTypes = extractAIInputTypesFromBuilderHint(node, combo);
+    const subnodeConfigTypeName = aiInputTypes.length > 0 ? `${nodeName}${versionSuffix}${comboSuffix}SubnodeConfig` : undefined;
+    const lines = [];
+    const comboDesc = Object.entries(combo)
+        .filter(([_, v]) => v !== undefined)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ');
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${version}`);
+    lines.push(` * Discriminator: ${comboDesc}`);
+    lines.push(' */');
+    lines.push('');
+    lines.push('');
+    const needsFilter = props.some((p) => p.type === 'filter');
+    const needsAssignment = props.some((p) => p.type === 'assignmentCollection');
+    if (needsFilter || needsAssignment) {
+        lines.push('// Helper types for special n8n fields');
+        if (needsFilter) {
+            lines.push(generateFilterTypeDeclaration(false));
+        }
+        if (needsAssignment) {
+            lines.push(generateAssignmentTypeDeclarations(false));
+        }
+        lines.push('');
+    }
+    if (node.credentials && node.credentials.length > 0) {
+        lines.push('interface Credentials {');
+        const seenCreds = new Set();
+        for (const cred of node.credentials) {
+            if (seenCreds.has(cred.name))
+                continue;
+            seenCreds.add(cred.name);
+            const optional = !cred.required ? '?' : '';
+            lines.push(`${INDENT}${cred.name}${optional}: CredentialReference;`);
+        }
+        const hasGenericAuthType = node.properties.some((p) => p.name === 'genericAuthType' && p.type === 'credentialsSelect');
+        if (hasGenericAuthType) {
+            lines.push(`${INDENT}/** Generic auth credentials - set the 'genericAuthType' config parameter to select which one to use */`);
+            for (const credName of GENERIC_AUTH_TYPE_VALUES) {
+                if (!seenCreds.has(credName)) {
+                    seenCreds.add(credName);
+                    lines.push(`${INDENT}${credName}?: CredentialReference;`);
+                }
+            }
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    let description;
+    for (const [key, value] of Object.entries(combo)) {
+        if (value === undefined)
+            continue;
+        const discProp = node.properties.find((p) => p.name === key && p.options?.some((o) => o.value === value));
+        if (discProp) {
+            description = discProp.options?.find((o) => o.value === value)?.description;
+            if (description)
+                break;
+        }
+    }
+    if (description) {
+        lines.push(`/** ${description} */`);
+    }
+    lines.push(`export type ${configName} = {`);
+    for (const [key, value] of Object.entries(combo)) {
+        if (value !== undefined) {
+            lines.push(`${INDENT}${key}: '${value}';`);
+        }
+    }
+    const seenNames = new Set();
+    for (const prop of props) {
+        if (seenNames.has(prop.name))
+            continue;
+        seenNames.add(prop.name);
+        const propLine = generatePropertyLine(prop, isPropertyOptional(prop), combo);
+        if (propLine) {
+            lines.push(propLine);
+        }
+    }
+    lines.push('};');
+    lines.push('');
+    if (schema) {
+        lines.push(`export type ${outputTypeName} = ${jsonSchemaToTypeScript(schema)};`);
+        lines.push('');
+    }
+    if (subnodeConfigTypeName && aiInputTypes.length > 0) {
+        const subnodeConfigCode = generateNarrowedSubnodeConfig(aiInputTypes, nodeName, versionSuffix, comboSuffix);
+        if (subnodeConfigCode) {
+            lines.push(subnodeConfigCode);
+            lines.push('');
+        }
+    }
+    lines.push(`export type ${nodeTypeName} = {`);
+    lines.push(`${INDENT}type: '${node.name}';`);
+    lines.push(`${INDENT}version: ${version};`);
+    if (node.credentials && node.credentials.length > 0) {
+        lines.push(`${INDENT}credentials?: Credentials;`);
+    }
+    if (isTrigger) {
+        lines.push(`${INDENT}isTrigger: true;`);
+    }
+    const hasRequiredSubnodes = aiInputTypes.some((input) => input.required);
+    const subnodeOptionalMark = hasRequiredSubnodes ? '' : '?';
+    const configType = subnodeConfigTypeName
+        ? `NodeConfig<${configName}> & { subnodes${subnodeOptionalMark}: ${subnodeConfigTypeName} }`
+        : `NodeConfig<${configName}>`;
+    lines.push(`${INDENT}config: ${configType};`);
+    if (schema) {
+        lines.push(`${INDENT}output?: Items<${outputTypeName}>;`);
+    }
+    lines.push('};');
+    return lines.join('\n');
+}
+function generateResourceIndexFile(node, version, resource, operations) {
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const versionSuffix = versionToTypeName(version);
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} - ${toPascalCase(resource)} Resource`);
+    lines.push(' * Re-exports all operation types for this resource.');
+    lines.push(' */');
+    lines.push('');
+    const nodeTypeNames = [];
+    for (const op of operations.sort()) {
+        const fileName = `operation_${toSnakeCase(op)}`;
+        const nodeTypeName = `${nodeName}${versionSuffix}${toPascalCase(resource)}${toPascalCase(op)}Node`;
+        nodeTypeNames.push(nodeTypeName);
+        lines.push(`import type { ${nodeTypeName} } from './${fileName}';`);
+    }
+    lines.push('');
+    for (const op of operations.sort()) {
+        const fileName = `operation_${toSnakeCase(op)}`;
+        lines.push(`export * from './${fileName}';`);
+    }
+    lines.push('');
+    const resourceNodeTypeName = `${nodeName}${versionSuffix}${toPascalCase(resource)}Node`;
+    if (nodeTypeNames.length === 1) {
+        lines.push(`export type ${resourceNodeTypeName} = ${nodeTypeNames[0]};`);
+    }
+    else {
+        lines.push(`export type ${resourceNodeTypeName} =`);
+        for (const typeName of nodeTypeNames) {
+            lines.push(`${INDENT}| ${typeName}`);
+        }
+        lines.push(`${INDENT};`);
+    }
+    return lines.join('\n');
+}
+function generateSplitVersionIndexFile(node, version, tree) {
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const versionSuffix = versionToTypeName(version);
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${version}`);
+    lines.push(' * Re-exports all discriminator combinations.');
+    lines.push(' */');
+    lines.push('');
+    const nodeTypeNames = [];
+    if (tree.type === 'resource_operation' && tree.resources) {
+        for (const [resource] of tree.resources) {
+            const resourceNodeTypeName = `${nodeName}${versionSuffix}${toPascalCase(resource)}Node`;
+            nodeTypeNames.push(resourceNodeTypeName);
+            const resourceDir = `resource_${toSnakeCase(resource)}`;
+            lines.push(`import type { ${resourceNodeTypeName} } from './${resourceDir}';`);
+        }
+        lines.push('');
+        for (const [resource] of tree.resources) {
+            const resourceDir = `resource_${toSnakeCase(resource)}`;
+            lines.push(`export * from './${resourceDir}';`);
+        }
+        lines.push('');
+    }
+    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)}`;
+            const nodeTypeName = `${nodeName}${versionSuffix}${toPascalCase(value)}Node`;
+            nodeTypeNames.push(nodeTypeName);
+            lines.push(`import type { ${nodeTypeName} } from './${fileName}';`);
+        }
+        lines.push('');
+        for (const value of tree.discriminatorValues.sort()) {
+            const fileName = `${discName}_${toSnakeCase(value)}`;
+            lines.push(`export * from './${fileName}';`);
+        }
+        lines.push('');
+    }
+    const nodeTypeName = `${nodeName}${versionSuffix}Node`;
+    if (nodeTypeNames.length === 1) {
+        lines.push(`export type ${nodeTypeName} = ${nodeTypeNames[0]};`);
+    }
+    else if (nodeTypeNames.length > 1) {
+        lines.push(`export type ${nodeTypeName} =`);
+        for (const typeName of nodeTypeNames) {
+            lines.push(`${INDENT}| ${typeName}`);
+        }
+        lines.push(`${INDENT};`);
+    }
+    return lines.join('\n');
+}
+function planSplitVersionFiles(node, version) {
+    const files = new Map();
+    const combinations = extractDiscriminatorCombinations(node);
+    const tree = buildDiscriminatorTree(combinations);
+    const outputSchemas = discoverSchemasForNode(node.name, version, node.schemaPath);
+    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 = filterPropertiesForVersion(node.properties, version);
+                const nodeForCombination = { ...node, properties: versionFilteredProps };
+                const props = getPropertiesForCombination(nodeForCombination, combo);
+                const fileName = `operation_${toSnakeCase(operation)}.ts`;
+                const filePath = `${resourceDir}/${fileName}`;
+                const matchingSchema = findSchemaForOperation(outputSchemas, resource, operation);
+                const content = generateDiscriminatorFile(node, version, combo, props, matchingSchema?.schema, 6);
+                files.set(filePath, content);
+            }
+            const filteredOperations = operations.filter((op) => !isCustomApiCall(op));
+            const resourceIndexContent = generateResourceIndexFile(node, version, resource, filteredOperations);
+            files.set(`${resourceDir}/index.ts`, 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 = filterPropertiesForVersion(node.properties, version);
+            const nodeForCombination = { ...node, properties: versionFilteredProps };
+            const props = getPropertiesForCombination(nodeForCombination, combo);
+            const fileName = `${discName}_${toSnakeCase(value)}.ts`;
+            const content = generateDiscriminatorFile(node, version, combo, props, undefined, 5);
+            files.set(fileName, content);
+        }
+    }
+    files.set('index.ts', generateSplitVersionIndexFile(node, version, tree));
+    const schemaFiles = (0, generate_zod_schemas_1.planSplitVersionSchemaFiles)(node, version);
+    for (const [path, content] of schemaFiles) {
+        files.set(path, content);
+    }
+    return files;
+}
+function isTriggerNode(node) {
+    const inputs = node.inputs;
+    if (Array.isArray(inputs)) {
+        if (inputs.length === 0)
+            return true;
+        if (typeof inputs[0] === 'string') {
+            return !inputs.includes('main');
+        }
+        return !inputs.some((i) => typeof i === 'object' && i.type === 'main');
+    }
+    return false;
+}
+function versionToFileName(version) {
+    return `v${String(version).replace('.', '')}`;
+}
+function generateSingleVersionTypeFile(node, specificVersion) {
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const isTrigger = isTriggerNode(node);
+    const versionSuffix = versionToTypeName(specificVersion);
+    const filteredProperties = filterPropertiesForVersion(node.properties, specificVersion);
+    const filteredNode = {
+        ...node,
+        properties: filteredProperties,
+        version: specificVersion,
+    };
+    const outputSchemas = discoverSchemasForNode(node.name, specificVersion, node.schemaPath);
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node - Version ${specificVersion}`);
+    if (node.description) {
+        lines.push(` * ${node.description}`);
+    }
+    lines.push(' */');
+    lines.push('');
+    lines.push('');
+    const aiInputTypes = extractAIInputTypesFromBuilderHint(node);
+    const subnodeConfigTypeName = aiInputTypes.length > 0 ? `${nodeName}${versionSuffix}SubnodeConfig` : undefined;
+    const outputProps = filteredProperties.filter((p) => !['notice', 'curlImport', 'credentials'].includes(p.type));
+    const needsFilter = outputProps.some((p) => p.type === 'filter');
+    const needsAssignment = outputProps.some((p) => p.type === 'assignmentCollection');
+    if (needsFilter || needsAssignment) {
+        lines.push('// Helper types for special n8n fields');
+        if (needsFilter) {
+            lines.push(generateFilterTypeDeclaration(false));
+        }
+        if (needsAssignment) {
+            lines.push(generateAssignmentTypeDeclarations(false));
+        }
+        lines.push('');
+    }
+    const unionResult = generateDiscriminatedUnionForEntry(filteredNode, nodeName, versionSuffix);
+    lines.push(unionResult.code);
+    lines.push('');
+    const configToOutputType = new Map();
+    const outputTypesToGenerate = [];
+    for (const configInfo of unionResult.configTypes) {
+        let matchingSchema = configInfo.resource && configInfo.operation
+            ? findSchemaForOperation(outputSchemas, configInfo.resource, configInfo.operation)
+            : undefined;
+        if (!matchingSchema && !configInfo.resource && !configInfo.operation) {
+            matchingSchema = outputSchemas.find((s) => s.resource === '');
+        }
+        if (matchingSchema) {
+            let outputTypeName = configInfo.typeName.replace(/Params$/, 'Output');
+            if (outputTypeName === configInfo.typeName) {
+                outputTypeName = `${configInfo.typeName}Output`;
+            }
+            outputTypesToGenerate.push({ typeName: outputTypeName, schema: matchingSchema.schema });
+            configToOutputType.set(configInfo.typeName, outputTypeName);
+        }
+    }
+    if (outputTypesToGenerate.length > 0) {
+        for (const { typeName, schema } of outputTypesToGenerate) {
+            lines.push(`export type ${typeName} = ${jsonSchemaToTypeScript(schema)};`);
+            lines.push('');
+        }
+    }
+    if (subnodeConfigTypeName) {
+        const subnodeConfigCode = generateNarrowedSubnodeConfig(aiInputTypes, nodeName, versionSuffix);
+        if (subnodeConfigCode) {
+            lines.push(subnodeConfigCode);
+            lines.push('');
+        }
+    }
+    const credTypeName = node.credentials && node.credentials.length > 0
+        ? `${nodeName}${versionSuffix}Credentials`
+        : undefined;
+    if (node.credentials && node.credentials.length > 0) {
+        lines.push(`export interface ${credTypeName} {`);
+        const seenCreds = new Set();
+        for (const cred of node.credentials) {
+            if (seenCreds.has(cred.name))
+                continue;
+            seenCreds.add(cred.name);
+            const optional = !cred.required ? '?' : '';
+            lines.push(`${INDENT}${cred.name}${optional}: CredentialReference;`);
+        }
+        const hasGenericAuthType = node.properties.some((p) => p.name === 'genericAuthType' && p.type === 'credentialsSelect');
+        if (hasGenericAuthType) {
+            lines.push(`${INDENT}/** Generic auth credentials - set the 'genericAuthType' config parameter to select which one to use */`);
+            for (const credName of GENERIC_AUTH_TYPE_VALUES) {
+                if (!seenCreds.has(credName)) {
+                    seenCreds.add(credName);
+                    lines.push(`${INDENT}${credName}?: CredentialReference;`);
+                }
+            }
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    const baseTypeName = `${nodeName}${versionSuffix}NodeBase`;
+    lines.push(`interface ${baseTypeName} {`);
+    lines.push(`${INDENT}type: '${node.name}';`);
+    lines.push(`${INDENT}version: ${specificVersion};`);
+    if (credTypeName) {
+        lines.push(`${INDENT}credentials?: ${credTypeName};`);
+    }
+    if (isTrigger) {
+        lines.push(`${INDENT}isTrigger: true;`);
+    }
+    lines.push('}');
+    lines.push('');
+    const individualNodeTypes = [];
+    for (const configInfo of unionResult.configTypes) {
+        const outputTypeName = configToOutputType.get(configInfo.typeName);
+        const individualTypeName = configInfo.typeName.replace(/Config$/, 'Node');
+        const finalTypeName = individualTypeName === configInfo.typeName
+            ? `${configInfo.typeName}Node`
+            : individualTypeName;
+        individualNodeTypes.push(finalTypeName);
+        lines.push(`export type ${finalTypeName} = ${baseTypeName} & {`);
+        if (subnodeConfigTypeName) {
+            const hasRequiredSubnodes = aiInputTypes.some((input) => input.required);
+            const subnodeOptionalMark = hasRequiredSubnodes ? '' : '?';
+            lines.push(`${INDENT}config: NodeConfig<${configInfo.typeName}> & { subnodes${subnodeOptionalMark}: ${subnodeConfigTypeName} };`);
+        }
+        else {
+            lines.push(`${INDENT}config: NodeConfig<${configInfo.typeName}>;`);
+        }
+        if (outputTypeName) {
+            lines.push(`${INDENT}output?: Items<${outputTypeName}>;`);
+        }
+        lines.push('};');
+        lines.push('');
+    }
+    const nodeTypeName = `${nodeName}${versionSuffix}Node`;
+    if (individualNodeTypes.length === 1) {
+        lines.push(`export type ${nodeTypeName} = ${individualNodeTypes[0]};`);
+    }
+    else if (individualNodeTypes.length > 1) {
+        lines.push(`export type ${nodeTypeName} =`);
+        for (let i = 0; i < individualNodeTypes.length; i++) {
+            lines.push(`${INDENT}| ${individualNodeTypes[i]}`);
+        }
+        lines.push(`${INDENT};`);
+    }
+    else {
+        lines.push(`export type ${nodeTypeName} = ${baseTypeName} & {`);
+        lines.push(`${INDENT}config: NodeConfig<Record<string, unknown>>;`);
+        lines.push('};');
+    }
+    return lines.join('\n');
+}
+function generateVersionIndexFile(node, versions, splitVersions = new Set()) {
+    const prefix = getPackagePrefix(node.name);
+    const typeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const sortedVersions = [...versions].sort((a, b) => b - a);
+    const lines = [];
+    lines.push('/**');
+    lines.push(` * ${node.displayName} Node Types`);
+    lines.push(' *');
+    lines.push(' * Re-exports all version-specific types and provides combined union type.');
+    lines.push(' */');
+    lines.push('');
+    const nodeTypeNames = [];
+    for (const version of sortedVersions) {
+        const fileName = versionToFileName(version);
+        const versionSuffix = versionToTypeName(version);
+        const nodeTypeName = `${typeName}${versionSuffix}Node`;
+        nodeTypeNames.push(nodeTypeName);
+        const importPath = splitVersions.has(version) ? `./${fileName}` : `./${fileName}`;
+        lines.push(`import type { ${nodeTypeName} } from '${importPath}';`);
+    }
+    lines.push('');
+    for (const version of sortedVersions) {
+        const fileName = versionToFileName(version);
+        lines.push(`export * from './${fileName}';`);
+    }
+    lines.push('');
+    lines.push('// Combined union type for all versions');
+    lines.push(`export type ${typeName}Node = ${nodeTypeNames.join(' | ')};`);
+    return lines.join('\n');
+}
+function generateNodeTypeFile(nodes) {
+    const nodeArray = Array.isArray(nodes) ? nodes : [nodes];
+    const node = nodeArray[0];
+    const prefix = getPackagePrefix(node.name);
+    const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+    const isTrigger = isTriggerNode(node);
+    const allVersions = [];
+    for (const n of nodeArray) {
+        const versions = Array.isArray(n.version) ? n.version : [n.version];
+        allVersions.push(...versions);
+    }
+    const lines = [];
+    lines.push(generateNodeJSDoc(node));
+    lines.push('');
+    lines.push('');
+    const outputProps = nodeArray.flatMap((n) => n.properties.filter((p) => !['notice', 'curlImport', 'credentials'].includes(p.type)));
+    const needsFilter = outputProps.some((p) => p.type === 'filter');
+    const needsAssignment = outputProps.some((p) => p.type === 'assignmentCollection');
+    if (needsFilter || needsAssignment) {
+        lines.push('// Helper types for special n8n fields');
+        if (needsFilter) {
+            lines.push(generateFilterTypeDeclaration(false));
+        }
+        if (needsAssignment) {
+            lines.push(generateAssignmentTypeDeclarations(false));
+        }
+        lines.push('');
+    }
+    const sortedNodes = [...nodeArray].sort((a, b) => {
+        const aHighest = getHighestVersion(a.version);
+        const bHighest = getHighestVersion(b.version);
+        return bHighest - aHighest;
+    });
+    for (const n of sortedNodes) {
+        const entryVersion = getHighestVersion(n.version);
+        const entryVersionSuffix = versionToTypeName(entryVersion);
+        const unionResult = generateDiscriminatedUnionForEntry(n, nodeName, entryVersionSuffix);
+        lines.push(unionResult.code);
+        lines.push('');
+    }
+    const allCredentials = [];
+    const seenCreds = new Set();
+    for (const n of nodeArray) {
+        if (n.credentials) {
+            for (const cred of n.credentials) {
+                if (!seenCreds.has(cred.name)) {
+                    seenCreds.add(cred.name);
+                    allCredentials.push(cred);
+                }
+            }
+        }
+    }
+    for (const n of sortedNodes) {
+        const entryVersion = getHighestVersion(n.version);
+        const entryVersionSuffix = versionToTypeName(entryVersion);
+        if (n.credentials && n.credentials.length > 0) {
+            lines.push(`export interface ${nodeName}${entryVersionSuffix}Credentials {`);
+            const seenCreds = new Set();
+            for (const cred of n.credentials) {
+                if (seenCreds.has(cred.name))
+                    continue;
+                seenCreds.add(cred.name);
+                const optional = !cred.required ? '?' : '';
+                lines.push(`${INDENT}${cred.name}${optional}: CredentialReference;`);
+            }
+            const hasGenericAuthType = n.properties.some((p) => p.name === 'genericAuthType' && p.type === 'credentialsSelect');
+            if (hasGenericAuthType) {
+                lines.push(`${INDENT}/** Generic auth credentials - set the 'genericAuthType' config parameter to select which one to use */`);
+                for (const credName of GENERIC_AUTH_TYPE_VALUES) {
+                    if (!seenCreds.has(credName)) {
+                        seenCreds.add(credName);
+                        lines.push(`${INDENT}${credName}?: CredentialReference;`);
+                    }
+                }
+            }
+            lines.push('}');
+            lines.push('');
+        }
+    }
+    const nodeTypeNames = [];
+    for (const n of sortedNodes) {
+        const entryVersion = getHighestVersion(n.version);
+        const entryVersionSuffix = versionToTypeName(entryVersion);
+        const versions = Array.isArray(n.version) ? n.version : [n.version];
+        const versionUnion = versions
+            .sort((a, b) => a - b)
+            .map((v) => String(v))
+            .join(' | ');
+        const nodeTypeName = `${nodeName}${entryVersionSuffix}Node`;
+        nodeTypeNames.push(nodeTypeName);
+        const credType = n.credentials && n.credentials.length > 0
+            ? `${nodeName}${entryVersionSuffix}Credentials`
+            : 'Record<string, never>';
+        lines.push(`export type ${nodeTypeName} = {`);
+        lines.push(`${INDENT}type: '${n.name}';`);
+        lines.push(`${INDENT}version: ${versionUnion};`);
+        lines.push(`${INDENT}config: NodeConfig<${nodeName}${entryVersionSuffix}Params>;`);
+        lines.push(`${INDENT}credentials?: ${credType};`);
+        if (isTrigger) {
+            lines.push(`${INDENT}isTrigger: true;`);
+        }
+        lines.push('};');
+        lines.push('');
+    }
+    lines.push(`export type ${nodeName}Node = ${nodeTypeNames.join(' | ')};`);
+    return lines.join('\n');
+}
+function generateDiscriminatedUnionForEntry(node, nodeName, versionSuffix) {
+    const combinations = extractDiscriminatorCombinations(node);
+    const lines = [];
+    const configTypes = [];
+    if (combinations.length === 0) {
+        const configName = `${nodeName}${versionSuffix}Params`;
+        lines.push(`export interface ${configName} {`);
+        const mergedProps = mergeCollectionProperties(node.properties);
+        for (const prop of mergedProps) {
+            const propLine = generatePropertyLine(prop, isPropertyOptional(prop));
+            if (propLine) {
+                lines.push(propLine);
+            }
+        }
+        lines.push('}');
+        configTypes.push({
+            typeName: configName,
+            discriminators: {},
+        });
+        return {
+            code: lines.join('\n'),
+            configTypes,
+        };
+    }
+    const configTypeNames = [];
+    for (const combo of combinations) {
+        const comboValues = Object.entries(combo)
+            .filter(([_, v]) => v !== undefined)
+            .map(([_, v]) => toPascalCase(v));
+        const configName = `${nodeName}${versionSuffix}${comboValues.join('')}Params`;
+        configTypeNames.push(configName);
+        const configInfo = {
+            typeName: configName,
+            resource: combo.resource,
+            operation: combo.operation,
+            discriminators: {},
+        };
+        for (const [key, value] of Object.entries(combo)) {
+            if (value !== undefined) {
+                configInfo.discriminators[key] = value;
+            }
+        }
+        configTypes.push(configInfo);
+        const props = getPropertiesForCombination(node, combo);
+        let description;
+        for (const [key, value] of Object.entries(combo)) {
+            if (value === undefined)
+                continue;
+            const discProp = node.properties.find((p) => p.name === key && p.options?.some((o) => o.value === value));
+            if (discProp) {
+                description = discProp.options?.find((o) => o.value === value)?.description;
+                if (description)
+                    break;
+            }
+        }
+        if (description) {
+            lines.push(`/** ${description} */`);
+        }
+        lines.push(`export type ${configName} = {`);
+        for (const [key, value] of Object.entries(combo)) {
+            if (value !== undefined) {
+                lines.push(`${INDENT}${key}: '${value}';`);
+            }
+        }
+        const seenNames = new Set();
+        for (const prop of props) {
+            if (seenNames.has(prop.name)) {
+                continue;
+            }
+            seenNames.add(prop.name);
+            const propLine = generatePropertyLine(prop, isPropertyOptional(prop), combo);
+            if (propLine) {
+                lines.push(propLine);
+            }
+        }
+        lines.push('};');
+        lines.push('');
+    }
+    return {
+        code: lines.join('\n'),
+        configTypes,
+    };
+}
+function generateIndexFile(nodes) {
+    const lines = [];
+    lines.push('/**');
+    lines.push(' * Generated Node Types');
+    lines.push(' *');
+    lines.push(' * This file is auto-generated by scripts/generate-types.ts');
+    lines.push(' * Do not edit manually.');
+    lines.push(' *');
+    lines.push(' * To regenerate:');
+    lines.push(' *   pnpm generate-types');
+    lines.push(' */');
+    lines.push('');
+    const byPackage = new Map();
+    for (const node of nodes) {
+        const pkg = getPackageName(node.name);
+        if (!byPackage.has(pkg)) {
+            byPackage.set(pkg, []);
+        }
+        byPackage.get(pkg).push(node);
+    }
+    lines.push('// Import node types for AllNodeTypes union');
+    const sortedNodes = [...nodes].sort((a, b) => a.name.localeCompare(b.name));
+    for (const [pkg, pkgNodes] of byPackage) {
+        const sortedPkgNodes = pkgNodes.sort((a, b) => a.name.localeCompare(b.name));
+        for (const node of sortedPkgNodes) {
+            const fileName = nodeNameToFileName(node.name);
+            const prefix = getPackagePrefix(node.name);
+            const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+            lines.push(`import type { ${nodeName}Node } from './nodes/${pkg}/${fileName}';`);
+        }
+    }
+    lines.push('');
+    for (const [pkg, pkgNodes] of byPackage) {
+        lines.push(`// ${pkg}`);
+        for (const node of pkgNodes.sort((a, b) => a.name.localeCompare(b.name))) {
+            const fileName = nodeNameToFileName(node.name);
+            lines.push(`export * from './nodes/${pkg}/${fileName}';`);
+        }
+        lines.push('');
+    }
+    lines.push('// Combined type union of node type strings');
+    lines.push('export type KnownNodeType =');
+    for (let i = 0; i < nodes.length; i++) {
+        lines.push(`${INDENT}| '${nodes[i].name}'`);
+    }
+    lines.push(`${INDENT};`);
+    lines.push('');
+    lines.push('// Union of all node input types for type-safe node() function');
+    lines.push('export type AllNodeTypes =');
+    for (let i = 0; i < sortedNodes.length; i++) {
+        const node = sortedNodes[i];
+        const prefix = getPackagePrefix(node.name);
+        const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
+        lines.push(`${INDENT}| ${nodeName}Node`);
+    }
+    lines.push(`${INDENT};`);
+    return lines.join('\n');
+}
+const AI_SUBNODE_TYPES = [
+    {
+        outputType: 'ai_languageModel',
+        unionTypeName: 'ValidLanguageModelType',
+        factoryName: 'languageModel',
+    },
+    { outputType: 'ai_memory', unionTypeName: 'ValidMemoryType', factoryName: 'memory' },
+    { outputType: 'ai_tool', unionTypeName: 'ValidToolType', factoryName: 'tool' },
+    {
+        outputType: 'ai_outputParser',
+        unionTypeName: 'ValidOutputParserType',
+        factoryName: 'outputParser',
+    },
+    { outputType: 'ai_embedding', unionTypeName: 'ValidEmbeddingType', factoryName: 'embedding' },
+    {
+        outputType: 'ai_vectorStore',
+        unionTypeName: 'ValidVectorStoreType',
+        factoryName: 'vectorStore',
+    },
+    { outputType: 'ai_retriever', unionTypeName: 'ValidRetrieverType', factoryName: 'retriever' },
+    {
+        outputType: 'ai_document',
+        unionTypeName: 'ValidDocumentLoaderType',
+        factoryName: 'documentLoader',
+    },
+    {
+        outputType: 'ai_textSplitter',
+        unionTypeName: 'ValidTextSplitterType',
+        factoryName: 'textSplitter',
+    },
+];
+function extractAIInputTypes(node) {
+    const inputs = node.inputs;
+    const aiTypes = new Map();
+    if (typeof inputs === 'string') {
+        const aiTypeRegex = /["']ai_(\w+)["']/g;
+        let match;
+        while ((match = aiTypeRegex.exec(inputs)) !== null) {
+            const aiType = `ai_${match[1]}`;
+            const requiredRegex = new RegExp(`\\{[^}]*type:\\s*["']${aiType}["'][^}]*required:\\s*true[^}]*\\}`, 'g');
+            const isRequired = requiredRegex.test(inputs);
+            if (!aiTypes.has(aiType) || isRequired) {
+                aiTypes.set(aiType, isRequired);
+            }
+        }
+        return [...aiTypes.entries()].map(([type, required]) => ({ type, required }));
+    }
+    if (!Array.isArray(inputs)) {
+        return [];
+    }
+    for (const input of inputs) {
+        let inputType;
+        let isRequired = false;
+        if (typeof input === 'string') {
+            inputType = input;
+        }
+        else if (typeof input === 'object' && input !== null && 'type' in input) {
+            inputType = input.type;
+            if ('required' in input && input.required === true) {
+                isRequired = true;
+            }
+        }
+        if (inputType?.startsWith('ai_')) {
+            const existingRequired = aiTypes.get(inputType) ?? false;
+            aiTypes.set(inputType, existingRequired || isRequired);
+        }
+    }
+    return [...aiTypes.entries()].map(([type, required]) => ({ type, required }));
+}
+function extractAIInputTypesFromBuilderHint(node, combo) {
+    const nodeWithBuilderHint = node;
+    const builderHint = nodeWithBuilderHint.builderHint;
+    if (!builderHint?.inputs) {
+        return extractAIInputTypes(node).map((input) => ({
+            ...input,
+            required: false,
+        }));
+    }
+    const result = [];
+    for (const [inputType, config] of Object.entries(builderHint.inputs)) {
+        if (!inputType.startsWith('ai_'))
+            continue;
+        if (combo && config.displayOptions?.show) {
+            let applies = true;
+            for (const [key, values] of Object.entries(config.displayOptions.show)) {
+                if (DISCRIMINATOR_FIELDS.includes(key) && combo[key]) {
+                    const comboValue = combo[key];
+                    if (!values.includes(comboValue)) {
+                        applies = false;
+                        break;
+                    }
+                }
+            }
+            if (!applies)
+                continue;
+        }
+        const isRequired = config.required === true;
+        const nonDiscriminatorOptions = getNonDiscriminatorDisplayOptions(config.displayOptions);
+        const aiInput = {
+            type: inputType,
+            required: isRequired,
+        };
+        if (nonDiscriminatorOptions) {
+            aiInput.displayOptions = nonDiscriminatorOptions;
+        }
+        result.push(aiInput);
+    }
+    return result;
+}
+function getNonDiscriminatorDisplayOptions(displayOptions) {
+    if (!displayOptions)
+        return undefined;
+    const result = {};
+    if (displayOptions.show) {
+        const filteredShow = {};
+        for (const [key, values] of Object.entries(displayOptions.show)) {
+            if (!DISCRIMINATOR_FIELDS.includes(key)) {
+                filteredShow[key] = values;
+            }
+        }
+        if (Object.keys(filteredShow).length > 0) {
+            result.show = filteredShow;
+        }
+    }
+    if (displayOptions.hide) {
+        const filteredHide = {};
+        for (const [key, values] of Object.entries(displayOptions.hide)) {
+            if (!DISCRIMINATOR_FIELDS.includes(key)) {
+                filteredHide[key] = values;
+            }
+        }
+        if (Object.keys(filteredHide).length > 0) {
+            result.hide = filteredHide;
+        }
+    }
+    if (!result.show && !result.hide) {
+        return undefined;
+    }
+    return result;
+}
+function formatSubnodeDisplayOptionsAsJSDoc(displayOptions) {
+    if (!displayOptions)
+        return undefined;
+    const parts = [];
+    if (displayOptions.show && Object.keys(displayOptions.show).length > 0) {
+        const showObj = Object.entries(displayOptions.show)
+            .map(([key, values]) => `${key}: ${JSON.stringify(values)}`)
+            .join(', ');
+        parts.push(`@displayOptions.show { ${showObj} }`);
+    }
+    if (displayOptions.hide && Object.keys(displayOptions.hide).length > 0) {
+        const hideObj = Object.entries(displayOptions.hide)
+            .map(([key, values]) => `${key}: ${JSON.stringify(values)}`)
+            .join(', ');
+        parts.push(`@displayOptions.hide { ${hideObj} }`);
+    }
+    return parts.length > 0 ? parts.join(`\n${INDENT} * `) : undefined;
+}
+function generateNarrowedSubnodeConfig(aiInputTypes, nodeName, versionSuffix, comboSuffix = '') {
+    if (aiInputTypes.length === 0) {
+        return null;
+    }
+    const lines = [];
+    const interfaceName = `${nodeName}${versionSuffix}${comboSuffix}SubnodeConfig`;
+    lines.push(`export interface ${interfaceName} {`);
+    for (const aiInput of aiInputTypes) {
+        const fieldInfo = AI_TYPE_TO_SUBNODE_FIELD[aiInput.type];
+        if (!fieldInfo) {
+            continue;
+        }
+        let typeStr;
+        if (fieldInfo.isArray) {
+            typeStr = `${fieldInfo.instanceType}[]`;
+        }
+        else if (fieldInfo.canBeMultiple) {
+            typeStr = `${fieldInfo.instanceType} | ${fieldInfo.instanceType}[]`;
+        }
+        else {
+            typeStr = fieldInfo.instanceType;
+        }
+        if (aiInput.displayOptions) {
+            const displayOptionsJSDoc = formatSubnodeDisplayOptionsAsJSDoc(aiInput.displayOptions);
+            if (displayOptionsJSDoc) {
+                lines.push(`${INDENT}/**`);
+                lines.push(`${INDENT} * ${displayOptionsJSDoc}`);
+                lines.push(`${INDENT} */`);
+            }
+        }
+        const optional = aiInput.required ? '' : '?';
+        lines.push(`${INDENT}${fieldInfo.fieldName}${optional}: ${typeStr};`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function getSubnodeInstanceTypeImports(aiInputTypes) {
+    const imports = [];
+    for (const aiInput of aiInputTypes) {
+        const fieldInfo = AI_TYPE_TO_SUBNODE_FIELD[aiInput.type];
+        if (fieldInfo && !imports.includes(fieldInfo.instanceType)) {
+            imports.push(fieldInfo.instanceType);
+        }
+    }
+    return imports;
+}
+function extractOutputTypes(node) {
+    const outputs = node.outputs;
+    if (!Array.isArray(outputs)) {
+        return [];
+    }
+    const outputTypes = [];
+    for (const output of outputs) {
+        if (typeof output === 'string') {
+            outputTypes.push(output);
+        }
+        else if (typeof output === 'object' && output !== null && 'type' in output) {
+            outputTypes.push(output.type);
+        }
+    }
+    return outputTypes;
+}
+function groupNodesByOutputType(nodes) {
+    const grouped = {};
+    for (const node of nodes) {
+        const outputTypes = extractOutputTypes(node);
+        for (const outputType of outputTypes) {
+            if (!grouped[outputType]) {
+                grouped[outputType] = [];
+            }
+            if (!grouped[outputType].includes(node.name)) {
+                grouped[outputType].push(node.name);
+            }
+        }
+    }
+    return grouped;
+}
+function generateSubnodeUnionTypes(nodes) {
+    const grouped = groupNodesByOutputType(nodes);
+    const lines = [];
+    for (const { outputType, unionTypeName, factoryName } of AI_SUBNODE_TYPES) {
+        const nodeNames = grouped[outputType] ?? [];
+        lines.push('/**');
+        lines.push(` * Union of all valid ${outputType.replace('ai_', '')} node types.`);
+        lines.push(` * Use with ${factoryName}() factory for type-safe subnode creation.`);
+        lines.push(' */');
+        if (nodeNames.length === 0) {
+            lines.push(`export type ${unionTypeName} = never;`);
+        }
+        else {
+            lines.push(`export type ${unionTypeName} =`);
+            for (let i = 0; i < nodeNames.length; i++) {
+                lines.push(`${INDENT}| '${nodeNames[i]}'`);
+            }
+            lines.push(`${INDENT};`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function generateSubnodesFile(nodes) {
+    const lines = [];
+    lines.push('/**');
+    lines.push(' * Generated Subnode Union Types');
+    lines.push(' *');
+    lines.push(' * This file is auto-generated by scripts/generate-types.ts');
+    lines.push(' * Do not edit manually.');
+    lines.push(' *');
+    lines.push(' * These union types define valid node types for each subnode category.');
+    lines.push(' * Use with the corresponding factory functions for type-safe subnode creation.');
+    lines.push(' */');
+    lines.push('');
+    lines.push(generateSubnodeUnionTypes(nodes));
+    return lines.join('\n');
+}
+function getSubnodeOutputType(node) {
+    const outputTypes = extractOutputTypes(node);
+    for (const outputType of outputTypes) {
+        if (AI_SUBNODE_TYPES.some((t) => t.outputType === outputType)) {
+            return outputType;
+        }
+    }
+    return undefined;
+}
+async function loadNodeTypes(jsonPath, packageName) {
+    const content = await fs.promises.readFile(jsonPath, 'utf-8');
+    let nodes;
+    try {
+        nodes = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse node types from ${jsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (packageName) {
+        for (const node of nodes) {
+            if (!node.name.includes('.')) {
+                node.name = `${packageName}.${node.name}`;
+            }
+        }
+    }
+    return nodes;
+}
+function convertNodeToToolVariant(node) {
+    if (!node.usableAsTool) {
+        return null;
+    }
+    const toolNode = (0, n8n_workflow_1.deepCopy)(node);
+    toolNode.name = toolNode.name + 'Tool';
+    toolNode.displayName = toolNode.displayName + ' Tool';
+    toolNode.outputs = [{ type: 'ai_tool', displayName: 'Tool' }];
+    toolNode.inputs = [];
+    delete toolNode.usableAsTool;
+    const hasToolDescription = toolNode.properties.some((p) => p.name === 'toolDescription');
+    if (!hasToolDescription) {
+        const hasResource = toolNode.properties.some((p) => p.name === 'resource');
+        const hasOperation = toolNode.properties.some((p) => p.name === 'operation');
+        const toolDescriptionProp = {
+            displayName: 'Description',
+            name: 'toolDescription',
+            type: 'string',
+            default: toolNode.description ?? '',
+            required: true,
+            description: 'Explain to the LLM what this tool does, a good, specific description would allow LLMs to produce expected results much more often',
+        };
+        if (hasResource || hasOperation) {
+            const descriptionTypeProp = {
+                displayName: 'Tool Description',
+                name: 'descriptionType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Set Automatically',
+                        value: 'auto',
+                        description: 'Automatically set based on resource and operation',
+                    },
+                    {
+                        name: 'Set Manually',
+                        value: 'manual',
+                        description: 'Manually set the description',
+                    },
+                ],
+                default: 'auto',
+            };
+            toolDescriptionProp.displayOptions = {
+                show: {
+                    descriptionType: ['manual'],
+                },
+            };
+            const firstNonNoticeIdx = toolNode.properties.findIndex((p) => p.type !== 'notice');
+            const insertIdx = firstNonNoticeIdx >= 0 ? firstNonNoticeIdx : 0;
+            toolNode.properties.splice(insertIdx, 0, descriptionTypeProp, toolDescriptionProp);
+        }
+        else {
+            const firstNonNoticeIdx = toolNode.properties.findIndex((p) => p.type !== 'notice');
+            const insertIdx = firstNonNoticeIdx >= 0 ? firstNonNoticeIdx : 0;
+            toolNode.properties.splice(insertIdx, 0, toolDescriptionProp);
+        }
+    }
+    return toolNode;
+}
+const WRITE_BATCH_SIZE = 100;
+async function writeFilesInBatches(files) {
+    for (let i = 0; i < files.length; i += WRITE_BATCH_SIZE) {
+        const batch = files.slice(i, i + WRITE_BATCH_SIZE);
+        await Promise.all(batch.map((f) => fs.promises.writeFile(f.path, f.content)));
+    }
+}
+async function generateVersionSpecificFiles(packageDir, _packageName, nodesByName) {
+    const allNodes = [];
+    const allDirs = new Set();
+    const allWrites = [];
+    const splitPlans = [];
+    for (const [nodeName, nodes] of nodesByName) {
+        try {
+            const nodeDir = path.join(packageDir, nodeName);
+            const nodeWrites = [];
+            const nodeDirs = new Set([nodeDir]);
+            const nodeSplitPlans = [];
+            const versionToNode = new Map();
+            const allVersions = [];
+            const splitVersionsSet = new Set();
+            for (const node of nodes) {
+                const versions = Array.isArray(node.version) ? node.version : [node.version];
+                for (const version of versions) {
+                    if (!versionToNode.has(version)) {
+                        versionToNode.set(version, node);
+                        allVersions.push(version);
+                    }
+                }
+            }
+            for (const version of allVersions) {
+                const sourceNode = versionToNode.get(version);
+                const fileName = versionToFileName(version);
+                if (hasDiscriminatorPattern(sourceNode)) {
+                    const versionDir = path.join(nodeDir, fileName);
+                    const plan = planSplitVersionFiles(sourceNode, version);
+                    nodeSplitPlans.push({ baseDir: versionDir, plan });
+                    splitVersionsSet.add(version);
+                }
+                else {
+                    const content = generateSingleVersionTypeFile(sourceNode, version);
+                    nodeWrites.push({ path: path.join(nodeDir, `${fileName}.ts`), content });
+                    const schemaContent = (0, generate_zod_schemas_1.generateSingleVersionSchemaFile)(sourceNode, version);
+                    nodeWrites.push({
+                        path: path.join(nodeDir, `${fileName}.schema.js`),
+                        content: schemaContent,
+                    });
+                }
+            }
+            const indexContent = generateVersionIndexFile(nodes[0], allVersions, splitVersionsSet);
+            nodeWrites.push({ path: path.join(nodeDir, 'index.ts'), content: indexContent });
+            allWrites.push(...nodeWrites);
+            for (const d of nodeDirs)
+                allDirs.add(d);
+            splitPlans.push(...nodeSplitPlans);
+            allNodes.push(nodes[0]);
+        }
+        catch (error) {
+            console.error(`  Error generating ${nodeName}:`, error);
+        }
+    }
+    for (const { baseDir, plan } of splitPlans) {
+        for (const [relativePath, content] of plan) {
+            const fullPath = path.join(baseDir, relativePath);
+            allDirs.add(path.dirname(fullPath));
+            allWrites.push({ path: fullPath, content });
+        }
+    }
+    await Promise.all([...allDirs].map((d) => fs.promises.mkdir(d, { recursive: true })));
+    await writeFilesInBatches(allWrites);
+    return allNodes;
+}
+async function orchestrateGeneration(options) {
+    const { nodes, outputDir } = options;
+    const nodesByPackage = new Map();
+    for (const node of nodes) {
+        if (node.hidden)
+            continue;
+        const packageName = getPackageName(node.name);
+        const fileName = nodeNameToFileName(node.name);
+        if (!nodesByPackage.has(packageName)) {
+            nodesByPackage.set(packageName, new Map());
+        }
+        const packageNodes = nodesByPackage.get(packageName);
+        if (!packageNodes.has(fileName)) {
+            packageNodes.set(fileName, []);
+        }
+        packageNodes.get(fileName).push(node);
+    }
+    const allNodes = [];
+    for (const [packageName, nodesByName] of nodesByPackage) {
+        const packageDir = path.join(outputDir, 'nodes', packageName);
+        await fs.promises.rm(packageDir, { recursive: true, force: true });
+        const packageNodes = await generateVersionSpecificFiles(packageDir, packageName, nodesByName);
+        allNodes.push(...packageNodes);
+    }
+    if (allNodes.length > 0) {
+        const indexContent = generateIndexFile(allNodes);
+        await fs.promises.writeFile(path.join(outputDir, 'index.ts'), indexContent);
+    }
+    return { nodeCount: allNodes.length };
+}
+async function generateTypes() {
+    console.log('Starting type generation...');
+    const allNodes = [];
+    if (fs.existsSync(NODES_BASE_TYPES)) {
+        console.log(`Loading nodes from ${NODES_BASE_TYPES}...`);
+        const nodesBase = await loadNodeTypes(NODES_BASE_TYPES, 'n8n-nodes-base');
+        console.log(`  Found ${nodesBase.length} node entries in nodes-base`);
+        allNodes.push(...groupAndAddToolVariants(nodesBase));
+    }
+    else {
+        console.log(`Warning: ${NODES_BASE_TYPES} not found. Run 'pnpm build' in nodes-base first.`);
+    }
+    if (fs.existsSync(NODES_LANGCHAIN_TYPES)) {
+        console.log(`Loading nodes from ${NODES_LANGCHAIN_TYPES}...`);
+        const nodesLangchain = await loadNodeTypes(NODES_LANGCHAIN_TYPES, '@n8n/n8n-nodes-langchain');
+        console.log(`  Found ${nodesLangchain.length} node entries in nodes-langchain`);
+        allNodes.push(...groupAndAddToolVariants(nodesLangchain));
+    }
+    else {
+        console.log(`Warning: ${NODES_LANGCHAIN_TYPES} not found. Run 'pnpm build' in nodes-langchain first.`);
+    }
+    const result = await orchestrateGeneration({ nodes: allNodes, outputDir: DEV_OUTPUT_PATH });
+    if (result.nodeCount === 0) {
+        const placeholderContent = `/**
+ * Generated Node Types
+ *
+ * This file is auto-generated by scripts/generate-types.ts
+ * Do not edit manually.
+ *
+ * No nodes were found. Run 'pnpm build' in nodes-base and nodes-langchain first.
+ *
+ * @generated
+ */
+
+export {};
+`;
+        await fs.promises.writeFile(path.join(DEV_OUTPUT_PATH, 'index.ts'), placeholderContent);
+        console.log('Generated placeholder index.ts (no nodes found)');
+    }
+    else {
+        console.log(`Generated definitions for ${result.nodeCount} nodes`);
+    }
+    console.log('Type generation complete!');
+}
+function groupAndAddToolVariants(nodes) {
+    const result = [];
+    for (const node of nodes) {
+        if (node.hidden)
+            continue;
+        result.push(node);
+        const toolVariant = convertNodeToToolVariant(node);
+        if (toolVariant) {
+            result.push(toolVariant);
+        }
+    }
+    return result;
+}
+if (require.main === module) {
+    generateTypes().catch((error) => {
+        console.error('Type generation failed:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=generate-types.js.map