zod-codegen 1.3.0 → 1.4.1

package/dist/src/types/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../../src/types/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,SAAS;;iBAEpB,CAAC;AA6CH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAKxD,CAAC;AAcF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;iBAYpB,CAAC;AAkBH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;iBAKnB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;iBAKtB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASvB,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAanB,CAAC;AA+CH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAStB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AACpD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AACpD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/src/utils/error-handler.d.ts

@@ -0,0 +1,3 @@
+export declare const errorReceived: (process: NodeJS.Process, startTime: bigint) => () => void;
+export declare const handleErrors: (process: NodeJS.Process, startTime: bigint) => void;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/src/utils/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/error-handler.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,WAAS,IAGhF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,KAAG,IAKzE,CAAC"}

package/dist/src/utils/error-handler.js

@@ -5,7 +5,7 @@ export const errorReceived = (process, startTime) => () => {
 };
 export const handleErrors = (process, startTime) => {
     const catchErrors = ['unhandledRejection', 'uncaughtException'];
-    catchErrors.map((event) => {
-        return process.on(event, errorReceived(process, startTime));
+    catchErrors.forEach((event) => {
+        process.on(event, errorReceived(process, startTime));
     });
 };

package/dist/src/utils/execution-time.d.ts

@@ -0,0 +1,2 @@
+export declare function getExecutionTime(startTime: bigint): number;
+//# sourceMappingURL=execution-time.d.ts.map

package/dist/src/utils/execution-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-time.d.ts","sourceRoot":"","sources":["../../../src/utils/execution-time.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/src/utils/manifest.d.ts

@@ -0,0 +1,8 @@
+interface Manifest {
+    readonly name: string;
+    readonly version: string;
+    readonly description: string;
+}
+export declare function isManifest(input: unknown): input is Manifest;
+export {};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/src/utils/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/utils/manifest.ts"],"names":[],"mappings":"AAEA,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAQD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D"}

package/dist/src/utils/naming-convention.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Supported naming conventions for operation IDs.
+ * These conventions transform operation IDs to match common programming language styles.
+ *
+ * @example
+ * ```typescript
+ * transformNamingConvention('get_user_by_id', 'camelCase') // 'getUserById'
+ * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
+ * ```
+ */
+export type NamingConvention = 'camelCase' | 'PascalCase' | 'snake_case' | 'kebab-case' | 'SCREAMING_SNAKE_CASE' | 'SCREAMING-KEBAB-CASE';
+/**
+ * Operation details provided to custom transformers.
+ * Contains all available information about an OpenAPI operation.
+ *
+ * @example
+ * ```typescript
+ * const transformer: OperationNameTransformer = (details) => {
+ *   return `${details.method.toUpperCase()}_${details.operationId}`;
+ * };
+ * ```
+ */
+export interface OperationDetails {
+    /** Original operationId from OpenAPI spec */
+    operationId: string;
+    /** HTTP method (get, post, put, patch, delete, head, options) */
+    method: string;
+    /** API path (e.g., /users/{id}) */
+    path: string;
+    /** Tags associated with the operation */
+    tags?: string[];
+    /** Summary of the operation */
+    summary?: string;
+    /** Description of the operation */
+    description?: string;
+}
+/**
+ * Custom transformer function for operation names.
+ * Receives operation details and returns the transformed name.
+ *
+ * **Note:** The returned name will be sanitized to ensure it's a valid TypeScript identifier.
+ * Invalid characters will be replaced with underscores, and names starting with digits will be prefixed.
+ *
+ * @param details - Complete operation details from OpenAPI spec
+ * @returns The transformed operation name
+ *
+ * @example
+ * ```typescript
+ * const transformer: OperationNameTransformer = (details) => {
+ *   const tag = details.tags?.[0] || 'default';
+ *   return `${details.method}_${tag}_${details.operationId}`;
+ * };
+ * ```
+ */
+export type OperationNameTransformer = (details: OperationDetails) => string;
+/**
+ * Transforms a string to the specified naming convention.
+ *
+ * Handles various input formats including camelCase, PascalCase, snake_case, kebab-case,
+ * and mixed delimiters. The function normalizes the input by splitting on common delimiters
+ * (underscores, hyphens, spaces, dots) and then applies the target convention.
+ *
+ * **Note:** This function does not sanitize the output. The caller should ensure the result
+ * is a valid identifier for the target language (e.g., using `sanitizeIdentifier`).
+ *
+ * @param input - The input string to transform (can be in any naming convention)
+ * @param convention - The target naming convention to apply
+ * @returns The transformed string in the target convention
+ *
+ * @example
+ * ```typescript
+ * transformNamingConvention('get_user_by_id', 'camelCase') // 'getUserById'
+ * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
+ * transformNamingConvention('get-user-by-id', 'PascalCase') // 'GetUserById'
+ * ```
+ *
+ * @throws Will return empty string if input is empty (preserves empty input)
+ */
+export declare function transformNamingConvention(input: string, convention: NamingConvention): string;
+//# sourceMappingURL=naming-convention.d.ts.map

package/dist/src/utils/naming-convention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-convention.d.ts","sourceRoot":"","sources":["../../../src/utils/naming-convention.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACxB,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,sBAAsB,GACtB,sBAAsB,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CAAC;AA0G7E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,MAAM,CAsB7F"}

package/dist/src/utils/naming-convention.js

@@ -0,0 +1,135 @@
+/**
+ * Capitalizes the first letter of a word
+ */
+function capitalize(word) {
+    if (word.length === 0)
+        return word;
+    return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/**
+ * Splits camelCase or PascalCase strings into words
+ */
+function splitCamelCase(input) {
+    const words = [];
+    let currentWord = '';
+    for (const char of input) {
+        const isUpperCase = char === char.toUpperCase() && char !== char.toLowerCase();
+        const isDigit = /\d/.test(char);
+        const lastChar = currentWord[currentWord.length - 1];
+        // Start a new word if:
+        // 1. Current char is uppercase and we have a previous word
+        // 2. Current char is a digit and previous was not
+        if (currentWord.length > 0 && (isUpperCase || (isDigit && lastChar && !/\d/.test(lastChar)))) {
+            words.push(currentWord);
+            currentWord = '';
+        }
+        currentWord += char;
+    }
+    if (currentWord.length > 0) {
+        words.push(currentWord);
+    }
+    return words.length > 0 ? words : [input];
+}
+/**
+ * Normalizes input string into an array of words
+ * Handles camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE, etc.
+ */
+function normalizeToWords(input) {
+    // Handle empty or single character
+    if (input.length <= 1) {
+        return [input.toLowerCase()];
+    }
+    // Split by common delimiters: underscore, hyphen, space, dot
+    let words = input.split(/[-_\s.]+/).filter((w) => w.length > 0);
+    // If no delimiters found, try to split camelCase/PascalCase
+    if (words.length === 1) {
+        words = splitCamelCase(input);
+    }
+    // Normalize all words to lowercase
+    return words.map((w) => w.toLowerCase());
+}
+/**
+ * Converts words array to camelCase
+ */
+function toCamelCase(words) {
+    if (words.length === 0)
+        return '';
+    const [first, ...rest] = words;
+    if (!first)
+        return '';
+    return first + rest.map((w) => capitalize(w)).join('');
+}
+/**
+ * Converts words array to PascalCase
+ */
+function toPascalCase(words) {
+    return words.map((w) => capitalize(w)).join('');
+}
+/**
+ * Converts words array to snake_case
+ */
+function toSnakeCase(words) {
+    return words.join('_');
+}
+/**
+ * Converts words array to kebab-case
+ */
+function toKebabCase(words) {
+    return words.join('-');
+}
+/**
+ * Converts words array to SCREAMING_SNAKE_CASE
+ */
+function toScreamingSnakeCase(words) {
+    return words.map((w) => w.toUpperCase()).join('_');
+}
+/**
+ * Converts words array to SCREAMING-KEBAB-CASE
+ */
+function toScreamingKebabCase(words) {
+    return words.map((w) => w.toUpperCase()).join('-');
+}
+/**
+ * Transforms a string to the specified naming convention.
+ *
+ * Handles various input formats including camelCase, PascalCase, snake_case, kebab-case,
+ * and mixed delimiters. The function normalizes the input by splitting on common delimiters
+ * (underscores, hyphens, spaces, dots) and then applies the target convention.
+ *
+ * **Note:** This function does not sanitize the output. The caller should ensure the result
+ * is a valid identifier for the target language (e.g., using `sanitizeIdentifier`).
+ *
+ * @param input - The input string to transform (can be in any naming convention)
+ * @param convention - The target naming convention to apply
+ * @returns The transformed string in the target convention
+ *
+ * @example
+ * ```typescript
+ * transformNamingConvention('get_user_by_id', 'camelCase') // 'getUserById'
+ * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
+ * transformNamingConvention('get-user-by-id', 'PascalCase') // 'GetUserById'
+ * ```
+ *
+ * @throws Will return empty string if input is empty (preserves empty input)
+ */
+export function transformNamingConvention(input, convention) {
+    if (!input || input.length === 0) {
+        return input;
+    }
+    // Normalize input: split by common delimiters and convert to words
+    const words = normalizeToWords(input);
+    switch (convention) {
+        case 'camelCase':
+            return toCamelCase(words);
+        case 'PascalCase':
+            return toPascalCase(words);
+        case 'snake_case':
+            return toSnakeCase(words);
+        case 'kebab-case':
+            return toKebabCase(words);
+        case 'SCREAMING_SNAKE_CASE':
+            return toScreamingSnakeCase(words);
+        case 'SCREAMING-KEBAB-CASE':
+            return toScreamingKebabCase(words);
+    }
+}

package/dist/src/utils/reporter.d.ts

@@ -0,0 +1,7 @@
+export declare class Reporter {
+    private readonly _stdout;
+    constructor(_stdout: NodeJS.WriteStream);
+    log(...args: readonly unknown[]): void;
+    error(...args: readonly unknown[]): void;
+}
+//# sourceMappingURL=reporter.d.ts.map

package/dist/src/utils/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../../src/utils/reporter.ts"],"names":[],"mappings":"AAEA,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,MAAM,CAAC,WAAW;IAKxD,GAAG,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAItC,KAAK,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;CAGzC"}

package/dist/src/utils/signal-handler.d.ts

@@ -0,0 +1,3 @@
+export declare const signalReceived: (process: NodeJS.Process, startTime: bigint, event: NodeJS.Signals) => () => void;
+export declare const handleSignals: (process: NodeJS.Process, startTime: bigint) => void;
+//# sourceMappingURL=signal-handler.d.ts.map

package/dist/src/utils/signal-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/signal-handler.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,OAAO,MAAM,CAAC,OAAO,WAAS,IAIxG,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,KAAG,IAK1E,CAAC"}

package/dist/src/utils/signal-handler.js

@@ -6,7 +6,7 @@ export const signalReceived = (process, startTime, event) => () => {
 };
 export const handleSignals = (process, startTime) => {
     const catchSignals = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
-    catchSignals.map((event) => {
-        return process.once(event, signalReceived(process, startTime, event));
+    catchSignals.forEach((event) => {
+        process.once(event, signalReceived(process, startTime, event));
     });
 };

package/dist/src/utils/tty.d.ts

@@ -0,0 +1,2 @@
+export declare function isTTY(process: NodeJS.Process): boolean;
+//# sourceMappingURL=tty.d.ts.map

package/dist/src/utils/tty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tty.d.ts","sourceRoot":"","sources":["../../../src/utils/tty.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAEtD"}

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAGA,wBAmCG"}

package/package.json

@@ -1,8 +1,6 @@
 {
   "author": "Julien Andreu <julienandreu@me.com>",
-  "bin": {
-    "zod-codegen": "dist/src/cli.js"
-  },
+  "bin": "dist/src/cli.js",
   "bugs": {
     "url": "https://github.com/julienandreu/zod-codegen/issues"
   },
@@ -45,7 +43,8 @@
     "@types/jsonpath": "^0.2.4",
     "@types/node": "^24.10.1",
     "@types/yargs": "^17.0.35",
-    "@vitest/coverage-v8": "^4.0.13",
+    "@vitest/coverage-v8": "^4.0.14",
+    "cross-env": "^10.1.0",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "husky": "^9.1.7",
@@ -54,16 +53,16 @@
     "ts-node": "^10.9.2",
     "typescript-eslint": "^8.46.4",
     "undici": "^7.16.0",
-    "vitest": "^4.0.13",
-    "yarn-audit-fix": "^10.1.1"
+    "vitest": "^4.0.14"
   },
   "optionalDependencies": {
     "undici": "^7.16.0"
   },
   "homepage": "https://github.com/julienandreu/zod-codegen",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "name": "zod-codegen",
   "type": "module",
+  "types": "./dist/src/generator.d.ts",
   "exports": {
     ".": {
       "types": "./dist/src/generator.d.ts",
@@ -84,14 +83,15 @@
       "tar": "^7.5.2"
     },
     "glob": "^11.1.0",
-    "tar": "^7.5.2"
+    "tar": "^7.5.2",
+    "yargs": "^18.0.0"
   },
   "scripts": {
-    "audit:fix": "yarn-audit-fix",
-    "build": "rm -rf dist && tsc --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
-    "build:native": "rm -rf dist && npx tsgo --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
+    "audit:fix": "npm audit fix",
+    "build": "NODE_OPTIONS='--no-deprecation' sh -c 'rm -rf dist && tsc --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js'",
+    "build:native": "rm -rf dist && NODE_OPTIONS='--no-deprecation' npx tsgo --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
     "build:watch": "tsc --project tsconfig.json --watch",
-    "dev": "yarn build && node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ./examples/petstore && yarn format && yarn lint",
+    "dev": "npm run build && node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ./examples/petstore && npm run format && npm run lint",
     "lint": "eslint src --fix",
     "lint:check": "eslint src",
     "format": "prettier src --write --log-level error",
@@ -103,12 +103,12 @@
     "test:ui": "vitest --ui",
     "manifest:update": "ts-node scripts/update-manifest.ts",
     "prepare": "husky",
-    "prepublishOnly": "yarn build && yarn test && yarn lint:check && yarn type-check",
+    "prepublishOnly": "npm run build && npm run test && npm run lint:check && npm run type-check",
     "clean": "rm -rf dist coverage node_modules/.cache",
-    "validate": "yarn type-check && yarn lint:check && yarn format:check && yarn test",
+    "validate": "npm run type-check && npm run lint:check && npm run format:check && npm run test",
     "validate:examples": "tsc -p ./tsconfig.examples.json --noEmit",
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.3.0"
+  "version": "1.4.1"
 }

package/src/cli.ts

@@ -2,7 +2,7 @@
 
 import yargs from 'yargs';
 import {hideBin} from 'yargs/helpers';
-import {Generator} from './generator.js';
+import {Generator, type GeneratorOptions, type NamingConvention} from './generator.js';
 import {readFileSync} from 'node:fs';
 import {fileURLToPath} from 'node:url';
 import {dirname, join} from 'node:path';
@@ -72,15 +72,46 @@ const argv = yargs(hideBin(process.argv))
     description: 'Directory to output the generated files',
     default: 'generated',
   })
+  .option('naming-convention', {
+    alias: 'n',
+    type: 'string',
+    description: 'Naming convention to apply to operation IDs',
+    choices: ['camelCase', 'PascalCase', 'snake_case', 'kebab-case', 'SCREAMING_SNAKE_CASE', 'SCREAMING-KEBAB-CASE'],
+    default: undefined,
+  })
   .strict()
   .help()
   .parseSync();
 
-const {input, output} = argv;
+const {input, output, namingConvention} = argv;
+
+/**
+ * Type guard to validate that a string is a valid naming convention.
+ * This ensures type safety when parsing CLI arguments.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid NamingConvention
+ */
+function isValidNamingConvention(value: string | undefined): value is NamingConvention {
+  if (value === undefined) {
+    return false;
+  }
+  const validConventions: readonly NamingConvention[] = [
+    'camelCase',
+    'PascalCase',
+    'snake_case',
+    'kebab-case',
+    'SCREAMING_SNAKE_CASE',
+    'SCREAMING-KEBAB-CASE',
+  ] as const;
+  return validConventions.includes(value as NamingConvention);
+}
 
 void (async () => {
   try {
-    const generator = new Generator(name, version, reporter, input, output);
+    const options: GeneratorOptions = isValidNamingConvention(namingConvention) ? {namingConvention} : {};
+
+    const generator = new Generator(name, version, reporter, input, output, options);
     const exitCode = await generator.run();
     process.exit(exitCode);
   } catch (error) {

package/src/generator.ts

@@ -1,13 +1,18 @@
 import type {Reporter} from './utils/reporter.js';
 import type {OpenApiSpecType} from './types/openapi.js';
+import type {GeneratorOptions} from './types/generator-options.js';
 import {OpenApiFileParserService, SyncFileReaderService} from './services/file-reader.service.js';
 import {TypeScriptCodeGeneratorService} from './services/code-generator.service.js';
 import {SyncFileWriterService} from './services/file-writer.service.js';
 
+// Re-export types for library users
+export type {GeneratorOptions} from './types/generator-options.js';
+export type {NamingConvention, OperationDetails, OperationNameTransformer} from './utils/naming-convention.js';
+
 export class Generator {
   private readonly fileReader = new SyncFileReaderService();
   private readonly fileParser = new OpenApiFileParserService();
-  private readonly codeGenerator = new TypeScriptCodeGeneratorService();
+  private readonly codeGenerator: TypeScriptCodeGeneratorService;
   private readonly fileWriter: SyncFileWriterService;
   private readonly outputPath: string;
 
@@ -17,9 +22,11 @@ export class Generator {
     private readonly reporter: Reporter,
     private readonly inputPath: string,
     private readonly _outputDir: string,
+    options: GeneratorOptions = {},
   ) {
     this.fileWriter = new SyncFileWriterService(this._name, this._version, inputPath);
     this.outputPath = this.fileWriter.resolveOutputPath(this._outputDir);
+    this.codeGenerator = new TypeScriptCodeGeneratorService(options);
   }
 
   async run(): Promise<number> {

package/src/services/code-generator.service.ts

@@ -3,14 +3,28 @@ import * as ts from 'typescript';
 import {z} from 'zod';
 import type {CodeGenerator, SchemaBuilder} from '../interfaces/code-generator.js';
 import type {MethodSchemaType, OpenApiSpecType, ReferenceType} from '../types/openapi.js';
+import type {GeneratorOptions} from '../types/generator-options.js';
 import {MethodSchema, Reference, SchemaProperties} from '../types/openapi.js';
 import {TypeScriptImportBuilderService} from './import-builder.service.js';
 import {TypeScriptTypeBuilderService} from './type-builder.service.js';
+import {
+  type NamingConvention,
+  type OperationDetails,
+  type OperationNameTransformer,
+  transformNamingConvention,
+} from '../utils/naming-convention.js';
 
 export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuilder {
   private readonly typeBuilder = new TypeScriptTypeBuilderService();
   private readonly importBuilder = new TypeScriptImportBuilderService();
   private readonly printer = ts.createPrinter({newLine: ts.NewLineKind.LineFeed});
+  private readonly namingConvention: NamingConvention | undefined;
+  private readonly operationNameTransformer: OperationNameTransformer | undefined;
+
+  constructor(options: GeneratorOptions = {}) {
+    this.namingConvention = options.namingConvention;
+    this.operationNameTransformer = options.operationNameTransformer;
+  }
 
   private readonly ZodAST = z.object({
     type: z.enum(['string', 'number', 'boolean', 'object', 'array', 'unknown', 'record']),
@@ -122,7 +136,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     const methods = this.buildClientMethods(openapi, schemas);
 
     return ts.factory.createClassDeclaration(
-      [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+      [ts.factory.createToken(ts.SyntaxKind.ExportKeyword), ts.factory.createToken(ts.SyntaxKind.DefaultKeyword)],
       ts.factory.createIdentifier(clientName),
       undefined,
       undefined,
@@ -261,9 +275,9 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
 
   private buildHttpRequestMethod(): ts.MethodDeclaration {
     return ts.factory.createMethodDeclaration(
-      [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+      [ts.factory.createToken(ts.SyntaxKind.ProtectedKeyword), ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
       undefined,
-      ts.factory.createPrivateIdentifier('#makeRequest'),
+      ts.factory.createIdentifier('makeRequest'),
       undefined,
       [this.typeBuilder.createGenericType('T')],
       [
@@ -894,6 +908,36 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     }, []);
   }
 
+  /**
+   * Transforms operation ID according to the configured naming convention or transformer
+   * Ensures the result is a valid TypeScript identifier
+   */
+  private transformOperationName(operationId: string, method: string, path: string, schema: MethodSchemaType): string {
+    let transformed: string;
+
+    // Custom transformer takes precedence
+    if (this.operationNameTransformer) {
+      const details: OperationDetails = {
+        operationId,
+        method,
+        path,
+        ...(schema.tags !== undefined && {tags: schema.tags}),
+        ...(schema.summary !== undefined && {summary: schema.summary}),
+        ...(schema.description !== undefined && {description: schema.description}),
+      };
+      transformed = this.operationNameTransformer(details);
+    } else if (this.namingConvention) {
+      // Apply naming convention if specified
+      transformed = transformNamingConvention(operationId, this.namingConvention);
+    } else {
+      // Return original operationId if no transformation is configured
+      transformed = operationId;
+    }
+
+    // Sanitize to ensure valid TypeScript identifier (handles edge cases from custom transformers)
+    return this.typeBuilder.sanitizeIdentifier(transformed);
+  }
+
   private buildEndpointMethod(
     method: string,
     path: string,
@@ -958,10 +1002,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
 
     // Call makeRequest
     const makeRequestCall = ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createThis(),
-        ts.factory.createPrivateIdentifier('#makeRequest'),
-      ),
+      ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createIdentifier('makeRequest')),
       undefined,
       [ts.factory.createStringLiteral(method.toUpperCase(), true), pathExpression, optionsExpression],
     );
@@ -979,10 +1020,12 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
       statements.push(ts.factory.createReturnStatement(ts.factory.createAwaitExpression(makeRequestCall)));
     }
 
+    const transformedOperationId = this.transformOperationName(String(schema.operationId), method, path, schema);
+
     const methodDeclaration = ts.factory.createMethodDeclaration(
       [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
       undefined,
-      ts.factory.createIdentifier(String(schema.operationId)),
+      ts.factory.createIdentifier(transformedOperationId),
       undefined,
       undefined,
       parameters,

package/src/types/generator-options.ts

@@ -0,0 +1,60 @@
+import type {NamingConvention, OperationNameTransformer} from '../utils/naming-convention.js';
+
+/**
+ * Configuration options for the Generator class.
+ *
+ * These options control how operation IDs are transformed during code generation.
+ * You can either use a predefined naming convention or provide a custom transformer function.
+ *
+ * @example
+ * ```typescript
+ * // Using a naming convention
+ * const generator = new Generator(..., {
+ *   namingConvention: 'camelCase'
+ * });
+ *
+ * // Using a custom transformer
+ * const generator = new Generator(..., {
+ *   operationNameTransformer: (details) => {
+ *     return `${details.method}_${details.operationId}`;
+ *   }
+ * });
+ * ```
+ */
+export interface GeneratorOptions {
+  /**
+   * Naming convention to apply to operation IDs.
+   *
+   * If provided, all operation IDs will be transformed according to the specified convention.
+   * This is useful when OpenAPI specs have inconsistent or poorly named operation IDs.
+   *
+   * **Note:** If `operationNameTransformer` is also provided, it takes precedence.
+   *
+   * @example
+   * ```typescript
+   * { namingConvention: 'camelCase' } // Transforms 'get_user_by_id' → 'getUserById'
+   * ```
+   */
+  namingConvention?: NamingConvention;
+
+  /**
+   * Custom transformer function for operation names.
+   *
+   * If provided, this function will be called for each operation with full operation details.
+   * This allows for advanced customization based on HTTP method, path, tags, etc.
+   *
+   * **Note:** This takes precedence over `namingConvention` if both are provided.
+   * The returned name will be sanitized to ensure it's a valid TypeScript identifier.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   operationNameTransformer: (details) => {
+   *     const tag = details.tags?.[0] || 'default';
+   *     return `${details.method.toUpperCase()}_${tag}_${details.operationId}`;
+   *   }
+   * }
+   * ```
+   */
+  operationNameTransformer?: OperationNameTransformer;
+}