@pikku/openapi-parser 0.12.8 → 0.12.10

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { parseOpenAPISpec, computeContractHash, type ParsedSpec, type ParsedOperation, type ParsedParam, type ErrorResponse, type SecuritySchemeInfo, } from './parse-openapi.js';
-export { generateAddonFromOpenAPI, } from './codegen.js';
+export { generateAddonFromOpenAPI } from './codegen.js';
 export { generateOperationNames, detectCommonPrefix, type NamedOperation, } from './naming.js';
-export { type OpenAPISchema, type ZodCodegenContext, createContext, schemaToZod, schemaVarName, sanitizeTypeName, } from './openapi-to-zod-schema.js';
+export { type OpenAPISchema, type ZodCodegenContext, createContext, schemaToZod, schemaVarName, sanitizeTypeName, snakeToCamel, } from './openapi-to-zod-schema.js';

package/dist/index.js

@@ -1,4 +1,4 @@
 export { parseOpenAPISpec, computeContractHash, } from './parse-openapi.js';
-export { generateAddonFromOpenAPI, } from './codegen.js';
+export { generateAddonFromOpenAPI } from './codegen.js';
 export { generateOperationNames, detectCommonPrefix, } from './naming.js';
-export { createContext, schemaToZod, schemaVarName, sanitizeTypeName, } from './openapi-to-zod-schema.js';
+export { createContext, schemaToZod, schemaVarName, sanitizeTypeName, snakeToCamel, } from './openapi-to-zod-schema.js';

package/dist/naming.d.ts

@@ -2,6 +2,13 @@
  * Derives function/method names from HTTP method + path.
  * Uses operationId when available, otherwise generates from path segments.
  */
+/**
+ * Ensure a name is a valid JS/TS identifier:
+ * - Not a reserved word
+ * - Does not start with a digit
+ * - Does not contain numeric separator patterns (e.g. 1_000)
+ */
+export declare function sanitizeIdentifier(name: string): string;
 export declare function singularize(word: string): string;
 export declare function toCamelCase(str: string): string;
 export declare function toPascalCase(str: string): string;

package/dist/naming.js

@@ -2,6 +2,112 @@
  * Derives function/method names from HTTP method + path.
  * Uses operationId when available, otherwise generates from path segments.
  */
+/** JavaScript/TypeScript reserved words that cannot be used as identifiers */
+const JS_RESERVED_WORDS = new Set([
+    // ECMAScript reserved words
+    'abstract',
+    'arguments',
+    'await',
+    'boolean',
+    'break',
+    'byte',
+    'case',
+    'catch',
+    'char',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'double',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'final',
+    'finally',
+    'float',
+    'for',
+    'function',
+    'goto',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'int',
+    'interface',
+    'let',
+    'long',
+    'native',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'short',
+    'static',
+    'super',
+    'switch',
+    'synchronized',
+    'this',
+    'throw',
+    'throws',
+    'transient',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'volatile',
+    'while',
+    'with',
+    'yield',
+    // TypeScript additional reserved words in strict mode
+    'as',
+    'any',
+    'declare',
+    'get',
+    'module',
+    'require',
+    'number',
+    'object',
+    'set',
+    'string',
+    'symbol',
+    'type',
+    'from',
+    'of',
+]);
+/**
+ * Ensure a name is a valid JS/TS identifier:
+ * - Not a reserved word
+ * - Does not start with a digit
+ * - Does not contain numeric separator patterns (e.g. 1_000)
+ */
+export function sanitizeIdentifier(name) {
+    // Strip numeric separator patterns like 1_000 → 1000
+    name = name.replace(/(\d)_(\d)/g, '$1$2');
+    // Strip any remaining invalid characters
+    name = name.replace(/[^a-zA-Z0-9_$]/g, '');
+    // Prefix with 'n' if name starts with a digit (not underscore, since
+    // pikku inspector may strip leading underscores from type names)
+    if (/^[0-9]/.test(name)) {
+        name = 'n' + name;
+    }
+    // Prefix with underscore if name is a reserved word
+    if (JS_RESERVED_WORDS.has(name)) {
+        name = '_' + name;
+    }
+    return name || 'unnamed';
+}
 const IRREGULAR_PLURALS = {
     addresses: 'address',
     statuses: 'status',
@@ -25,11 +131,18 @@ export function singularize(word) {
         return word.slice(0, -3) + 'y';
     }
     // -shes, -ches, -xes, -zes, -sses → drop "es"
-    if (lower.endsWith('shes') || lower.endsWith('ches') || lower.endsWith('xes') || lower.endsWith('zes') || lower.endsWith('sses')) {
+    if (lower.endsWith('shes') ||
+        lower.endsWith('ches') ||
+        lower.endsWith('xes') ||
+        lower.endsWith('zes') ||
+        lower.endsWith('sses')) {
         return word.slice(0, -2);
     }
     // General: drop trailing "s" (covers courses→course, products→product, etc.)
-    if (lower.endsWith('s') && !lower.endsWith('ss') && !lower.endsWith('us') && lower.length > 2) {
+    if (lower.endsWith('s') &&
+        !lower.endsWith('ss') &&
+        !lower.endsWith('us') &&
+        lower.length > 2) {
         return word.slice(0, -1);
     }
     return word;
@@ -37,6 +150,7 @@ export function singularize(word) {
 export function toCamelCase(str) {
     return str
         .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
+        .replace(/[^a-zA-Z0-9]+$/g, '') // strip trailing non-alphanumeric chars
         .replace(/^[A-Z]/, (c) => c.toLowerCase());
 }
 export function toPascalCase(str) {
@@ -75,10 +189,12 @@ export function detectCommonPrefix(paths) {
 /** Convert operationId to camelCase function name */
 function fromOperationId(operationId) {
     // operationId might be snake_case, camelCase, PascalCase, or kebab-case
-    return toCamelCase(operationId
+    let name = toCamelCase(operationId
+        .replace(/[{}]/g, '') // strip curly braces from path parameters
         .replace(/[^a-zA-Z0-9_-]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_|_$/g, ''));
+        .replace(/[-_]+/g, '_')
+        .replace(/^_|_$/g, '')) || 'unnamed';
+    return sanitizeIdentifier(name);
 }
 const METHOD_PREFIXES = {
     get: 'get',
@@ -94,6 +210,11 @@ const METHOD_PREFIXES = {
 export function generateOperationNames(operations, commonPrefix) {
     const results = [];
     const usedNames = new Map();
+    // Track names case-insensitively to prevent file system collisions on
+    // case-insensitive systems (macOS, Windows). Two operationIds that differ
+    // only in casing (e.g. userGetOauth2Application vs userGetOAuth2Application)
+    // would produce files that collide on disk.
+    const usedNamesLower = new Map();
     for (const op of operations) {
         let name;
         if (op.operationId) {
@@ -102,13 +223,20 @@ export function generateOperationNames(operations, commonPrefix) {
         else {
             name = deriveNameFromPath(op.method, op.path, commonPrefix);
         }
-        // Handle collisions
-        const existing = usedNames.get(name) ?? 0;
+        // Ensure name is a valid JS/TS identifier
+        name = sanitizeIdentifier(name);
+        // Handle collisions (case-insensitive to avoid file system conflicts)
+        const nameLower = name.toLowerCase();
+        const existingExact = usedNames.get(name) ?? 0;
+        const existingCI = usedNamesLower.get(nameLower) ?? 0;
+        const existing = Math.max(existingExact, existingCI);
         if (existing > 0) {
             usedNames.set(name, existing + 1);
+            usedNamesLower.set(nameLower, existing + 1);
             name = `${name}${existing + 1}`;
         }
         usedNames.set(name, (usedNames.get(name) ?? 0) || 1);
+        usedNamesLower.set(name.toLowerCase(), (usedNamesLower.get(name.toLowerCase()) ?? 0) || 1);
         results.push({
             method: op.method,
             path: op.path,
@@ -124,10 +252,7 @@ function deriveNameFromPath(method, path, commonPrefix) {
     if (commonPrefix && cleanPath.startsWith(commonPrefix)) {
         cleanPath = '/' + cleanPath.slice(commonPrefix.length);
     }
-    const segments = cleanPath
-        .replace(/^\//, '')
-        .split('/')
-        .filter(Boolean);
+    const segments = cleanPath.replace(/^\//, '').split('/').filter(Boolean);
     const methodLower = method.toLowerCase();
     const prefix = METHOD_PREFIXES[methodLower] || methodLower;
     // Separate param and non-param segments

package/dist/openapi-to-zod-schema.d.ts

@@ -15,8 +15,8 @@ export interface OpenAPISchema {
     default?: unknown;
     minimum?: number;
     maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
     minLength?: number;
     maxLength?: number;
     pattern?: string;
@@ -37,8 +37,25 @@ export interface ZodCodegenContext {
     usedRefs: Set<string>;
     /** Indent level for readability */
     indent: number;
+    /** Track schemas currently being processed to detect cycles */
+    seen: Set<OpenAPISchema>;
+    /**
+     * Map from resolved schema object identity to its component name.
+     * After $ref resolution, many references lose their $ref string and
+     * become the same JS object as the component schema. This map lets
+     * schemaToZod detect those resolved references by identity.
+     */
+    schemaIdentityMap: Map<object, string>;
+    /** Current nesting depth for preventing excessively deep types */
+    depth: number;
+    /** When true, convert snake_case property keys to camelCase in z.object() */
+    camelCase?: boolean;
 }
-export declare function createContext(schemaRefs?: Map<string, string>): ZodCodegenContext;
+export declare function createContext(schemaRefs?: Map<string, string>, schemaIdentityMap?: Map<object, string>, opts?: {
+    camelCase?: boolean;
+}): ZodCodegenContext;
+/** Convert a snake_case or kebab-case string to camelCase */
+export declare function snakeToCamel(s: string): string;
 /**
  * Convert a single OpenAPI schema to a Zod expression string.
  * Does NOT include .optional() — that's handled at the property level based on `required`.
@@ -46,9 +63,5 @@ export declare function createContext(schemaRefs?: Map<string, string>): ZodCode
 export declare function schemaToZod(schema: OpenAPISchema, ctx: ZodCodegenContext, opts?: {
     optional?: boolean;
 }): string;
-/**
- * Generate the Zod variable name for a component schema.
- * e.g. "PaginatedResponse" → "PaginatedResponseSchema"
- */
 export declare function sanitizeTypeName(name: string): string;
 export declare function schemaVarName(name: string): string;

package/dist/openapi-to-zod-schema.js

@@ -3,18 +3,39 @@
  *
  * Chaining order: base → refinements → .nullable() → .optional() → .default() → .describe()
  */
-export function createContext(schemaRefs) {
+export function createContext(schemaRefs, schemaIdentityMap, opts) {
     return {
         schemaRefs: schemaRefs ?? new Map(),
         usedRefs: new Set(),
         indent: 0,
+        seen: new Set(),
+        schemaIdentityMap: schemaIdentityMap ?? new Map(),
+        depth: 0,
+        camelCase: opts?.camelCase,
     };
 }
+/** Convert a snake_case or kebab-case string to camelCase */
+export function snakeToCamel(s) {
+    return s.replace(/[-_]+(.)/g, (_, c) => c.toUpperCase());
+}
 /**
  * Convert a single OpenAPI schema to a Zod expression string.
  * Does NOT include .optional() — that's handled at the property level based on `required`.
  */
 export function schemaToZod(schema, ctx, opts = {}) {
+    // Bug 5: Depth limit to prevent TS2589 "excessively deep" type errors
+    if (ctx.depth > 10) {
+        let code = 'z.any()';
+        if (schema.nullable)
+            code += '.nullable()';
+        if (opts.optional)
+            code += '.optional()';
+        if (schema.description) {
+            const safeDesc = schema.description.replace(/\*\//g, '* /');
+            code += `.describe(${JSON.stringify(safeDesc)})`;
+        }
+        return code;
+    }
     let code = schemaToZodBase(schema, ctx);
     // Refinements
     code = applyRefinements(code, schema);
@@ -26,18 +47,105 @@ export function schemaToZod(schema, ctx, opts = {}) {
     if (opts.optional) {
         code += '.optional()';
     }
-    // Default
+    // Default — validate type compatibility and coerce mismatches
     if (schema.default !== undefined) {
-        code += `.default(${JSON.stringify(schema.default)})`;
+        let defaultValue = schema.default;
+        if (schema.enum && schema.enum.length > 0) {
+            // For enum schemas, the default must exactly match one of the enum values.
+            // Don't apply type coercion — the Zod schema uses the original enum types
+            // (e.g. z.literal(1) not z.literal("1")), so coercing would cause TS2769.
+            const enumValues = new Set(schema.enum.map((v) => JSON.stringify(v)));
+            if (enumValues.has(JSON.stringify(defaultValue))) {
+                code += `.default(${JSON.stringify(defaultValue)})`;
+            }
+            // else: default not in enum — skip it entirely
+        }
+        else if (defaultValue === null && !schema.nullable) {
+            // skip null defaults unless nullable
+        }
+        else if (schema.type === 'object' && typeof defaultValue === 'string') {
+            // skip string defaults on object types (often a stray description)
+        }
+        else if (schema.properties &&
+            typeof defaultValue === 'object' &&
+            defaultValue !== null &&
+            !Array.isArray(defaultValue)) {
+            // For object schemas with properties, validate default keys match schema properties.
+            // Extra keys in the default cause TS2769 because z.object() rejects unknown keys.
+            const schemaKeys = new Set(Object.keys(schema.properties));
+            const defaultKeys = Object.keys(defaultValue);
+            const hasExtraKeys = defaultKeys.some((k) => !schemaKeys.has(k));
+            if (!hasExtraKeys) {
+                code += `.default(${JSON.stringify(defaultValue)})`;
+            }
+            // else: default has keys not in schema — skip it
+        }
+        else if (schema.type === 'string' &&
+            typeof defaultValue === 'object' &&
+            defaultValue !== null) {
+            // skip object/array defaults on string types
+        }
+        else if ((!schema.type || schema.type === 'object') &&
+            schema.properties &&
+            typeof defaultValue === 'string') {
+            // skip string defaults on implicit object types (has properties but no explicit type)
+        }
+        else if (schema.type === 'array' && !Array.isArray(defaultValue)) {
+            // skip type-mismatched defaults (non-array default on array type)
+        }
+        else if (schema.type !== 'array' && Array.isArray(defaultValue)) {
+            // skip array defaults on non-array types
+        }
+        else if (schema.type === 'boolean' && typeof defaultValue === 'string') {
+            defaultValue = defaultValue === 'true';
+            code += `.default(${JSON.stringify(defaultValue)})`;
+        }
+        else if ((schema.type === 'number' || schema.type === 'integer') &&
+            typeof defaultValue === 'string') {
+            const parsed = Number(defaultValue);
+            if (!isNaN(parsed))
+                code += `.default(${JSON.stringify(parsed)})`;
+        }
+        else if (schema.type === 'string' && typeof defaultValue === 'number') {
+            code += `.default(${JSON.stringify(String(defaultValue))})`;
+        }
+        else if (schema.type === 'string' && typeof defaultValue === 'boolean') {
+            code += `.default(${JSON.stringify(String(defaultValue))})`;
+        }
+        else if (schema.type === 'boolean' && typeof defaultValue !== 'boolean') {
+            code += `.default(${defaultValue === 'true' || defaultValue === 1})`;
+        }
+        else if ((schema.type === 'number' || schema.type === 'integer') &&
+            typeof defaultValue === 'boolean') {
+            code += `.default(${defaultValue ? 1 : 0})`;
+        }
+        else {
+            code += `.default(${JSON.stringify(defaultValue)})`;
+        }
     }
-    // Description
+    // Description — sanitize */ to prevent breaking JSDoc comments downstream
     if (schema.description) {
-        code += `.describe(${JSON.stringify(schema.description)})`;
+        const safeDesc = schema.description.replace(/\*\//g, '* /');
+        code += `.describe(${JSON.stringify(safeDesc)})`;
     }
     return code;
 }
 function schemaToZodBase(schema, ctx) {
-    // Handle $ref
+    // Cycle detection: if we've already started processing this exact schema
+    // object, return z.any() to break infinite recursion
+    if (ctx.seen.has(schema)) {
+        return 'z.any()';
+    }
+    ctx.seen.add(schema);
+    try {
+        return schemaToZodBaseInner(schema, ctx);
+    }
+    finally {
+        ctx.seen.delete(schema);
+    }
+}
+function schemaToZodBaseInner(schema, ctx) {
+    // Handle $ref (surviving after resolution)
     if (schema.$ref) {
         const refName = schema.$ref.split('/').pop();
         const zodName = ctx.schemaRefs.get(refName);
@@ -48,6 +156,18 @@ function schemaToZodBase(schema, ctx) {
         // Unknown ref — fallback to z.unknown()
         return 'z.unknown()';
     }
+    // Handle resolved $ref by object identity: if this schema object IS a
+    // known component schema, reference the variable instead of inlining.
+    if (ctx.schemaIdentityMap.size > 0) {
+        const identityName = ctx.schemaIdentityMap.get(schema);
+        if (identityName) {
+            const zodName = ctx.schemaRefs.get(identityName);
+            if (zodName) {
+                ctx.usedRefs.add(identityName);
+                return zodName;
+            }
+        }
+    }
     // Handle allOf — merge into single object
     if (schema.allOf && schema.allOf.length > 0) {
         return handleAllOf(schema.allOf, ctx);
@@ -82,6 +202,13 @@ function schemaToZodBase(schema, ctx) {
             if (schema.properties) {
                 return handleObject(schema, ctx);
             }
+            // Bug 4: Infer number type when minimum/maximum present but no type
+            if (schema.minimum !== undefined ||
+                schema.maximum !== undefined ||
+                schema.exclusiveMinimum !== undefined ||
+                schema.exclusiveMaximum !== undefined) {
+                return 'z.number()';
+            }
             return 'z.unknown()';
     }
 }
@@ -103,24 +230,28 @@ function handleString(schema) {
     }
 }
 function handleEnum(values) {
-    // Single value — use z.literal
-    if (values.length === 1) {
-        return `z.literal(${JSON.stringify(values[0])})`;
+    const primitives = values.filter((v) => v === null ||
+        typeof v === 'string' ||
+        typeof v === 'number' ||
+        typeof v === 'boolean');
+    if (primitives.length === 0)
+        return 'z.unknown()';
+    if (primitives.length === 1) {
+        return `z.literal(${JSON.stringify(primitives[0])})`;
     }
-    // If all values are strings, use z.enum
-    if (values.every((v) => typeof v === 'string')) {
-        const enumValues = values.map((v) => JSON.stringify(v)).join(', ');
+    if (primitives.every((v) => typeof v === 'string')) {
+        const enumValues = primitives.map((v) => JSON.stringify(v)).join(', ');
         return `z.enum([${enumValues}])`;
     }
-    // Mixed types — use z.union of z.literal
-    const literals = values
+    const literals = primitives
         .map((v) => `z.literal(${JSON.stringify(v)})`)
         .join(', ');
     return `z.union([${literals}])`;
 }
 function handleArray(schema, ctx) {
+    const innerCtx = { ...ctx, depth: ctx.depth + 1 };
     const itemsZod = schema.items
-        ? schemaToZodBase(schema.items, ctx)
+        ? schemaToZodBase(schema.items, innerCtx)
         : 'z.unknown()';
     return `z.array(${itemsZod})`;
 }
@@ -138,7 +269,11 @@ function handleObject(schema, ctx) {
         }
         return 'z.record(z.string(), z.unknown())';
     }
-    const inner = { ...ctx, indent: ctx.indent + 1 };
+    const inner = {
+        ...ctx,
+        indent: ctx.indent + 1,
+        depth: ctx.depth + 1,
+    };
     const pad = indent(inner);
     const closePad = indent(ctx);
     const requiredSet = new Set(schema.required ?? []);
@@ -146,22 +281,34 @@ function handleObject(schema, ctx) {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
         const isOptional = !requiredSet.has(key);
         const propZod = schemaToZod(propSchema, inner, { optional: isOptional });
-        entries.push(`${pad}${safeKey(key)}: ${propZod},`);
+        const outputKey = ctx.camelCase ? snakeToCamel(key) : key;
+        entries.push(`${pad}${safeKey(outputKey)}: ${propZod},`);
     }
     return `z.object({\n${entries.join('\n')}\n${closePad}})`;
 }
 function handleAllOf(schemas, ctx) {
+    // Helper to check if a sub-schema is a reference (by $ref or identity map)
+    function getRefName(sub) {
+        if (sub.$ref) {
+            return sub.$ref.split('/').pop();
+        }
+        if (ctx.schemaIdentityMap.size > 0) {
+            const identityName = ctx.schemaIdentityMap.get(sub);
+            if (identityName && ctx.schemaRefs.has(identityName)) {
+                return identityName;
+            }
+        }
+        return undefined;
+    }
     // Collect all properties from all schemas
     const mergedProps = {};
     const mergedRequired = [];
     for (const sub of schemas) {
-        if (sub.$ref) {
-            const refName = sub.$ref.split('/').pop();
+        const refName = getRefName(sub);
+        if (refName) {
             const zodName = ctx.schemaRefs.get(refName);
             if (zodName) {
                 ctx.usedRefs.add(refName);
-                // If it's a pure ref in an allOf, we'd need to merge/extend
-                // For simplicity, if we have refs mixed with objects, use .merge()
             }
         }
         if (sub.properties) {
@@ -172,11 +319,11 @@ function handleAllOf(schemas, ctx) {
         }
     }
     // If we have only refs, use .merge()
-    const refSchemas = schemas.filter((s) => s.$ref);
-    const objSchemas = schemas.filter((s) => !s.$ref && (s.properties || s.type === 'object'));
+    const refSchemas = schemas.filter((s) => getRefName(s) !== undefined);
+    const objSchemas = schemas.filter((s) => getRefName(s) === undefined && (s.properties || s.type === 'object'));
     if (refSchemas.length > 0 && objSchemas.length === 0) {
         const parts = refSchemas.map((s) => {
-            const refName = s.$ref.split('/').pop();
+            const refName = getRefName(s);
             ctx.usedRefs.add(refName);
             return ctx.schemaRefs.get(refName) || 'z.object({})';
         });
@@ -202,9 +349,23 @@ function handleUnion(schemas, ctx) {
     return `z.union([${members.join(', ')}])`;
 }
 function applyRefinements(code, schema) {
+    // Don't apply refinements to types that don't support .min()/.max()/.regex() etc.
+    // This includes z.any(), z.unknown(), z.union(...), z.literal(...), z.enum(...),
+    // z.lazy(...), z.record(...), and schema references (variable names without z. prefix).
+    if (code === 'z.any()' ||
+        code === 'z.unknown()' ||
+        code.startsWith('z.union(') ||
+        code.startsWith('z.literal(') ||
+        code.startsWith('z.enum(') ||
+        code.startsWith('z.lazy(') ||
+        code.startsWith('z.record(') ||
+        // Schema variable references (e.g. FooSchema) — no z. prefix
+        (!code.startsWith('z.') && /^[a-zA-Z_$]/.test(code))) {
+        return code;
+    }
     let result = code;
-    // String refinements
-    if (schema.type === 'string' || (!schema.type && !schema.format)) {
+    // String refinements — only apply to explicit string types
+    if (schema.type === 'string' && !schema.enum) {
         if (schema.minLength !== undefined) {
             result += `.min(${schema.minLength})`;
         }
@@ -215,18 +376,38 @@ function applyRefinements(code, schema) {
             result += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
         }
     }
-    // Number refinements
-    if (schema.type === 'number' || schema.type === 'integer') {
+    // Number refinements — also apply when no type but min/max present (inferred number)
+    const isNumberType = schema.type === 'number' ||
+        schema.type === 'integer' ||
+        (!schema.type &&
+            !schema.properties &&
+            (schema.minimum !== undefined ||
+                schema.maximum !== undefined ||
+                schema.exclusiveMinimum !== undefined ||
+                schema.exclusiveMaximum !== undefined));
+    if (isNumberType && !schema.enum) {
+        const exMinIsBoolean = typeof schema.exclusiveMinimum === 'boolean';
+        const exMaxIsBoolean = typeof schema.exclusiveMaximum === 'boolean';
         if (schema.minimum !== undefined) {
-            result += `.min(${schema.minimum})`;
+            if (exMinIsBoolean && schema.exclusiveMinimum) {
+                result += `.gt(${schema.minimum})`;
+            }
+            else {
+                result += `.min(${schema.minimum})`;
+            }
         }
         if (schema.maximum !== undefined) {
-            result += `.max(${schema.maximum})`;
+            if (exMaxIsBoolean && schema.exclusiveMaximum) {
+                result += `.lt(${schema.maximum})`;
+            }
+            else {
+                result += `.max(${schema.maximum})`;
+            }
         }
-        if (schema.exclusiveMinimum !== undefined) {
+        if (!exMinIsBoolean && schema.exclusiveMinimum !== undefined) {
             result += `.gt(${schema.exclusiveMinimum})`;
         }
-        if (schema.exclusiveMaximum !== undefined) {
+        if (!exMaxIsBoolean && schema.exclusiveMaximum !== undefined) {
             result += `.lt(${schema.exclusiveMaximum})`;
         }
     }
@@ -252,8 +433,39 @@ function safeKey(key) {
  * Generate the Zod variable name for a component schema.
  * e.g. "PaginatedResponse" → "PaginatedResponseSchema"
  */
+const RESERVED_TYPE_NAMES = new Set([
+    'object',
+    'string',
+    'number',
+    'boolean',
+    'symbol',
+    'undefined',
+    'null',
+    'void',
+    'never',
+    'any',
+    'unknown',
+    'bigint',
+    'function',
+    'class',
+    'enum',
+    'interface',
+    'type',
+    'import',
+    'export',
+]);
 export function sanitizeTypeName(name) {
-    return name.replace(/[^a-zA-Z0-9_$]/g, '');
+    // Strip numeric separator patterns (e.g. 1_000 → 1000)
+    let cleaned = name.replace(/(\d)_(\d)/g, '$1$2');
+    cleaned = cleaned.replace(/[^a-zA-Z0-9_$]/g, '');
+    // Prefix with 'n' if starts with a digit
+    if (/^[0-9]/.test(cleaned)) {
+        cleaned = 'n' + cleaned;
+    }
+    if (RESERVED_TYPE_NAMES.has(cleaned.toLowerCase())) {
+        return `${cleaned}Type`;
+    }
+    return cleaned;
 }
 export function schemaVarName(name) {
     const sanitized = sanitizeTypeName(name);