zod-codegen 1.6.2 → 1.7.0

package/dist/src/services/code-generator.service.js

@@ -1,10 +1,9 @@
-import jp from 'jsonpath';
 import * as ts from 'typescript';
 import { z } from 'zod';
 import { MethodSchema, Reference, SchemaProperties } from '../types/openapi.js';
+import { transformNamingConvention } from '../utils/naming-convention.js';
 import { TypeScriptImportBuilderService } from './import-builder.service.js';
 import { TypeScriptTypeBuilderService } from './type-builder.service.js';
-import { transformNamingConvention, } from '../utils/naming-convention.js';
 export class TypeScriptCodeGeneratorService {
     typeBuilder = new TypeScriptTypeBuilderService();
     importBuilder = new TypeScriptImportBuilderService();
@@ -20,10 +19,33 @@ export class TypeScriptCodeGeneratorService {
     }
     ZodAST = z.object({
         type: z.enum(['string', 'number', 'boolean', 'object', 'array', 'unknown', 'record']),
-        args: z.array(z.unknown()).optional(),
+        args: z.array(z.unknown()).optional()
     });
+    extractSchemaReferences(schema) {
+        const references = new Set();
+        const walk = (node) => {
+            if (Array.isArray(node)) {
+                for (const item of node) {
+                    walk(item);
+                }
+                return;
+            }
+            if (node === null || typeof node !== 'object') {
+                return;
+            }
+            for (const [key, value] of Object.entries(node)) {
+                if (key === '$ref' && typeof value === 'string' && value.startsWith('#/components/schemas/')) {
+                    references.add(value.replace('#/components/schemas/', ''));
+                    continue;
+                }
+                walk(value);
+            }
+        };
+        walk(schema);
+        return [...references];
+    }
     generate(spec) {
-        const file = ts.createSourceFile('generated.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+        const file = ts.createSourceFile('api.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
         const nodes = this.buildAST(spec);
         return this.printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(nodes), file);
     }
@@ -53,15 +75,19 @@ export class TypeScriptCodeGeneratorService {
         const schemaTypeAliases = this.buildSchemaTypeAliases(schemas);
         const serverConfig = this.buildServerConfiguration(openapi);
         const clientClass = this.buildClientClass(openapi, schemas);
+        const explicitTypeDeclarations = this.buildExplicitTypeDeclarations(openapi);
         return [
             this.createComment('Imports'),
             ...imports,
+            this.createComment('Explicit type declarations'),
+            ...explicitTypeDeclarations,
             this.createComment('Components schemas'),
             ...Object.values(schemas),
             ...schemaTypeAliases,
             ...serverConfig,
+            this.buildResponseValidationErrorClass(),
             this.createComment('Client class'),
-            clientClass,
+            clientClass
         ];
     }
     buildSchemas(openapi) {
@@ -72,27 +98,195 @@ export class TypeScriptCodeGeneratorService {
         const sortedSchemaNames = this.topologicalSort(schemasMap);
         return sortedSchemaNames.reduce((schemaRegistered, name) => {
             const schema = openapi.components?.schemas?.[name];
-            if (!schema)
+            if (!schema) {
                 return schemaRegistered;
+            }
             // Set context for current schema being built
             this.currentSchemaName = name;
             const schemaExpression = this.buildSchema(schema);
             // Clear context
             this.currentSchemaName = null;
-            const variableStatement = ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier(this.typeBuilder.sanitizeIdentifier(name)), undefined, undefined, schemaExpression),
-            ], ts.NodeFlags.Const));
+            const sanitizedName = this.typeBuilder.sanitizeIdentifier(name);
+            // Add type annotation: z.ZodType<Name>
+            const typeAnnotation = ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('ZodType')), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedName), undefined)
+            ]);
+            const variableStatement = ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(sanitizedName), undefined, typeAnnotation, schemaExpression)], ts.NodeFlags.Const));
             return {
                 ...schemaRegistered,
-                [name]: variableStatement,
+                [name]: variableStatement
             };
         }, {});
     }
-    buildSchemaTypeAliases(schemas) {
-        return Object.keys(schemas).map((name) => {
+    buildSchemaTypeAliases(_schemas) {
+        // Explicit type declarations are used instead of z.infer type exports
+        return [];
+    }
+    /**
+     * Builds explicit TypeScript type declarations for all schemas.
+     * Returns interface declarations for object types and type aliases for other types.
+     */
+    buildExplicitTypeDeclarations(openapi) {
+        const schemasEntries = Object.entries(openapi.components?.schemas ?? {});
+        const schemasMap = Object.fromEntries(schemasEntries);
+        const sortedSchemaNames = this.topologicalSort(schemasMap);
+        const statements = [];
+        for (const name of sortedSchemaNames) {
+            const schema = openapi.components?.schemas?.[name];
+            if (!schema) {
+                continue;
+            }
             const sanitizedName = this.typeBuilder.sanitizeIdentifier(name);
-            return ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(sanitizedName), undefined, ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedName), undefined)]));
+            const safeSchema = SchemaProperties.safeParse(schema);
+            if (!safeSchema.success) {
+                // Unknown schema type, create a type alias to unknown
+                statements.push(ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(sanitizedName), undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)));
+                continue;
+            }
+            const schemaData = safeSchema.data;
+            const typeNode = this.buildTypeNode(schemaData);
+            // For object types with properties, create an interface
+            if (schemaData['type'] === 'object' && schemaData['properties']) {
+                statements.push(this.buildInterfaceDeclaration(sanitizedName, schemaData));
+                continue;
+            }
+            // For all other types (enums, arrays, unions, etc.), create a type alias
+            statements.push(ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(sanitizedName), undefined, typeNode));
+        }
+        return statements;
+    }
+    /**
+     * Converts an OpenAPI schema to a TypeScript type node.
+     */
+    buildTypeNode(schema) {
+        const safeSchema = SchemaProperties.safeParse(schema);
+        if (!safeSchema.success) {
+            return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        }
+        const prop = safeSchema.data;
+        // Handle $ref
+        if (this.isReference(prop)) {
+            const { $ref = '' } = Reference.parse(prop);
+            const refName = $ref.split('/').pop() ?? 'never';
+            const sanitizedRefName = this.typeBuilder.sanitizeIdentifier(refName);
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedRefName), undefined);
+        }
+        // Handle nullable
+        const isNullable = prop['nullable'] === true;
+        const baseTypeNode = this.buildBaseTypeNode(prop);
+        if (isNullable) {
+            return ts.factory.createUnionTypeNode([baseTypeNode, ts.factory.createLiteralTypeNode(ts.factory.createNull())]);
+        }
+        return baseTypeNode;
+    }
+    /**
+     * Builds the base type node without nullable handling.
+     */
+    buildBaseTypeNode(prop) {
+        // Handle anyOf/oneOf (union types)
+        if (prop['anyOf'] && Array.isArray(prop['anyOf']) && prop['anyOf'].length > 0) {
+            const types = prop['anyOf'].map((s) => this.buildTypeNode(s));
+            return ts.factory.createUnionTypeNode(types);
+        }
+        if (prop['oneOf'] && Array.isArray(prop['oneOf']) && prop['oneOf'].length > 0) {
+            const types = prop['oneOf'].map((s) => this.buildTypeNode(s));
+            return ts.factory.createUnionTypeNode(types);
+        }
+        // Handle allOf (intersection types)
+        if (prop['allOf'] && Array.isArray(prop['allOf']) && prop['allOf'].length > 0) {
+            const types = prop['allOf'].map((s) => this.buildTypeNode(s));
+            return ts.factory.createIntersectionTypeNode(types);
+        }
+        // Handle enum
+        if (prop['enum'] && Array.isArray(prop['enum']) && prop['enum'].length > 0) {
+            const literalTypes = prop['enum'].map((val) => {
+                if (typeof val === 'string') {
+                    return ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(val, true));
+                }
+                else if (typeof val === 'number') {
+                    if (val < 0) {
+                        return ts.factory.createLiteralTypeNode(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(String(Math.abs(val)))));
+                    }
+                    return ts.factory.createLiteralTypeNode(ts.factory.createNumericLiteral(String(val)));
+                }
+                else if (typeof val === 'boolean') {
+                    return ts.factory.createLiteralTypeNode(val ? ts.factory.createTrue() : ts.factory.createFalse());
+                }
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+            });
+            return ts.factory.createUnionTypeNode(literalTypes);
+        }
+        // Handle type-specific schemas
+        switch (prop['type']) {
+            case 'string':
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+            case 'number':
+            case 'integer':
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+            case 'boolean':
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+            case 'array': {
+                const itemsType = prop['items'] ? this.buildTypeNode(prop['items']) : ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+                return ts.factory.createArrayTypeNode(itemsType);
+            }
+            case 'object': {
+                const properties = (prop['properties'] ?? {});
+                const requiredProps = (prop['required'] ?? []);
+                if (Object.keys(properties).length > 0) {
+                    return this.buildObjectTypeLiteral(properties, requiredProps);
+                }
+                // Empty object or additionalProperties - use Record<string, unknown>
+                return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
+                    ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
+                ]);
+            }
+            default:
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        }
+    }
+    /**
+     * Builds a TypeScript type literal for an object schema.
+     */
+    buildObjectTypeLiteral(properties, requiredProps) {
+        const members = Object.entries(properties).map(([name, propSchema]) => {
+            const isRequired = requiredProps.includes(name);
+            const typeNode = this.buildTypeNode(propSchema);
+            return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(name), isRequired ? undefined : ts.factory.createToken(ts.SyntaxKind.QuestionToken), typeNode);
         });
+        return ts.factory.createTypeLiteralNode(members);
+    }
+    /**
+     * Builds a TypeScript interface declaration for an object schema.
+     */
+    buildInterfaceDeclaration(name, schema) {
+        const properties = (schema['properties'] ?? {});
+        const requiredProps = (schema['required'] ?? []);
+        const members = Object.entries(properties).map(([propName, propSchema]) => {
+            const isRequired = requiredProps.includes(propName);
+            const typeNode = this.buildTypeNode(propSchema);
+            return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(propName), isRequired ? undefined : ts.factory.createToken(ts.SyntaxKind.QuestionToken), typeNode);
+        });
+        return ts.factory.createInterfaceDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(name), undefined, undefined, members);
+    }
+    buildResponseValidationErrorClass() {
+        const typeParamT = ts.factory.createTypeParameterDeclaration(undefined, 'T');
+        const responseProperty = ts.factory.createPropertyDeclaration([ts.factory.createToken(ts.SyntaxKind.ReadonlyKeyword)], 'response', undefined, ts.factory.createTypeReferenceNode('Response'), undefined);
+        const errorProperty = ts.factory.createPropertyDeclaration([ts.factory.createToken(ts.SyntaxKind.ReadonlyKeyword)], 'error', undefined, ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), 'ZodError'), [ts.factory.createTypeReferenceNode('T')]), undefined);
+        const constructorDecl = ts.factory.createConstructorDeclaration(undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'message', undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)),
+            ts.factory.createParameterDeclaration(undefined, undefined, 'response', undefined, ts.factory.createTypeReferenceNode('Response')),
+            ts.factory.createParameterDeclaration(undefined, undefined, 'error', undefined, ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), 'ZodError'), [ts.factory.createTypeReferenceNode('T')]))
+        ], ts.factory.createBlock([
+            ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createSuper(), undefined, [ts.factory.createIdentifier('message')])),
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), 'name'), ts.SyntaxKind.EqualsToken, ts.factory.createAsExpression(ts.factory.createStringLiteral('ResponseValidationError', true), ts.factory.createTypeReferenceNode('const')))),
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), 'response'), ts.SyntaxKind.EqualsToken, ts.factory.createIdentifier('response'))),
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), 'error'), ts.SyntaxKind.EqualsToken, ts.factory.createIdentifier('error')))
+        ], true));
+        const dataGetter = ts.factory.createGetAccessorDeclaration(undefined, 'data', [], ts.factory.createTypeReferenceNode('T'), ts.factory.createBlock([
+            ts.factory.createReturnStatement(ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), 'response'), 'json'), undefined, []), ts.factory.createTypeReferenceNode('T')))
+        ], true));
+        return ts.factory.createClassDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], 'ResponseValidationError', [typeParamT], [ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier('Error'), undefined)])], [responseProperty, errorProperty, constructorDecl, dataGetter]);
     }
     buildClientClass(openapi, schemas) {
         const clientName = this.generateClientName(openapi.info.title);
@@ -103,7 +297,7 @@ export class TypeScriptCodeGeneratorService {
             this.buildGetBaseRequestOptionsMethod(),
             this.buildHandleResponseMethod(),
             this.buildHttpRequestMethod(),
-            ...methods,
+            ...methods
         ]);
     }
     buildConstructor(openapi) {
@@ -111,24 +305,21 @@ export class TypeScriptCodeGeneratorService {
         if (hasServers) {
             // Options-based constructor
             return ts.factory.createConstructorDeclaration(undefined, [
-                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('options'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('ClientOptions'), undefined), undefined),
+                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('options'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('ClientOptions'), undefined), undefined)
             ], ts.factory.createBlock([
                 ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
                     ts.factory.createVariableDeclaration(ts.factory.createIdentifier('resolvedUrl'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('baseUrl')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createNull()), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('baseUrl')), ts.factory.createToken(ts.SyntaxKind.ColonToken), ts.factory.createCallExpression(ts.factory.createIdentifier('resolveServerUrl'), undefined, [
                         ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('serverIndex')),
-                        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('serverVariables')),
-                    ]))),
+                        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('serverVariables'))
+                    ])))
                 ], ts.NodeFlags.Const)),
-                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('resolvedUrl'))),
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('resolvedUrl')))
             ], true));
         }
         else {
             // Fallback: simple baseUrl parameter
-            return ts.factory.createConstructorDeclaration(undefined, [
-                this.typeBuilder.createParameter('baseUrl', 'string', ts.factory.createStringLiteral('/', true)),
-                this.typeBuilder.createParameter('_', 'unknown', undefined, true),
-            ], ts.factory.createBlock([
-                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('baseUrl'))),
+            return ts.factory.createConstructorDeclaration(undefined, [this.typeBuilder.createParameter('baseUrl', 'string', ts.factory.createStringLiteral('/', true)), this.typeBuilder.createParameter('_', 'unknown', undefined, true)], ts.factory.createBlock([
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('baseUrl')))
             ], true));
         }
     }
@@ -138,9 +329,9 @@ export class TypeScriptCodeGeneratorService {
                 ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('RequestInit'), undefined),
                 ts.factory.createUnionTypeNode([
                     ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral('method', true)),
-                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral('body', true)),
-                ]),
-            ]),
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral('body', true))
+                ])
+            ])
         ]), ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression([], false))], true));
     }
     buildHandleResponseMethod() {
@@ -148,76 +339,66 @@ export class TypeScriptCodeGeneratorService {
             this.typeBuilder.createParameter('response', 'Response'),
             this.typeBuilder.createParameter('method', 'string'),
             this.typeBuilder.createParameter('path', 'string'),
-            this.typeBuilder.createParameter('options', '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string; headers?: Record<string, string>}'),
-        ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Response'), undefined),
-        ]), ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createIdentifier('response'))], true));
+            this.typeBuilder.createParameter('options', '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string; headers?: Record<string, string>}')
+        ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Response'), undefined)]), ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createIdentifier('response'))], true));
     }
     buildHttpRequestMethod() {
         return ts.factory.createMethodDeclaration([ts.factory.createToken(ts.SyntaxKind.ProtectedKeyword), ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)], undefined, ts.factory.createIdentifier('makeRequest'), undefined, [this.typeBuilder.createGenericType('T')], [
             this.typeBuilder.createParameter('method', 'string'),
             this.typeBuilder.createParameter('path', 'string'),
-            this.typeBuilder.createParameter('options', '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string; headers?: Record<string, string>}', ts.factory.createObjectLiteralExpression([], false), false),
-        ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('T'), undefined),
-        ]), ts.factory.createBlock([
+            this.typeBuilder.createParameter('options', '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string; headers?: Record<string, string>}', ts.factory.createObjectLiteralExpression([], false), false)
+        ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('T'), undefined)]), ts.factory.createBlock([
             // Create initial URL object that we will use to build the final URL
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
                 ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseUrl'), undefined, undefined, ts.factory.createNewExpression(ts.factory.createIdentifier('URL'), undefined, [
                     ts.factory.createIdentifier('path'),
-                    ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')),
-                ])),
+                    ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl'))
+                ]))
             ], ts.NodeFlags.Const)),
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('url'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('params')), ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('keys')), undefined, [
-                    ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('params')),
-                ]), ts.factory.createIdentifier('length')), ts.factory.createToken(ts.SyntaxKind.GreaterThanToken), ts.factory.createNumericLiteral('0'))), undefined, ts.factory.createCallExpression(ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([
-                    ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('entries')), undefined, [
-                        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('params')),
-                    ]), ts.factory.createIdentifier('filter')), undefined, [
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('url'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('params')), ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('keys')), undefined, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('params'))]), ts.factory.createIdentifier('length')), ts.factory.createToken(ts.SyntaxKind.GreaterThanToken), ts.factory.createNumericLiteral('0'))), undefined, ts.factory.createCallExpression(ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([
+                    ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('entries')), undefined, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('params'))]), ts.factory.createIdentifier('filter')), undefined, [
                         ts.factory.createArrowFunction(undefined, undefined, [
                             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createArrayBindingPattern([
                                 ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(''), undefined),
-                                ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('value'), undefined),
-                            ]), undefined, undefined),
-                        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createIdentifier('value'), ts.SyntaxKind.ExclamationEqualsEqualsToken, ts.factory.createIdentifier('undefined'))),
+                                ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('value'), undefined)
+                            ]), undefined, undefined)
+                        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createIdentifier('value'), ts.SyntaxKind.ExclamationEqualsEqualsToken, ts.factory.createIdentifier('undefined')))
                     ]), ts.factory.createIdentifier('forEach')), undefined, [
                         ts.factory.createArrowFunction(undefined, undefined, [
                             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createArrayBindingPattern([
                                 ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('key'), undefined),
-                                ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('value'), undefined),
-                            ]), undefined, undefined),
+                                ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('value'), undefined)
+                            ]), undefined, undefined)
                         ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([
                             ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseUrl'), ts.factory.createIdentifier('searchParams')), ts.factory.createIdentifier('set')), undefined, [
                                 ts.factory.createIdentifier('key'),
-                                ts.factory.createCallExpression(ts.factory.createIdentifier('String'), undefined, [ts.factory.createIdentifier('value')]),
-                            ])),
-                        ], false)),
+                                ts.factory.createCallExpression(ts.factory.createIdentifier('String'), undefined, [ts.factory.createIdentifier('value')])
+                            ]))
+                        ], false))
                     ])),
-                    ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseUrl'), ts.factory.createIdentifier('toString')), undefined, [])),
-                ], true))), undefined, []), undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseUrl'), ts.factory.createIdentifier('toString')), undefined, []))),
+                    ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseUrl'), ts.factory.createIdentifier('toString')), undefined, []))
+                ], true))), undefined, []), undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseUrl'), ts.factory.createIdentifier('toString')), undefined, [])))
             ], ts.NodeFlags.Const)),
             // Get base request options (headers, signal, credentials, etc.)
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseOptions'), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createIdentifier('getBaseRequestOptions')), undefined, [])),
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseOptions'), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createIdentifier('getBaseRequestOptions')), undefined, []))
             ], ts.NodeFlags.Const)),
             // Build Content-Type header
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('contentType'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('contentType')), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createStringLiteral('application/x-www-form-urlencoded', true)), undefined, ts.factory.createStringLiteral('application/x-www-form-urlencoded', true), undefined, ts.factory.createStringLiteral('application/json', true))),
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('contentType'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('contentType')), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createStringLiteral('application/x-www-form-urlencoded', true)), undefined, ts.factory.createStringLiteral('application/x-www-form-urlencoded', true), undefined, ts.factory.createStringLiteral('application/json', true)))
             ], ts.NodeFlags.Const)),
             // Merge headers: base headers, Content-Type, and request-specific headers
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseHeaders'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseOptions'), ts.factory.createIdentifier('headers')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')), undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseOptions'), ts.factory.createIdentifier('headers')), undefined, ts.factory.createObjectLiteralExpression([], false))),
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseHeaders'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseOptions'), ts.factory.createIdentifier('headers')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')), undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseOptions'), ts.factory.createIdentifier('headers')), undefined, ts.factory.createObjectLiteralExpression([], false)))
             ], ts.NodeFlags.Const)),
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
                 ts.factory.createVariableDeclaration(ts.factory.createIdentifier('headers'), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('assign')), undefined, [
                     ts.factory.createObjectLiteralExpression([], false),
                     ts.factory.createIdentifier('baseHeaders'),
-                    ts.factory.createObjectLiteralExpression([
-                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('Content-Type', true), ts.factory.createIdentifier('contentType')),
-                    ], false),
-                    ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('headers')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')), undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('headers')), undefined, ts.factory.createObjectLiteralExpression([], false)),
-                ])),
+                    ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('Content-Type', true), ts.factory.createIdentifier('contentType'))], false),
+                    ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('headers')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')), undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('headers')), undefined, ts.factory.createObjectLiteralExpression([], false))
+                ]))
             ], ts.NodeFlags.Const)),
             // Build body with form-urlencoded support
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
@@ -225,29 +406,25 @@ export class TypeScriptCodeGeneratorService {
                 // Form-urlencoded: convert object to URLSearchParams
                 ts.factory.createCallExpression(ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([
                     ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                        ts.factory.createVariableDeclaration(ts.factory.createIdentifier('params'), undefined, undefined, ts.factory.createNewExpression(ts.factory.createIdentifier('URLSearchParams'), undefined, [])),
+                        ts.factory.createVariableDeclaration(ts.factory.createIdentifier('params'), undefined, undefined, ts.factory.createNewExpression(ts.factory.createIdentifier('URLSearchParams'), undefined, []))
                     ], ts.NodeFlags.Const)),
-                    ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('entries')), undefined, [
-                        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('data')),
-                    ]), ts.factory.createIdentifier('forEach')), undefined, [
+                    ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('entries')), undefined, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('data'))]), ts.factory.createIdentifier('forEach')), undefined, [
                         ts.factory.createArrowFunction(undefined, undefined, [
                             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createArrayBindingPattern([
                                 ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('key'), undefined),
-                                ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('value'), undefined),
-                            ]), undefined, undefined),
+                                ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier('value'), undefined)
+                            ]), undefined, undefined)
                         ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([
                             ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('params'), ts.factory.createIdentifier('set')), undefined, [
                                 ts.factory.createIdentifier('key'),
-                                ts.factory.createCallExpression(ts.factory.createIdentifier('String'), undefined, [ts.factory.createIdentifier('value')]),
-                            ])),
-                        ], false)),
+                                ts.factory.createCallExpression(ts.factory.createIdentifier('String'), undefined, [ts.factory.createIdentifier('value')])
+                            ]))
+                        ], false))
                     ])),
-                    ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('params'), ts.factory.createIdentifier('toString')), undefined, [])),
+                    ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('params'), ts.factory.createIdentifier('toString')), undefined, []))
                 ], false))), undefined, []), undefined, 
                 // JSON: stringify the data
-                ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('JSON'), ts.factory.createIdentifier('stringify')), undefined, [
-                    ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('data')),
-                ])), undefined, ts.factory.createNull())),
+                ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('JSON'), ts.factory.createIdentifier('stringify')), undefined, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('data'))])), undefined, ts.factory.createNull()))
             ], ts.NodeFlags.Const)),
             // Make fetch request: merge base options with method, headers, and body
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
@@ -259,10 +436,10 @@ export class TypeScriptCodeGeneratorService {
                         ts.factory.createObjectLiteralExpression([
                             ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier('method'), undefined),
                             ts.factory.createPropertyAssignment(ts.factory.createIdentifier('headers'), ts.factory.createIdentifier('headers')),
-                            ts.factory.createPropertyAssignment(ts.factory.createIdentifier('body'), ts.factory.createIdentifier('body')),
-                        ], false),
-                    ]),
-                ]))),
+                            ts.factory.createPropertyAssignment(ts.factory.createIdentifier('body'), ts.factory.createIdentifier('body'))
+                        ], false)
+                    ])
+                ])))
             ], ts.NodeFlags.Const)),
             // Handle response through hook (allows subclasses to intercept and modify response)
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
@@ -270,18 +447,18 @@ export class TypeScriptCodeGeneratorService {
                     ts.factory.createIdentifier('rawResponse'),
                     ts.factory.createIdentifier('method'),
                     ts.factory.createIdentifier('path'),
-                    ts.factory.createIdentifier('options'),
-                ]))),
+                    ts.factory.createIdentifier('options')
+                ])))
             ], ts.NodeFlags.Const)),
             // Check response status
             ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('ok'))), ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier('Error'), undefined, [
                 ts.factory.createTemplateExpression(ts.factory.createTemplateHead('HTTP ', 'HTTP '), [
                     ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('status')), ts.factory.createTemplateMiddle(': ', ': ')),
-                    ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('statusText')), ts.factory.createTemplateTail('', '')),
-                ]),
+                    ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('statusText')), ts.factory.createTemplateTail('', ''))
+                ])
             ])), undefined),
             // Return parsed JSON
-            ts.factory.createReturnStatement(ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('json')), undefined, []))),
+            ts.factory.createReturnStatement(ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('json')), undefined, [])))
         ], true));
     }
     buildClientMethods(openapi, schemas) {
@@ -327,7 +504,7 @@ export class TypeScriptCodeGeneratorService {
                     // This will be handled in transformOperationName
                     const modifiedSchema = {
                         ...safeMethodSchema,
-                        operationId: `${operationId}_${methodLower}`,
+                        operationId: `${operationId}_${methodLower}`
                     };
                     return this.buildEndpointMethod(method, path, modifiedSchema, schemas);
                 }
@@ -352,7 +529,7 @@ export class TypeScriptCodeGeneratorService {
                 path,
                 ...(schema.tags !== undefined && { tags: schema.tags }),
                 ...(schema.summary !== undefined && { summary: schema.summary }),
-                ...(schema.description !== undefined && { description: schema.description }),
+                ...(schema.description !== undefined && { description: schema.description })
             };
             transformed = this.operationNameTransformer(details);
         }
@@ -391,9 +568,7 @@ export class TypeScriptCodeGeneratorService {
             }), false)
             : undefined;
         // Build request body
-        const requestBodyExpression = hasRequestBody
-            ? ts.factory.createIdentifier('body')
-            : undefined;
+        const requestBodyExpression = hasRequestBody ? ts.factory.createIdentifier('body') : undefined;
         // Build options object for makeRequest
         const optionsProps = [];
         if (queryParamsExpression) {
@@ -409,10 +584,32 @@ export class TypeScriptCodeGeneratorService {
         const optionsExpression = ts.factory.createObjectLiteralExpression(optionsProps, false);
         // Call makeRequest
         const makeRequestCall = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createIdentifier('makeRequest')), undefined, [ts.factory.createStringLiteral(method.toUpperCase(), true), pathExpression, optionsExpression]);
-        // Add Zod validation if we have a response schema
         if (responseSchema) {
-            const validateCall = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(responseSchema, ts.factory.createIdentifier('parse')), undefined, [ts.factory.createAwaitExpression(makeRequestCall)]);
-            statements.push(ts.factory.createReturnStatement(validateCall));
+            const schemaName = responseSchema.text;
+            const schemaNameLower = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
+            const parsedVarName = `parsed${schemaName}`;
+            // const response = await this.makeRequest(...)
+            statements.push(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration('response', undefined, undefined, ts.factory.createAwaitExpression(makeRequestCall))], ts.NodeFlags.Const)));
+            // const parsed{Name} = {Schema}.safeParse(response)
+            statements.push(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(parsedVarName, undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(responseSchema, ts.factory.createIdentifier('safeParse')), undefined, [
+                    ts.factory.createIdentifier('response')
+                ]))
+            ], ts.NodeFlags.Const)));
+            // if (!parsed{Name}.success) { throw new ResponseValidationError<{Type}>(...) }
+            statements.push(ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(parsedVarName), 'success')), ts.factory.createBlock([
+                ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier('ResponseValidationError'), [ts.factory.createTypeReferenceNode(schemaName)], [
+                    ts.factory.createTemplateExpression(ts.factory.createTemplateHead(`Invalid ${schemaNameLower}: `), [
+                        ts.factory.createTemplateSpan(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(parsedVarName), 'error'), 'errors'), 'map'), undefined, [
+                            ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'error')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('error'), 'message'))
+                        ]), 'join'), undefined, [ts.factory.createStringLiteral(', ', true)]), ts.factory.createTemplateTail(''))
+                    ]),
+                    ts.factory.createIdentifier('response'),
+                    ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(parsedVarName), 'error')
+                ]))
+            ], true)));
+            // return parsed{Name}.data
+            statements.push(ts.factory.createReturnStatement(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(parsedVarName), 'data')));
         }
         else {
             statements.push(ts.factory.createReturnStatement(ts.factory.createAwaitExpression(makeRequestCall)));
@@ -441,7 +638,7 @@ export class TypeScriptCodeGeneratorService {
                 matches.push({
                     index: match.index,
                     length: match[0].length,
-                    name: paramName,
+                    name: paramName
                 });
             }
         }
@@ -536,9 +733,7 @@ export class TypeScriptCodeGeneratorService {
             parameters.push(this.typeBuilder.createParameter('body', bodyType, undefined, !schema.requestBody?.required));
         }
         // Determine content type for request body
-        const contentType = hasRequestBody && schema.requestBody?.content?.['application/x-www-form-urlencoded']
-            ? 'application/x-www-form-urlencoded'
-            : 'application/json';
+        const contentType = hasRequestBody && schema.requestBody?.content?.['application/x-www-form-urlencoded'] ? 'application/x-www-form-urlencoded' : 'application/json';
         return { parameters, pathParams, queryParams, hasRequestBody, contentType };
     }
     getParameterType(schema) {
@@ -632,9 +827,7 @@ export class TypeScriptCodeGeneratorService {
         const responseDefault = schema.responses?.['default'];
         const response = response200 ?? response201 ?? responseDefault;
         if (!response?.content?.['application/json']?.schema) {
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-                ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
-            ]);
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)]);
         }
         const responseSchema = response.content['application/json'].schema;
         const typeName = this.getSchemaTypeName(responseSchema, schemas);
@@ -646,26 +839,22 @@ export class TypeScriptCodeGeneratorService {
             if (schemas[sanitizedItemTypeName]) {
                 // Use the type alias directly (it already uses z.infer)
                 return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-                    ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)),
+                    ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined))
                 ]);
             }
             // If it's a primitive array, use the type name as-is
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
-            ]);
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined)]);
         }
         const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
         // Check if it's a custom schema type (we have a type alias for it)
         if (schemas[sanitizedTypeName]) {
             // Use the type name directly (we have a type alias that already uses z.infer)
             return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedTypeName), undefined),
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedTypeName), undefined)
             ]);
         }
         // For primitive types and Record types, use the type name directly
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
-        ]);
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined)]);
     }
     buildServerConfiguration(openapi) {
         const servers = openapi.servers;
@@ -675,17 +864,13 @@ export class TypeScriptCodeGeneratorService {
         const statements = [];
         // Build server configuration array
         const serverConfigElements = servers.map((server) => {
-            const properties = [
-                ts.factory.createPropertyAssignment('url', ts.factory.createStringLiteral(server.url, true)),
-            ];
+            const properties = [ts.factory.createPropertyAssignment('url', ts.factory.createStringLiteral(server.url, true))];
             if (server.description) {
                 properties.push(ts.factory.createPropertyAssignment('description', ts.factory.createStringLiteral(server.description, true)));
             }
             if (server.variables && Object.keys(server.variables).length > 0) {
                 const variableProperties = Object.entries(server.variables).map(([varName, varDef]) => {
-                    const varProps = [
-                        ts.factory.createPropertyAssignment('default', ts.factory.createStringLiteral(varDef.default, true)),
-                    ];
+                    const varProps = [ts.factory.createPropertyAssignment('default', ts.factory.createStringLiteral(varDef.default, true))];
                     if (varDef.enum && varDef.enum.length > 0) {
                         varProps.push(ts.factory.createPropertyAssignment('enum', ts.factory.createArrayLiteralExpression(varDef.enum.map((val) => ts.factory.createStringLiteral(val, true)), false)));
                     }
@@ -700,22 +885,20 @@ export class TypeScriptCodeGeneratorService {
         });
         // Export server configuration
         statements.push(ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('serverConfigurations'), undefined, undefined, ts.factory.createArrayLiteralExpression(serverConfigElements, false)),
+            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('serverConfigurations'), undefined, undefined, ts.factory.createArrayLiteralExpression(serverConfigElements, false))
         ], ts.NodeFlags.Const)));
         // Export default base URL (first server with default variables)
         const firstServer = servers[0];
         const defaultBaseUrl = firstServer ? this.resolveServerUrl(firstServer, {}) : '/';
-        statements.push(ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('defaultBaseUrl'), undefined, undefined, ts.factory.createStringLiteral(defaultBaseUrl, true)),
-        ], ts.NodeFlags.Const)));
+        statements.push(ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier('defaultBaseUrl'), undefined, undefined, ts.factory.createStringLiteral(defaultBaseUrl, true))], ts.NodeFlags.Const)));
         // Build ClientOptions type
         const optionProperties = [
             ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('baseUrl'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)),
             ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)),
             ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('serverVariables'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
                 ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-            ])),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+            ]))
         ];
         statements.push(ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier('ClientOptions'), undefined, ts.factory.createTypeLiteralNode(optionProperties)));
         // Build resolveServerUrl helper function
@@ -735,14 +918,10 @@ export class TypeScriptCodeGeneratorService {
     buildResolveServerUrlFunction(servers) {
         // Build server configs array inline
         const serverConfigElements = servers.map((server) => {
-            const properties = [
-                ts.factory.createPropertyAssignment('url', ts.factory.createStringLiteral(server.url, true)),
-            ];
+            const properties = [ts.factory.createPropertyAssignment('url', ts.factory.createStringLiteral(server.url, true))];
             if (server.variables && Object.keys(server.variables).length > 0) {
                 const variableProperties = Object.entries(server.variables).map(([varName, varDef]) => {
-                    const varProps = [
-                        ts.factory.createPropertyAssignment('default', ts.factory.createStringLiteral(varDef.default, true)),
-                    ];
+                    const varProps = [ts.factory.createPropertyAssignment('default', ts.factory.createStringLiteral(varDef.default, true))];
                     if (varDef.enum && varDef.enum.length > 0) {
                         varProps.push(ts.factory.createPropertyAssignment('enum', ts.factory.createArrayLiteralExpression(varDef.enum.map((val) => ts.factory.createStringLiteral(val, true)), false)));
                     }
@@ -761,56 +940,47 @@ export class TypeScriptCodeGeneratorService {
         const value = ts.factory.createIdentifier('value');
         const bodyStatements = [
             // const configs = [...]
-            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(configs, undefined, undefined, ts.factory.createArrayLiteralExpression(serverConfigElements, false)),
-            ], ts.NodeFlags.Const)),
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(configs, undefined, undefined, ts.factory.createArrayLiteralExpression(serverConfigElements, false))], ts.NodeFlags.Const)),
             // const idx = serverIndex ?? 0
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(idx, undefined, undefined, ts.factory.createBinaryExpression(ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), ts.factory.createNumericLiteral('0'))),
+                ts.factory.createVariableDeclaration(idx, undefined, undefined, ts.factory.createBinaryExpression(ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), ts.factory.createNumericLiteral('0')))
             ], ts.NodeFlags.Const)),
             // if (idx < configs.length) { ... }
             ts.factory.createIfStatement(ts.factory.createBinaryExpression(idx, ts.factory.createToken(ts.SyntaxKind.LessThanToken), ts.factory.createPropertyAccessExpression(configs, ts.factory.createIdentifier('length'))), ts.factory.createBlock([
                 // const config = configs[idx]
-                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                    ts.factory.createVariableDeclaration(config, undefined, undefined, ts.factory.createElementAccessExpression(configs, idx)),
-                ], ts.NodeFlags.Const)),
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(config, undefined, undefined, ts.factory.createElementAccessExpression(configs, idx))], ts.NodeFlags.Const)),
                 // let url = config.url
-                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                    ts.factory.createVariableDeclaration(url, undefined, undefined, ts.factory.createPropertyAccessExpression(config, ts.factory.createIdentifier('url'))),
-                ], ts.NodeFlags.Let)),
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(url, undefined, undefined, ts.factory.createPropertyAccessExpression(config, ts.factory.createIdentifier('url')))], ts.NodeFlags.Let)),
                 // if (config.variables && serverVariables) { ... }
                 ts.factory.createIfStatement(ts.factory.createLogicalAnd(ts.factory.createPropertyAccessExpression(config, ts.factory.createIdentifier('variables')), ts.factory.createIdentifier('serverVariables')), ts.factory.createBlock([
                     // for (const [key, value] of Object.entries(serverVariables)) { url = url.replace(...) }
                     ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([
                         ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([
                             ts.factory.createBindingElement(undefined, undefined, key),
-                            ts.factory.createBindingElement(undefined, undefined, value),
-                        ]), undefined, undefined),
+                            ts.factory.createBindingElement(undefined, undefined, value)
+                        ]), undefined, undefined)
                     ], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('entries')), undefined, [ts.factory.createIdentifier('serverVariables')]), ts.factory.createBlock([
                         ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(url, ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(url, ts.factory.createIdentifier('replace')), undefined, [
                             ts.factory.createNewExpression(ts.factory.createIdentifier('RegExp'), undefined, [
                                 ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(ts.factory.createStringLiteral('\\{'), ts.factory.createToken(ts.SyntaxKind.PlusToken), key), ts.factory.createToken(ts.SyntaxKind.PlusToken), ts.factory.createStringLiteral('\\}')),
-                                ts.factory.createStringLiteral('g'),
+                                ts.factory.createStringLiteral('g')
                             ]),
-                            value,
-                        ]))),
-                    ], true)),
+                            value
+                        ])))
+                    ], true))
                 ], true)),
                 // return url
-                ts.factory.createReturnStatement(url),
+                ts.factory.createReturnStatement(url)
             ], true)),
             // return default (first server with defaults)
-            ts.factory.createReturnStatement(ts.factory.createStringLiteral(servers[0] ? this.resolveServerUrl(servers[0], {}) : '/', true)),
+            ts.factory.createReturnStatement(ts.factory.createStringLiteral(servers[0] ? this.resolveServerUrl(servers[0], {}) : '/', true))
         ];
         return ts.factory.createFunctionDeclaration(undefined, undefined, ts.factory.createIdentifier('resolveServerUrl'), undefined, [
-            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createUnionTypeNode([
-                ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-                ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-            ]), undefined),
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createUnionTypeNode([ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)]), undefined),
             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('serverVariables'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
                 ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-            ]), ts.factory.createObjectLiteralExpression([], false)),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+            ]), ts.factory.createObjectLiteralExpression([], false))
         ], ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), ts.factory.createBlock(bodyStatements, true));
     }
     generateClientName(title) {
@@ -914,9 +1084,7 @@ export class TypeScriptCodeGeneratorService {
         const prop = safeProperty.data;
         if (this.isReference(prop)) {
             const refSchema = this.buildFromReference(prop);
-            return required
-                ? refSchema
-                : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(refSchema, ts.factory.createIdentifier('optional')), undefined, []);
+            return required ? refSchema : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(refSchema, ts.factory.createIdentifier('optional')), undefined, []);
         }
         if (prop['anyOf'] && Array.isArray(prop['anyOf']) && prop['anyOf'].length > 0) {
             return this.handleLogicalOperator('anyOf', prop['anyOf'], required);
@@ -964,7 +1132,9 @@ export class TypeScriptCodeGeneratorService {
                     else {
                         literalValue = ts.factory.createStringLiteral(String(val), true);
                     }
-                    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('literal')), undefined, [literalValue]);
+                    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('literal')), undefined, [
+                        literalValue
+                    ]);
                 });
                 const unionExpression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('union')), undefined, [ts.factory.createArrayLiteralExpression(literalSchemas, false)]);
                 return required
@@ -978,15 +1148,19 @@ export class TypeScriptCodeGeneratorService {
                 let arraySchema = this.buildZodAST([
                     {
                         type: 'array',
-                        args: [itemsSchema],
-                    },
+                        args: [itemsSchema]
+                    }
                 ]);
                 // Apply array constraints
                 if (typeof prop['minItems'] === 'number') {
-                    arraySchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(arraySchema, ts.factory.createIdentifier('min')), undefined, [ts.factory.createNumericLiteral(String(prop['minItems']))]);
+                    arraySchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(arraySchema, ts.factory.createIdentifier('min')), undefined, [
+                        ts.factory.createNumericLiteral(String(prop['minItems']))
+                    ]);
                 }
                 if (typeof prop['maxItems'] === 'number') {
-                    arraySchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(arraySchema, ts.factory.createIdentifier('max')), undefined, [ts.factory.createNumericLiteral(String(prop['maxItems']))]);
+                    arraySchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(arraySchema, ts.factory.createIdentifier('max')), undefined, [
+                        ts.factory.createNumericLiteral(String(prop['maxItems']))
+                    ]);
                 }
                 return required
                     ? arraySchema
@@ -1004,9 +1178,9 @@ export class TypeScriptCodeGeneratorService {
                             args: [
                                 ts.factory.createObjectLiteralExpression(propertiesEntries.map(([name, propValue]) => {
                                     return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(name), this.buildProperty(propValue, propRequired.includes(name)));
-                                }), true),
-                            ],
-                        },
+                                }), true)
+                            ]
+                        }
                     ]);
                     // Apply object constraints
                     let constrainedSchema = objectSchema;
@@ -1014,16 +1188,16 @@ export class TypeScriptCodeGeneratorService {
                         constrainedSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(constrainedSchema, ts.factory.createIdentifier('refine')), undefined, [
                             ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'obj', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('keys')), undefined, [ts.factory.createIdentifier('obj')]), ts.factory.createIdentifier('length')), ts.factory.createToken(ts.SyntaxKind.GreaterThanEqualsToken), ts.factory.createNumericLiteral(String(prop['minProperties'])))),
                             ts.factory.createObjectLiteralExpression([
-                                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Object must have at least ${String(prop['minProperties'])} properties`)),
-                            ]),
+                                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Object must have at least ${String(prop['minProperties'])} properties`))
+                            ])
                         ]);
                     }
                     if (typeof prop['maxProperties'] === 'number') {
                         constrainedSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(constrainedSchema, ts.factory.createIdentifier('refine')), undefined, [
                             ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'obj', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('keys')), undefined, [ts.factory.createIdentifier('obj')]), ts.factory.createIdentifier('length')), ts.factory.createToken(ts.SyntaxKind.LessThanEqualsToken), ts.factory.createNumericLiteral(String(prop['maxProperties'])))),
                             ts.factory.createObjectLiteralExpression([
-                                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Object must have at most ${String(prop['maxProperties'])} properties`)),
-                            ]),
+                                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Object must have at most ${String(prop['maxProperties'])} properties`))
+                            ])
                         ]);
                     }
                     return required
@@ -1033,31 +1207,30 @@ export class TypeScriptCodeGeneratorService {
                 return this.buildZodAST([
                     {
                         type: 'record',
-                        args: [this.buildZodAST(['string']), this.buildZodAST(['unknown'])],
-                    },
+                        args: [this.buildZodAST(['string']), this.buildZodAST(['unknown'])]
+                    }
                 ]);
             }
             case 'integer': {
                 let numberSchema = this.buildZodAST(['number', 'int']);
                 // Apply number constraints
                 if (prop['minimum'] !== undefined && typeof prop['minimum'] === 'number') {
-                    const minValue = prop['exclusiveMinimum'] && typeof prop['exclusiveMinimum'] === 'boolean'
-                        ? prop['minimum'] + 1
-                        : prop['minimum'];
+                    const minValue = prop['exclusiveMinimum'] && typeof prop['exclusiveMinimum'] === 'boolean' ? prop['minimum'] + 1 : prop['minimum'];
                     numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier(prop['exclusiveMinimum'] && typeof prop['exclusiveMinimum'] === 'boolean' ? 'gt' : 'gte')), undefined, [ts.factory.createNumericLiteral(String(minValue))]);
                 }
                 if (prop['maximum'] !== undefined && typeof prop['maximum'] === 'number') {
-                    const maxValue = prop['exclusiveMaximum'] && typeof prop['exclusiveMaximum'] === 'boolean'
-                        ? prop['maximum'] - 1
-                        : prop['maximum'];
+                    const maxValue = prop['exclusiveMaximum'] && typeof prop['exclusiveMaximum'] === 'boolean' ? prop['maximum'] - 1 : prop['maximum'];
                     numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier(prop['exclusiveMaximum'] ? 'lt' : 'lte')), undefined, [ts.factory.createNumericLiteral(String(maxValue))]);
                 }
                 if (typeof prop['multipleOf'] === 'number') {
                     const refineFunction = ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'val', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(ts.factory.createIdentifier('val'), ts.factory.createToken(ts.SyntaxKind.PercentToken), ts.factory.createNumericLiteral(String(prop['multipleOf']))), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createNumericLiteral('0')));
                     const refineOptions = ts.factory.createObjectLiteralExpression([
-                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Number must be a multiple of ${String(prop['multipleOf'])}`)),
+                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Number must be a multiple of ${String(prop['multipleOf'])}`))
+                    ]);
+                    numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier('refine')), undefined, [
+                        refineFunction,
+                        refineOptions
                     ]);
-                    numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier('refine')), undefined, [refineFunction, refineOptions]);
                 }
                 return required
                     ? numberSchema
@@ -1067,23 +1240,22 @@ export class TypeScriptCodeGeneratorService {
                 let numberSchema = this.buildZodAST(['number']);
                 // Apply number constraints
                 if (prop['minimum'] !== undefined && typeof prop['minimum'] === 'number') {
-                    const minValue = prop['exclusiveMinimum'] && typeof prop['exclusiveMinimum'] === 'boolean'
-                        ? prop['minimum'] + 1
-                        : prop['minimum'];
+                    const minValue = prop['exclusiveMinimum'] && typeof prop['exclusiveMinimum'] === 'boolean' ? prop['minimum'] + 1 : prop['minimum'];
                     numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier(prop['exclusiveMinimum'] && typeof prop['exclusiveMinimum'] === 'boolean' ? 'gt' : 'gte')), undefined, [ts.factory.createNumericLiteral(String(minValue))]);
                 }
                 if (prop['maximum'] !== undefined && typeof prop['maximum'] === 'number') {
-                    const maxValue = prop['exclusiveMaximum'] && typeof prop['exclusiveMaximum'] === 'boolean'
-                        ? prop['maximum'] - 1
-                        : prop['maximum'];
+                    const maxValue = prop['exclusiveMaximum'] && typeof prop['exclusiveMaximum'] === 'boolean' ? prop['maximum'] - 1 : prop['maximum'];
                     numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier(prop['exclusiveMaximum'] ? 'lt' : 'lte')), undefined, [ts.factory.createNumericLiteral(String(maxValue))]);
                 }
                 if (typeof prop['multipleOf'] === 'number') {
                     const refineFunction = ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'val', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(ts.factory.createIdentifier('val'), ts.factory.createToken(ts.SyntaxKind.PercentToken), ts.factory.createNumericLiteral(String(prop['multipleOf']))), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createNumericLiteral('0')));
                     const refineOptions = ts.factory.createObjectLiteralExpression([
-                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Number must be a multiple of ${String(prop['multipleOf'])}`)),
+                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral(`Number must be a multiple of ${String(prop['multipleOf'])}`))
+                    ]);
+                    numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier('refine')), undefined, [
+                        refineFunction,
+                        refineOptions
                     ]);
-                    numberSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(numberSchema, ts.factory.createIdentifier('refine')), undefined, [refineFunction, refineOptions]);
                 }
                 return required
                     ? numberSchema
@@ -1118,22 +1290,26 @@ export class TypeScriptCodeGeneratorService {
                 }
                 // Apply string constraints
                 if (typeof prop['minLength'] === 'number') {
-                    stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('min')), undefined, [ts.factory.createNumericLiteral(String(prop['minLength']))]);
+                    stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('min')), undefined, [
+                        ts.factory.createNumericLiteral(String(prop['minLength']))
+                    ]);
                 }
                 if (typeof prop['maxLength'] === 'number') {
-                    stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('max')), undefined, [ts.factory.createNumericLiteral(String(prop['maxLength']))]);
+                    stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('max')), undefined, [
+                        ts.factory.createNumericLiteral(String(prop['maxLength']))
+                    ]);
                 }
                 if (prop['pattern'] && typeof prop['pattern'] === 'string') {
                     stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('regex')), undefined, [
-                        ts.factory.createNewExpression(ts.factory.createIdentifier('RegExp'), undefined, [
-                            ts.factory.createStringLiteral(prop['pattern'], true),
-                        ]),
+                        ts.factory.createNewExpression(ts.factory.createIdentifier('RegExp'), undefined, [ts.factory.createStringLiteral(prop['pattern'], true)])
                     ]);
                 }
                 // Apply default value if not required
                 if (!required && prop['default'] !== undefined) {
                     const defaultValue = this.buildDefaultValue(prop['default']);
-                    stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('default')), undefined, [defaultValue]);
+                    stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('default')), undefined, [
+                        defaultValue
+                    ]);
                 }
                 return required
                     ? stringSchema
@@ -1143,12 +1319,10 @@ export class TypeScriptCodeGeneratorService {
                 let booleanSchema = this.buildZodAST(['boolean']);
                 // Apply default value if not required
                 if (!required && prop['default'] !== undefined) {
-                    const defaultValue = typeof prop['default'] === 'boolean'
-                        ? prop['default']
-                            ? ts.factory.createTrue()
-                            : ts.factory.createFalse()
-                        : ts.factory.createFalse();
-                    booleanSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(booleanSchema, ts.factory.createIdentifier('default')), undefined, [defaultValue]);
+                    const defaultValue = typeof prop['default'] === 'boolean' ? (prop['default'] ? ts.factory.createTrue() : ts.factory.createFalse()) : ts.factory.createFalse();
+                    booleanSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(booleanSchema, ts.factory.createIdentifier('default')), undefined, [
+                        defaultValue
+                    ]);
                 }
                 return required
                     ? booleanSchema
@@ -1200,7 +1374,9 @@ export class TypeScriptCodeGeneratorService {
             case 'anyOf':
             case 'oneOf': {
                 const unionSchemas = schemas.map((schema) => this.buildSchemaFromLogicalOperator(schema));
-                return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('union')), undefined, [ts.factory.createArrayLiteralExpression(unionSchemas, false)]);
+                return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('union')), undefined, [
+                    ts.factory.createArrayLiteralExpression(unionSchemas, false)
+                ]);
             }
             case 'allOf': {
                 if (schemas.length === 0) {
@@ -1215,10 +1391,12 @@ export class TypeScriptCodeGeneratorService {
             case 'not': {
                 const notSchema = this.buildSchemaFromLogicalOperator(schemas[0]);
                 return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('any')), ts.factory.createIdentifier('refine')), undefined, [
-                    ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'val', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(notSchema, ts.factory.createIdentifier('safeParse')), undefined, [ts.factory.createIdentifier('val')]))),
+                    ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'val', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(notSchema, ts.factory.createIdentifier('safeParse')), undefined, [
+                        ts.factory.createIdentifier('val')
+                    ]))),
                     ts.factory.createObjectLiteralExpression([
-                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral('Value must not match the excluded schema')),
-                    ]),
+                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral('Value must not match the excluded schema'))
+                    ])
                 ]);
             }
             default:
@@ -1267,16 +1445,16 @@ export class TypeScriptCodeGeneratorService {
                     args: [
                         ts.factory.createObjectLiteralExpression(properties.map(([name, property]) => {
                             return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(name), this.buildSchemaFromLogicalOperator(property));
-                        }), true),
-                    ],
-                },
+                        }), true)
+                    ]
+                }
             ]);
         }
         return this.buildZodAST([
             {
                 type: 'record',
-                args: [this.buildZodAST(['string']), this.buildZodAST(['unknown'])],
-            },
+                args: [this.buildZodAST(['string']), this.buildZodAST(['unknown'])]
+            }
         ]);
     }
     buildArrayTypeFromSchema(schemaObj) {
@@ -1284,8 +1462,8 @@ export class TypeScriptCodeGeneratorService {
             return this.buildZodAST([
                 {
                     type: 'array',
-                    args: [this.buildSchemaFromLogicalOperator(schemaObj.items)],
-                },
+                    args: [this.buildSchemaFromLogicalOperator(schemaObj.items)]
+                }
             ]);
         }
         return this.buildZodAST(['array']);
@@ -1305,7 +1483,7 @@ export class TypeScriptCodeGeneratorService {
         if (this.isCircularReference(refName)) {
             // Generate: z.lazy(() => RefSchema)
             return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('lazy')), undefined, [
-                ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createIdentifier(sanitizedRefName)),
+                ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createIdentifier(sanitizedRefName))
             ]);
         }
         return ts.factory.createIdentifier(sanitizedRefName);
@@ -1323,9 +1501,7 @@ export class TypeScriptCodeGeneratorService {
         }
         // Case 2: Reference to a schema that's part of a circular dependency chain
         // and we're currently building a schema that's also in that chain
-        if (this.circularSchemas.has(refName) &&
-            this.currentSchemaName !== null &&
-            this.circularSchemas.has(this.currentSchemaName)) {
+        if (this.circularSchemas.has(refName) && this.currentSchemaName !== null && this.circularSchemas.has(this.currentSchemaName)) {
             return true;
         }
         return false;
@@ -1340,11 +1516,7 @@ export class TypeScriptCodeGeneratorService {
         // Build dependency graph
         const graph = new Map();
         for (const [name, schema] of Object.entries(schemas)) {
-            const dependencies = jp
-                .query(schema, '$..["$ref"]')
-                .filter((ref) => ref.startsWith('#/components/schemas/'))
-                .map((ref) => ref.replace('#/components/schemas/', ''))
-                .filter((dep) => dep in schemas);
+            const dependencies = this.extractSchemaReferences(schema).filter((dep) => dep in schemas);
             graph.set(name, dependencies);
         }
         // Tarjan's algorithm for finding SCCs
@@ -1422,10 +1594,7 @@ export class TypeScriptCodeGeneratorService {
             }
             visiting.add(name);
             const schema = schemas[name];
-            const dependencies = jp
-                .query(schema, '$..["$ref"]')
-                .filter((ref) => ref.startsWith('#/components/schemas/'))
-                .map((ref) => ref.replace('#/components/schemas/', ''));
+            const dependencies = this.extractSchemaReferences(schema);
             for (const dep of dependencies) {
                 if (schemas[dep]) {
                     visit(dep);