zod-codegen 1.6.3 → 1.7.0

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;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAgB9C;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,5 +1,5 @@
-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) {

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,110 @@
+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);
+        });
+    });
+});

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":""}

package/dist/tests/integration/error-scenarios.test.js

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Generator } from '../../src/generator';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const testOutputDir = join(__dirname, '../../test-output-errors');
+describe('Error Scenarios', () => {
+    let generator;
+    let mockReporter;
+    const logSpy = vi.fn();
+    const errorSpy = vi.fn();
+    beforeEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+        mkdirSync(testOutputDir, { recursive: true });
+        mockReporter = {
+            log: logSpy,
+            error: errorSpy
+        };
+        logSpy.mockClear();
+        errorSpy.mockClear();
+    });
+    afterEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('File Reading Errors', () => {
+        it('should handle non-existent local file', async () => {
+            generator = new Generator('test-app', '1.0.0', mockReporter, './non-existent-file.yaml', testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+            expect(String(errorSpy.mock.calls[0]?.[0] ?? '')).toContain('Error');
+        });
+        it('should handle network errors when fetching URL', async () => {
+            const originalFetch = global.fetch;
+            const mockFetch = vi.fn().mockRejectedValue(new Error('Network error'));
+            global.fetch = mockFetch;
+            generator = new Generator('test-app', '1.0.0', mockReporter, 'https://example.com/nonexistent.json', testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+            expect(mockFetch).toHaveBeenCalled();
+            global.fetch = originalFetch;
+        });
+        it('should handle HTTP errors when fetching URL', async () => {
+            const originalFetch = global.fetch;
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error',
+                text: async () => 'Error response'
+            });
+            global.fetch = mockFetch;
+            generator = new Generator('test-app', '1.0.0', mockReporter, 'https://example.com/error.json', testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+            // Error should mention the HTTP error or parsing failure
+            const errorMessage = (errorSpy.mock.calls[0]?.[0] ?? '');
+            expect(errorMessage).toMatch(/500|Error|Failed/);
+            global.fetch = originalFetch;
+        });
+    });
+    describe('Parsing Errors', () => {
+        it('should handle invalid JSON', async () => {
+            const invalidFile = join(testOutputDir, 'invalid.json');
+            writeFileSync(invalidFile, '{ invalid json }');
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle invalid YAML', async () => {
+            const invalidFile = join(testOutputDir, 'invalid.yaml');
+            writeFileSync(invalidFile, 'invalid: yaml: [unclosed');
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle invalid OpenAPI version', async () => {
+            const invalidFile = join(testOutputDir, 'invalid-version.yaml');
+            writeFileSync(invalidFile, `
+openapi: 2.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths: {}
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle missing required fields', async () => {
+            const invalidFile = join(testOutputDir, 'missing-fields.yaml');
+            writeFileSync(invalidFile, `
+openapi: 3.0.0
+paths: {}
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+    });
+    describe('File Writing Errors', () => {
+        it('should handle write permission errors gracefully', async () => {
+            // Create a read-only directory (on Unix systems)
+            const readOnlyDir = join(testOutputDir, 'readonly');
+            mkdirSync(readOnlyDir, { recursive: true });
+            // Note: chmod doesn't work the same way on all systems, so this test
+            // might need to be adjusted based on the environment
+            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', readOnlyDir);
+            const exitCode = await generator.run();
+            // Should either succeed or fail gracefully
+            expect([0, 1]).toContain(exitCode);
+        });
+    });
+    describe('Malformed OpenAPI Specs', () => {
+        it('should handle empty spec', async () => {
+            const emptyFile = join(testOutputDir, 'empty.yaml');
+            writeFileSync(emptyFile, '');
+            generator = new Generator('test-app', '1.0.0', mockReporter, emptyFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle spec with no paths', async () => {
+            const noPathsFile = join(testOutputDir, 'no-paths.yaml');
+            writeFileSync(noPathsFile, `
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths: {}
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, noPathsFile, testOutputDir);
+            const exitCode = await generator.run();
+            // Should succeed even with no paths
+            expect(exitCode).toBe(0);
+            expect(logSpy).toHaveBeenCalled();
+        });
+        it('should handle spec with no components', async () => {
+            const noComponentsFile = join(testOutputDir, 'no-components.yaml');
+            writeFileSync(noComponentsFile, `
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths:
+  /test:
+    get:
+      operationId: test
+      responses:
+        '200':
+          description: Success
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, noComponentsFile, testOutputDir);
+            const exitCode = await generator.run();
+            // Should succeed even with no components
+            expect(exitCode).toBe(0);
+        });
+    });
+});

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

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

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

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