zod-codegen 1.6.3 → 1.7.1

package/dist/src/services/file-reader.service.d.ts

@@ -1,7 +1,9 @@
 import type { OpenApiFileParser, OpenApiFileReader } from '../interfaces/file-reader';
 import type { OpenApiSpecType } from '../types/openapi';
 export declare class SyncFileReaderService implements OpenApiFileReader {
+    private isUrl;
     readFile(path: string): Promise<string>;
+    private fetchUrl;
 }
 export declare class OpenApiFileParserService implements OpenApiFileParser<OpenApiSpecType> {
     parse(input: unknown): OpenApiSpecType;

package/dist/src/services/file-reader.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-reader.service.d.ts","sourceRoot":"","sources":["../../../src/services/file-reader.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,iBAAiB,EAAE,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AACpF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAGtD,qBAAa,qBAAsB,YAAW,iBAAiB;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAe9C;AAED,qBAAa,wBAAyB,YAAW,iBAAiB,CAAC,eAAe,CAAC;IACjF,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe;CAgBvC"}
+{"version":3,"file":"file-reader.service.d.ts","sourceRoot":"","sources":["../../../src/services/file-reader.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,qBAAa,qBAAsB,YAAW,iBAAiB;IAC7D,OAAO,CAAC,KAAK;IASP,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAQ/B,QAAQ;CAkBvB;AAED,qBAAa,wBAAyB,YAAW,iBAAiB,CAAC,eAAe,CAAC;IACjF,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe;CAgBvC"}

package/dist/src/services/file-reader.service.js

@@ -1,22 +1,36 @@
-import { readFileSync } from 'node:fs';
 import { load } from 'js-yaml';
+import { readFileSync } from 'node:fs';
 import { OpenApiSpec } from '../types/openapi.js';
 export class SyncFileReaderService {
-    async readFile(path) {
-        // Check if path is a URL
+    isUrl(path) {
         try {
             const url = new URL(path);
-            // If it's a valid URL, fetch it
-            const response = await fetch(url.toString());
-            if (!response.ok) {
-                throw new Error(`Failed to fetch ${path}: ${String(response.status)} ${response.statusText}`);
-            }
-            return await response.text();
+            return url.protocol === 'http:' || url.protocol === 'https:';
         }
         catch {
-            // If URL parsing fails, treat it as a local file path
-            return readFileSync(path, 'utf8');
+            return false;
+        }
+    }
+    async readFile(path) {
+        if (this.isUrl(path)) {
+            return await this.fetchUrl(path);
+        }
+        return readFileSync(path, 'utf8');
+    }
+    async fetchUrl(path) {
+        const url = new URL(path);
+        const headers = {};
+        if (url.username || url.password) {
+            const credentials = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`;
+            headers['Authorization'] = `Basic ${btoa(credentials)}`;
+            url.username = '';
+            url.password = '';
+        }
+        const response = await fetch(url.toString(), { headers });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${path}: ${String(response.status)} ${response.statusText}`);
         }
+        return await response.text();
     }
 }
 export class OpenApiFileParserService {

package/dist/src/services/file-writer.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-writer.service.d.ts","sourceRoot":"","sources":["../../../src/services/file-writer.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAE7D,qBAAa,qBAAsB,YAAW,UAAU;IAEpD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAFT,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM;IAGpC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAqBlD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,MAAM;CAGnE"}
+{"version":3,"file":"file-writer.service.d.ts","sourceRoot":"","sources":["../../../src/services/file-writer.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE/D,qBAAa,qBAAsB,YAAW,UAAU;IAEpD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAFT,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM;IAGpC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAqBlD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,SAAW,GAAG,MAAM;CAGlE"}

package/dist/src/services/file-writer.service.js

@@ -18,7 +18,7 @@ export class SyncFileWriterService {
             '/* eslint-disable */',
             '// @ts-nocheck',
             '',
-            content,
+            content
         ].join('\n');
         const dirPath = dirname(filePath);
         if (!existsSync(dirPath)) {
@@ -26,7 +26,7 @@ export class SyncFileWriterService {
         }
         writeFileSync(filePath, generatedContent);
     }
-    resolveOutputPath(outputDir, fileName = 'type.ts') {
+    resolveOutputPath(outputDir, fileName = 'api.ts') {
         return resolve(outputDir, fileName);
     }
 }

package/dist/src/services/import-builder.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-builder.service.d.ts","sourceRoot":"","sources":["../../../src/services/import-builder.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAKhE,QAAA,MAAM,aAAa;;;iBAGjB,CAAC;AAEH,KAAK,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEvD,qBAAa,8BAA+B,YAAW,aAAa;IAClE,YAAY,IAAI,EAAE,CAAC,iBAAiB,EAAE;IAQtC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,EAAE,CAAC,iBAAiB;CAqC/E"}
+{"version":3,"file":"import-builder.service.d.ts","sourceRoot":"","sources":["../../../src/services/import-builder.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAKlE,QAAA,MAAM,aAAa;;;iBAGjB,CAAC;AAEH,KAAK,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEvD,qBAAa,8BAA+B,YAAW,aAAa;IAClE,YAAY,IAAI,EAAE,CAAC,iBAAiB,EAAE;IAQtC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,EAAE,CAAC,iBAAiB;CAiC/E"}

package/dist/src/services/import-builder.service.js

@@ -4,14 +4,14 @@ const IsTypeImport = z.boolean();
 const ImportedElement = z.record(z.string(), IsTypeImport);
 const ImportOptions = z.object({
     defaultImport: ImportedElement.optional(),
-    namedImports: ImportedElement.optional(),
+    namedImports: ImportedElement.optional()
 });
 export class TypeScriptImportBuilderService {
     buildImports() {
         return [
             this.createImport('zod', {
-                namedImports: { z: false },
-            }),
+                namedImports: { z: false }
+            })
         ];
     }
     createImport(target, options) {

package/dist/src/services/type-builder.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-builder.service.d.ts","sourceRoot":"","sources":["../../../src/services/type-builder.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAE9D,qBAAa,4BAA6B,YAAW,WAAW;IAC9D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,QAAQ;IA6BpC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,EAAE,CAAC,mBAAmB;IAYtF,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,QAAQ,EAC3B,YAAY,CAAC,EAAE,EAAE,CAAC,UAAU,EAC5B,UAAU,UAAQ,GACjB,EAAE,CAAC,oBAAoB;IAW1B,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,wBAAwB;IAS5D,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAMxC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIjC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAGnC"}
+{"version":3,"file":"type-builder.service.d.ts","sourceRoot":"","sources":["../../../src/services/type-builder.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,qBAAa,4BAA6B,YAAW,WAAW;IAC9D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,QAAQ;IA4BpC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,EAAE,CAAC,mBAAmB;IAYtF,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,UAAU,UAAQ,GAAG,EAAE,CAAC,oBAAoB;IAWrI,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,wBAAwB;IAI5D,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAMxC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIjC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAGnC"}

package/dist/src/types/generator-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generator-options.d.ts","sourceRoot":"","sources":["../../../src/types/generator-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,wBAAwB,EAAC,MAAM,4BAA4B,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAEpC;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBAAwB,CAAC,EAAE,wBAAwB,CAAC;CACrD"}
+{"version":3,"file":"generator-options.d.ts","sourceRoot":"","sources":["../../../src/types/generator-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAEpC;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBAAwB,CAAC,EAAE,wBAAwB,CAAC;CACrD"}

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

@@ -1 +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"}
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../../src/types/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,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/types/openapi.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export const Reference = z.object({
-    $ref: z.string().optional(),
+    $ref: z.string().optional()
 });
 const BaseSchemaProperties = z.object({
     $ref: z.string().optional(),
@@ -36,27 +36,27 @@ const BaseSchemaProperties = z.object({
     xml: z
         .object({
         name: z.string().optional(),
-        wrapped: z.boolean().optional(),
+        wrapped: z.boolean().optional()
     })
         .optional(),
     externalDocs: Reference.optional(),
     example: z.unknown().optional(),
-    deprecated: z.boolean().optional(),
+    deprecated: z.boolean().optional()
 });
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const SchemaProperties = z.lazy(() => BaseSchemaProperties.extend({
     properties: z.record(z.string(), SchemaProperties).optional(),
-    items: SchemaProperties.optional(),
+    items: SchemaProperties.optional()
 }));
 const ServerVariable = z.object({
     default: z.string(),
     description: z.string().optional(),
-    enum: z.array(z.string()).optional(),
+    enum: z.array(z.string()).optional()
 });
 const Server = z.object({
     url: z.string(), // Allow templated URLs with {variables}
     description: z.string().optional(),
-    variables: z.record(z.string(), ServerVariable).optional(),
+    variables: z.record(z.string(), ServerVariable).optional()
 });
 export const Parameter = z.object({
     $ref: z.string().optional(),
@@ -69,7 +69,7 @@ export const Parameter = z.object({
     style: z.string().optional(),
     explode: z.boolean().optional(),
     allowReserved: z.boolean().optional(),
-    schema: SchemaProperties.optional(),
+    schema: SchemaProperties.optional()
 });
 const ResponseHeader = z.object({
     $ref: z.string().optional(),
@@ -80,22 +80,22 @@ const ResponseHeader = z.object({
     style: z.string().optional(),
     explode: z.boolean().optional(),
     allowReserved: z.boolean().optional(),
-    schema: Reference.optional(),
+    schema: Reference.optional()
 });
 const MediaType = z.object({
-    schema: z.unknown().optional(),
+    schema: z.unknown().optional()
 });
 export const Response = z.object({
     $ref: z.string().optional(),
     description: z.string(),
     headers: z.record(z.string(), ResponseHeader).optional(),
-    content: z.record(z.string(), MediaType).optional(),
+    content: z.record(z.string(), MediaType).optional()
 });
 export const RequestBody = z.object({
     $ref: z.string().optional(),
     description: z.string().optional(),
     required: z.boolean().optional(),
-    content: z.record(z.string(), MediaType).optional(),
+    content: z.record(z.string(), MediaType).optional()
 });
 export const MethodSchema = z.object({
     summary: z.string().optional(),
@@ -105,7 +105,7 @@ export const MethodSchema = z.object({
     requestBody: RequestBody.optional(),
     responses: z.record(z.string(), Response).optional(),
     tags: z.array(z.string()).optional(),
-    deprecated: z.boolean().optional(),
+    deprecated: z.boolean().optional()
 });
 export const PathItem = z.object({
     $ref: z.string().optional(),
@@ -119,7 +119,7 @@ export const PathItem = z.object({
     head: MethodSchema.optional(),
     options: MethodSchema.optional(),
     trace: MethodSchema.optional(),
-    parameters: z.array(Parameter).optional(),
+    parameters: z.array(Parameter).optional()
 });
 const Info = z.object({
     title: z.string().min(1),
@@ -130,25 +130,25 @@ const Info = z.object({
         .object({
         name: z.string().optional(),
         email: z.email().optional(),
-        url: z.url().optional(),
+        url: z.url().optional()
     })
         .optional(),
     license: z
         .object({
         name: z.string().min(1),
-        url: z.url().optional(),
+        url: z.url().optional()
     })
-        .optional(),
+        .optional()
 });
 const SecurityRequirement = z.record(z.string(), z.array(z.string()));
 const Tag = z.object({
     name: z.string().min(1),
     description: z.string().optional(),
-    externalDocs: Reference.optional(),
+    externalDocs: Reference.optional()
 });
 const ExternalDocumentation = z.object({
     description: z.string().optional(),
-    url: z.url(),
+    url: z.url()
 });
 const Components = z.object({
     schemas: z.record(z.string(), SchemaProperties).optional(),
@@ -159,7 +159,7 @@ const Components = z.object({
     headers: z.record(z.string(), ResponseHeader).optional(),
     securitySchemes: z.record(z.string(), Reference).optional(),
     links: z.record(z.string(), Reference).optional(),
-    callbacks: z.record(z.string(), Reference).optional(),
+    callbacks: z.record(z.string(), Reference).optional()
 });
 export const OpenApiSpec = z.object({
     openapi: z.string().regex(/^3\.\d+\.\d+$/, 'OpenAPI version must be in format 3.x.x'),
@@ -169,5 +169,5 @@ export const OpenApiSpec = z.object({
     components: Components.optional(),
     security: z.array(SecurityRequirement).optional(),
     tags: z.array(Tag).optional(),
-    externalDocs: ExternalDocumentation.optional(),
+    externalDocs: ExternalDocumentation.optional()
 });

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

@@ -1 +1 @@
-{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/error-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,UAAU,QAAQ,WAAS,IAGpG,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,UAAU,QAAQ,KAAG,IAK7F,CAAC"}
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/error-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,UAAU,QAAQ,WAAS,IAGpG,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,UAAU,QAAQ,KAAG,IAK7F,CAAC"}

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

@@ -1 +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"}
+{"version":3,"file":"naming-convention.d.ts","sourceRoot":"","sources":["../../../src/utils/naming-convention.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,sBAAsB,GAAG,sBAAsB,CAAC;AAE1I;;;;;;;;;;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;AAmH7E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,MAAM,CAsB7F"}

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

@@ -2,8 +2,9 @@
  * Capitalizes the first letter of a word
  */
 function capitalize(word) {
-    if (word.length === 0)
+    if (word.length === 0) {
         return word;
+    }
     return word.charAt(0).toUpperCase() + word.slice(1);
 }
 /**
@@ -52,11 +53,13 @@ function normalizeToWords(input) {
  * Converts words array to camelCase
  */
 function toCamelCase(words) {
-    if (words.length === 0)
+    if (words.length === 0) {
         return '';
+    }
     const [first, ...rest] = words;
-    if (!first)
+    if (!first) {
         return '';
+    }
     return first + rest.map((w) => capitalize(w)).join('');
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"signal-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/signal-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,cAAc,GACxB,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,OAAO,MAAM,CAAC,OAAO,EAAE,UAAU,QAAQ,WAAS,IAI9F,CAAC;AAEJ,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,UAAU,QAAQ,KAAG,IAK9F,CAAC"}
+{"version":3,"file":"signal-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/signal-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,OAAO,MAAM,CAAC,OAAO,EAAE,UAAU,QAAQ,WAAS,IAI5H,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,UAAU,QAAQ,KAAG,IAK9F,CAAC"}

package/dist/tests/integration/cli-comprehensive.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli-comprehensive.test.d.ts.map

package/dist/tests/integration/cli-comprehensive.test.d.ts.map

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

package/dist/tests/integration/cli-comprehensive.test.js

@@ -0,0 +1,123 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+describe('CLI Comprehensive Integration', () => {
+    const cwd = resolve(__dirname, '../..');
+    const testOutputDir = resolve(cwd, 'test-output-cli');
+    beforeEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    afterEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('Basic CLI Usage', () => {
+        it('should generate code with default output directory', () => {
+            execSync('node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output generated', {
+                encoding: 'utf-8',
+                cwd
+            });
+            const outputFile = resolve(cwd, 'generated/api.ts');
+            expect(existsSync(outputFile)).toBe(true);
+            const content = readFileSync(outputFile, 'utf-8');
+            expect(content).toContain('SwaggerPetstoreOpenAPI30');
+        });
+        it('should generate code with custom output directory', () => {
+            execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir}`, {
+                encoding: 'utf-8',
+                cwd
+            });
+            const outputFile = resolve(testOutputDir, 'api.ts');
+            expect(existsSync(outputFile)).toBe(true);
+        });
+        it('should accept naming convention option', () => {
+            execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir} --naming-convention camelCase`, {
+                encoding: 'utf-8',
+                cwd
+            });
+            const outputFile = resolve(testOutputDir, 'api.ts');
+            const content = readFileSync(outputFile, 'utf-8');
+            // Verify camelCase is applied (operation IDs should be camelCase)
+            expect(content).toMatch(/async \w+\(/);
+        });
+        it('should reject invalid naming convention', () => {
+            expect(() => {
+                execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir} --naming-convention invalid`, {
+                    encoding: 'utf-8',
+                    cwd,
+                    stdio: 'pipe'
+                });
+            }).toThrow();
+        });
+        it('should write to custom file when output is a .ts path', () => {
+            const outputFile = resolve(testOutputDir, 'client.ts');
+            execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output "${outputFile}"`, {
+                encoding: 'utf-8',
+                cwd
+            });
+            expect(existsSync(outputFile)).toBe(true);
+            const content = readFileSync(outputFile, 'utf-8');
+            expect(content).toContain('SwaggerPetstoreOpenAPI30');
+        });
+    });
+    describe('CLI Error Handling', () => {
+        it('should exit with code 1 on invalid input file', () => {
+            try {
+                execSync('node ./dist/src/cli.js --input ./nonexistent.yaml --output generated', {
+                    encoding: 'utf-8',
+                    cwd,
+                    stdio: 'pipe'
+                });
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                // Command should fail
+                expect(error).toBeDefined();
+            }
+        });
+        it('should require input option', () => {
+            expect(() => {
+                execSync('node ./dist/src/cli.js --output generated', {
+                    encoding: 'utf-8',
+                    cwd,
+                    stdio: 'pipe'
+                });
+            }).toThrow();
+        });
+    });
+    describe('CLI with Different Spec Formats', () => {
+        it('should handle JSON format', () => {
+            execSync(`node ./dist/src/cli.js --input ./samples/pokeapi-openapi.json --output ${testOutputDir}`, {
+                encoding: 'utf-8',
+                cwd
+            });
+            const outputFile = resolve(testOutputDir, 'api.ts');
+            expect(existsSync(outputFile)).toBe(true);
+        });
+        it('should handle YAML format', () => {
+            execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir}`, {
+                encoding: 'utf-8',
+                cwd
+            });
+            const outputFile = resolve(testOutputDir, 'api.ts');
+            expect(existsSync(outputFile)).toBe(true);
+        });
+        it('should generate code from a remote URL', () => {
+            execSync(`node ./dist/src/cli.js --input https://petstore3.swagger.io/api/v3/openapi.json --output ${testOutputDir}`, {
+                encoding: 'utf-8',
+                cwd,
+                timeout: 30000
+            });
+            const outputFile = resolve(testOutputDir, 'api.ts');
+            expect(existsSync(outputFile)).toBe(true);
+            const content = readFileSync(outputFile, 'utf-8');
+            expect(content).toContain('export default class');
+            expect(content).toContain('class ResponseValidationError<T> extends Error');
+            expect(content).toContain('import { z }');
+        });
+    });
+});

package/dist/tests/integration/cli.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.test.d.ts.map

package/dist/tests/integration/cli.test.d.ts.map

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

package/dist/tests/integration/cli.test.js

@@ -0,0 +1,25 @@
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+describe('CLI Integration', () => {
+    describe('--help', () => {
+        it('should display help information', () => {
+            const result = execSync('node ./dist/src/cli.js --help', {
+                encoding: 'utf-8',
+                cwd: resolve(__dirname, '../..')
+            });
+            expect(result).toContain('Usage:');
+            expect(result).toContain('--input');
+            expect(result).toContain('--output');
+        });
+    });
+    describe('--version', () => {
+        it('should display version information', () => {
+            const result = execSync('node ./dist/src/cli.js --version', {
+                encoding: 'utf-8',
+                cwd: resolve(__dirname, '../..')
+            });
+            expect(result).toMatch(/\d+\.\d+\.\d+/);
+        });
+    });
+});

package/dist/tests/integration/error-scenarios.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=error-scenarios.test.d.ts.map

package/dist/tests/integration/error-scenarios.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-scenarios.test.d.ts","sourceRoot":"","sources":["../../../tests/integration/error-scenarios.test.ts"],"names":[],"mappings":""}