openapi-class-transformer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,385 @@
+# openapi-class-transformer
+
+Generate class-transformer compatible TypeScript classes from OpenAPI specifications with full decorator support.
+
+## Features
+
+✨ **Class-Transformer Compatible**: Generates TypeScript classes with `@Expose()` and `@Type()` decorators
+🎯 **Type-Safe**: Full TypeScript support with proper type definitions
+📦 **Vendor Extensions**: Automatically includes all `x-*` properties in JSDoc comments
+🔧 **Customizable**: Support for custom templates and additional properties
+⚡ **Easy to Use**: Simple CLI and programmatic API
+🧪 **Well-Tested**: Comprehensive test coverage
+
+## Installation
+
+```bash
+npm install openapi-class-transformer
+# or
+yarn add openapi-class-transformer
+# or
+pnpm add openapi-class-transformer
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Generate from OpenAPI spec
+npx openapi-class-transformer generate \
+  --input ./api-spec.json \
+  --output ./src/generated
+
+# With custom template directory
+npx openapi-class-transformer generate \
+  -i ./api-spec.yaml \
+  -o ./src/api \
+  -t ./custom-templates
+
+# With additional properties
+npx openapi-class-transformer generate \
+  -i ./spec.json \
+  -o ./output \
+  --additional-properties modelPackage=dto,apiPackage=services
+```
+
+### Programmatic API
+
+```typescript
+import { Generator } from 'openapi-class-transformer';
+
+const generator = new Generator({
+  inputSpec: './api-spec.json',
+  outputDir: './src/generated',
+  // Optional: custom template directory
+  templateDir: './custom-templates',
+  // Optional: additional OpenAPI Generator properties
+  additionalProperties: {
+    modelPackage: 'dto',
+    apiPackage: 'services'
+  }
+});
+
+await generator.generate();
+```
+
+## Generated Output
+
+Given this OpenAPI schema:
+
+```yaml
+components:
+  schemas:
+    User:
+      type: object
+      required:
+        - id
+        - name
+      properties:
+        id:
+          type: string
+        name:
+          type: string
+        profile:
+          $ref: '#/components/schemas/Profile'
+    Profile:
+      type: object
+      properties:
+        bio:
+          type: string
+```
+
+The generator creates:
+
+```typescript
+import { Expose, Type } from 'class-transformer';
+import { Profile } from './profile.js';
+
+export class User {
+    /**
+     * id
+     */
+    @Expose()
+    'id': string;
+
+    /**
+     * name
+     */
+    @Expose()
+    'name': string;
+
+    /**
+     * profile
+     */
+    @Expose()
+    @Type(() => Profile)
+    'profile'?: Profile;
+}
+```
+
+### Vendor Extensions
+
+All OpenAPI vendor extensions (`x-*` properties) are automatically included in JSDoc comments:
+
+```yaml
+properties:
+  count:
+    anyOf:
+      - type: integer
+      - type: string
+    x-kubernetes-int-or-string: true
+    x-custom-property: "custom-value"
+```
+
+Generates:
+
+```typescript
+/**
+ * count
+ * @x-kubernetes-int-or-string true
+ * @x-custom-property "custom-value"
+ */
+@Expose()
+'count': string | number;
+```
+
+## Use with class-transformer
+
+The generated classes work seamlessly with `class-transformer`:
+
+```typescript
+import { plainToInstance } from 'class-transformer';
+import { User } from './generated/models/user';
+
+const plainData = {
+  id: '123',
+  name: 'John Doe',
+  profile: {
+    bio: 'Software developer'
+  }
+};
+
+const user = plainToInstance(User, plainData);
+// ✅ user is properly typed User instance
+// ✅ user.profile is properly typed Profile instance
+```
+
+### TypeScript Configuration
+
+Ensure your `tsconfig.json` has the following settings to use the generated classes:
+
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true
+  }
+}
+```
+
+### Dependencies
+
+Install `class-transformer` in your project:
+
+```bash
+npm install class-transformer reflect-metadata
+```
+
+And import `reflect-metadata` at the top of your entry file:
+
+```typescript
+import 'reflect-metadata';
+```
+
+## Runtime Type Metadata
+
+Each generated class includes a static `attributeTypeMap` property that provides runtime access to property metadata:
+
+```typescript
+import { User } from './generated/models/user';
+
+// Access type metadata at runtime
+console.log(User.attributeTypeMap);
+/*
+[
+  {
+    "name": "id",
+    "baseName": "id",
+    "type": "string",
+    "format": ""
+  },
+  {
+    "name": "name",
+    "baseName": "name",
+    "type": "string",
+    "format": ""
+  },
+  {
+    "name": "email",
+    "baseName": "email",
+    "type": "string",
+    "format": "email"
+  },
+  {
+    "name": "profile",
+    "baseName": "profile",
+    "type": "Profile",
+    "format": ""
+  }
+]
+*/
+```
+
+This is useful for:
+- **Runtime validation** - Check types dynamically
+- **Form generation** - Build UI forms from metadata
+- **Documentation** - Generate API docs from types
+- **Serialization** - Custom serialization logic based on types
+
+### Array Types
+
+Arrays are represented with the `Array<Type>` notation:
+
+```typescript
+console.log(UserList.attributeTypeMap);
+/*
+[
+  {
+    "name": "users",
+    "baseName": "users",
+    "type": "Array<User>",
+    "format": ""
+  }
+]
+*/
+```
+
+## Configuration Options
+
+### GeneratorOptions
+
+```typescript
+interface GeneratorOptions {
+  /**
+   * Path to the OpenAPI specification file (JSON or YAML)
+   */
+  inputSpec: string;
+
+  /**
+   * Output directory for generated files
+   */
+  outputDir: string;
+
+  /**
+   * Custom template directory (optional)
+   * If not provided, uses bundled templates
+   */
+  templateDir?: string;
+
+  /**
+   * Additional OpenAPI Generator properties
+   */
+  additionalProperties?: Record<string, string>;
+}
+```
+
+### Default Additional Properties
+
+The generator uses these defaults (can be overridden):
+
+- `withSeparateModelsAndApi`: `true`
+- `modelPackage`: `models`
+- `apiPackage`: `api`
+- `generateAliasAsModel`: `true`
+- `supportsES6`: `true`
+- `useSingleRequestParameter`: `true`
+- `withNodeImports`: `true`
+
+## Custom Templates
+
+You can provide custom Mustache templates to customize the generated output:
+
+1. Copy the default template from `templates/modelGeneric.mustache`
+2. Modify it according to your needs
+3. Pass the template directory to the generator:
+
+```typescript
+const generator = new Generator({
+  inputSpec: './spec.json',
+  outputDir: './output',
+  templateDir: './my-templates'
+});
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Build
+npm run build
+
+# Run tests with coverage
+npm run test:coverage
+```
+
+## Testing
+
+The package includes comprehensive test coverage using Jest:
+
+```bash
+npm test
+```
+
+Tests follow TDD (Test-Driven Development) principles with fixtures in the `test-fixtures` directory.
+
+### Test Results
+
+Each test generates its output into a separate directory under `test-results/` (gitignored). This allows you to:
+
+- **Inspect generated code** manually after running tests
+- **Debug issues** by examining actual output
+- **See examples** of what the generator produces
+
+For example, after running tests:
+
+```bash
+# View generated User class with @Expose decorators
+cat test-results/expose-decorators/models/user.ts
+
+# View generated Replica class with vendor extensions
+cat test-results/vendor-extensions/models/replica.ts
+```
+
+Test result directories persist between runs and are organized by test name:
+- `basic-generation/` - Basic class generation
+- `expose-decorators/` - @Expose() decorator tests
+- `type-decorators/` - @Type() decorator tests
+- `import-type-fix/` - Import type conversion tests
+- `vendor-extensions/` - Vendor extension tests
+
+See [test-results/README.md](test-results/README.md) for more details.
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Credits
+
+Built on top of:
+- [OpenAPI Generator](https://openapi-generator.tech/)
+- [class-transformer](https://github.com/typestack/class-transformer)

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const generator_1 = require("./generator");
+const path = __importStar(require("path"));
+const program = new commander_1.Command();
+program
+    .name('openapi-class-transformer')
+    .description('Generate class-transformer compatible TypeScript classes from OpenAPI specs')
+    .version('1.0.0');
+program
+    .command('generate')
+    .description('Generate TypeScript classes from OpenAPI specification')
+    .requiredOption('-i, --input <path>', 'Path to OpenAPI specification file')
+    .requiredOption('-o, --output <path>', 'Output directory for generated files')
+    .option('-t, --template <path>', 'Custom template directory')
+    .option('--additional-properties <props>', 'Additional OpenAPI Generator properties (key=value,key2=value2)')
+    .action(async (options) => {
+    try {
+        const additionalProperties = {};
+        if (options.additionalProperties) {
+            options.additionalProperties.split(',').forEach((prop) => {
+                const [key, value] = prop.split('=');
+                if (key && value) {
+                    additionalProperties[key] = value;
+                }
+            });
+        }
+        const generator = new generator_1.Generator({
+            inputSpec: path.resolve(options.input),
+            outputDir: path.resolve(options.output),
+            templateDir: options.template ? path.resolve(options.template) : undefined,
+            additionalProperties
+        });
+        await generator.generate();
+        console.log('✅ Generation completed successfully!');
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('❌ Generation failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,yCAAoC;AACpC,2CAAwC;AACxC,2CAA6B;AAE7B,MAAM,OAAO,GAAG,IAAI,mBAAO,EAAE,CAAC;AAE9B,OAAO;KACJ,IAAI,CAAC,2BAA2B,CAAC;KACjC,WAAW,CAAC,6EAA6E,CAAC;KAC1F,OAAO,CAAC,OAAO,CAAC,CAAC;AAEpB,OAAO;KACJ,OAAO,CAAC,UAAU,CAAC;KACnB,WAAW,CAAC,wDAAwD,CAAC;KACrE,cAAc,CAAC,oBAAoB,EAAE,oCAAoC,CAAC;KAC1E,cAAc,CAAC,qBAAqB,EAAE,sCAAsC,CAAC;KAC7E,MAAM,CAAC,uBAAuB,EAAE,2BAA2B,CAAC;KAC5D,MAAM,CAAC,iCAAiC,EAAE,iEAAiE,CAAC;KAC5G,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACxB,IAAI,CAAC;QACH,MAAM,oBAAoB,GAA2B,EAAE,CAAC;QACxD,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;YACjC,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAY,EAAE,EAAE;gBAC/D,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACrC,IAAI,GAAG,IAAI,KAAK,EAAE,CAAC;oBACjB,oBAAoB,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;gBACpC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,qBAAS,CAAC;YAC9B,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;YACtC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC;YACvC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;YAC1E,oBAAoB;SACrB,CAAC,CAAC;QAEH,MAAM,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC3B,OAAO,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;QACpD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,sBAAsB,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACtF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC,CAAC,CAAC;AAEL,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/generator.d.ts

@@ -0,0 +1,41 @@
+export interface GeneratorOptions {
+    /**
+     * Path to the OpenAPI specification file (JSON or YAML)
+     */
+    inputSpec: string;
+    /**
+     * Output directory for generated files
+     */
+    outputDir: string;
+    /**
+     * Custom template directory (optional)
+     * If not provided, uses bundled templates
+     */
+    templateDir?: string;
+    /**
+     * Generate only model classes (skip APIs and configuration)
+     * @default false
+     */
+    modelsOnly?: boolean;
+    /**
+     * Additional OpenAPI Generator properties
+     */
+    additionalProperties?: Record<string, string>;
+}
+export declare class Generator {
+    private options;
+    constructor(options: GeneratorOptions);
+    /**
+     * Get the default template directory (bundled with the package)
+     */
+    private getDefaultTemplateDir;
+    /**
+     * Validate generator options
+     */
+    private validateOptions;
+    /**
+     * Generate TypeScript classes from OpenAPI specification
+     */
+    generate(): Promise<void>;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/C;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAA6B;gBAEhC,OAAO,EAAE,gBAAgB;IAWrC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CA2FhC"}

package/dist/generator.js

@@ -0,0 +1,161 @@
+"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.Generator = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const post_processor_1 = require("./post-processor");
+class Generator {
+    constructor(options) {
+        this.options = {
+            templateDir: this.getDefaultTemplateDir(),
+            modelsOnly: false,
+            additionalProperties: {},
+            ...options
+        };
+        this.validateOptions();
+    }
+    /**
+     * Get the default template directory (bundled with the package)
+     */
+    getDefaultTemplateDir() {
+        // In development, templates are in the root
+        // After build, they should be adjacent to dist
+        const devPath = path.join(__dirname, '../templates');
+        const prodPath = path.join(__dirname, '../../templates');
+        if (fs.existsSync(devPath)) {
+            return devPath;
+        }
+        if (fs.existsSync(prodPath)) {
+            return prodPath;
+        }
+        throw new Error('Could not find templates directory');
+    }
+    /**
+     * Validate generator options
+     */
+    validateOptions() {
+        if (!fs.existsSync(this.options.inputSpec)) {
+            throw new Error(`Input spec not found: ${this.options.inputSpec}`);
+        }
+        if (!fs.existsSync(this.options.templateDir)) {
+            throw new Error(`Template directory not found: ${this.options.templateDir}`);
+        }
+    }
+    /**
+     * Generate TypeScript classes from OpenAPI specification
+     */
+    async generate() {
+        try {
+            // Ensure output directory exists
+            fs.mkdirSync(this.options.outputDir, { recursive: true });
+            // Build additional properties string
+            const additionalProps = {
+                withSeparateModelsAndApi: 'true',
+                modelPackage: 'models',
+                apiPackage: 'api',
+                generateAliasAsModel: 'true',
+                supportsES6: 'true',
+                useSingleRequestParameter: 'true',
+                withNodeImports: 'true',
+                ...this.options.additionalProperties
+            };
+            const propsString = Object.entries(additionalProps)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(',');
+            // Run OpenAPI Generator
+            // Try to use system-installed openapi-generator first, fallback to npx
+            const commandParts = [
+                'openapi-generator',
+                'generate',
+                `-i "${this.options.inputSpec}"`,
+                '-g typescript-axios',
+                `-o "${this.options.outputDir}"`,
+                `-t "${this.options.templateDir}"`,
+                `--additional-properties=${propsString}`
+            ];
+            // Add global-property to generate only models if modelsOnly is true
+            if (this.options.modelsOnly) {
+                commandParts.push('--global-property models');
+            }
+            const command = commandParts.join(' ');
+            console.log('Running OpenAPI Generator...');
+            // Ensure PATH includes common binary locations (Homebrew, system binaries)
+            const enhancedEnv = {
+                ...process.env,
+                PATH: `/opt/homebrew/bin:/usr/local/bin:${process.env.PATH || ''}`
+            };
+            try {
+                (0, child_process_1.execSync)(command, { stdio: 'inherit', env: enhancedEnv }); // Temporarily use inherit to see output
+            }
+            catch (error) {
+                // Log the actual error for debugging
+                console.error('First command failed:', error instanceof Error ? error.message : error);
+                // If openapi-generator not found, try npx
+                const npxCommandParts = [
+                    'npx',
+                    '-y',
+                    '@openapitools/openapi-generator-cli',
+                    'generate',
+                    `-i "${this.options.inputSpec}"`,
+                    '-g typescript-axios',
+                    `-o "${this.options.outputDir}"`,
+                    `-t "${this.options.templateDir}"`,
+                    `--additional-properties=${propsString}`
+                ];
+                // Add global-property to generate only models if modelsOnly is true
+                if (this.options.modelsOnly) {
+                    npxCommandParts.push('--global-property models');
+                }
+                const npxCommand = npxCommandParts.join(' ');
+                (0, child_process_1.execSync)(npxCommand, { stdio: 'pipe', env: enhancedEnv });
+            }
+            // Post-process generated files
+            console.log('Post-processing generated files...');
+            const postProcessor = new post_processor_1.PostProcessor(this.options.inputSpec, this.options.outputDir);
+            await postProcessor.process();
+            console.log('Generation complete!');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to generate classes: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+}
+exports.Generator = Generator;
+//# sourceMappingURL=generator.js.map