zod-codegen 1.6.2 → 1.6.3

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## <small>1.6.3 (2026-01-22)</small>
+
+- fix: do not depend on inference anymore and build strict types all ar… (#60) ([b0b663e](https://github.com/julienandreu/zod-codegen/commit/b0b663e)), closes [#60](https://github.com/julienandreu/zod-codegen/issues/60)
+
 ## <small>1.6.2 (2026-01-19)</small>
 
 - fix: improve URL construction and filter undefined query params (#58) ([b9c3d32](https://github.com/julienandreu/zod-codegen/commit/b9c3d32)), closes [#58](https://github.com/julienandreu/zod-codegen/issues/58)

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

@@ -17,6 +17,27 @@ export declare class TypeScriptCodeGeneratorService implements CodeGenerator, Sc
     private buildAST;
     private buildSchemas;
     private buildSchemaTypeAliases;
+    /**
+     * Builds explicit TypeScript type declarations for all schemas.
+     * Returns interface declarations for object types and type aliases for other types.
+     */
+    private buildExplicitTypeDeclarations;
+    /**
+     * Converts an OpenAPI schema to a TypeScript type node.
+     */
+    private buildTypeNode;
+    /**
+     * Builds the base type node without nullable handling.
+     */
+    private buildBaseTypeNode;
+    /**
+     * Builds a TypeScript type literal for an object schema.
+     */
+    private buildObjectTypeLiteral;
+    /**
+     * Builds a TypeScript interface declaration for an object schema.
+     */
+    private buildInterfaceDeclaration;
     private buildClientClass;
     private buildConstructor;
     private buildGetBaseRequestOptionsMethod;

package/dist/src/services/code-generator.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generator.service.d.ts","sourceRoot":"","sources":["../../../src/services/code-generator.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAC/E,OAAO,KAAK,EAAmB,eAAe,EAAgB,MAAM,kBAAkB,CAAC;AACvF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAWjE,qBAAa,8BAA+B,YAAW,aAAa,EAAE,aAAa;IACjF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAwC;IACtE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwD;IAChF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA+B;IAChE,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAuC;IAGhF,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,iBAAiB,CAAuB;gBAEpC,OAAO,GAAE,gBAAqB;IAK1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAGpB;IAEH,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM;IAMvC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,UAAO,GAAG,EAAE,CAAC,cAAc,GAAG,EAAE,CAAC,UAAU;IA2BhF,OAAO,CAAC,QAAQ;IAmBhB,OAAO,CAAC,YAAY;IA2CpB,OAAO,CAAC,sBAAsB;IAe9B,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,gBAAgB;IAmGxB,OAAO,CAAC,gCAAgC;IAwBxC,OAAO,CAAC,yBAAyB;IAuBjC,OAAO,CAAC,sBAAsB;IA8pB9B,OAAO,CAAC,kBAAkB;IAgE1B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAoC9B,OAAO,CAAC,mBAAmB;IAgH3B,OAAO,CAAC,mBAAmB;IA6D3B,OAAO,CAAC,qBAAqB;IAwF7B,OAAO,CAAC,gBAAgB;IA0CxB,OAAO,CAAC,iBAAiB;IAmCzB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,eAAe;IAuDvB,OAAO,CAAC,wBAAwB;IA4IhC,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,6BAA6B;IAkPrC,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuFzB,OAAO,CAAC,WAAW;IA0CnB,OAAO,CAAC,aAAa;IAmjBrB,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,oBAAoB;IAyE5B,OAAO,CAAC,8BAA8B;IActC,OAAO,CAAC,wBAAwB;IAyBhC,OAAO,CAAC,yBAAyB;IA8BjC,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,kBAAkB;IA8B1B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAmB3B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAiFlC,OAAO,CAAC,eAAe;CAuCxB"}
+{"version":3,"file":"code-generator.service.d.ts","sourceRoot":"","sources":["../../../src/services/code-generator.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAC/E,OAAO,KAAK,EAAmB,eAAe,EAAgB,MAAM,kBAAkB,CAAC;AACvF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAWjE,qBAAa,8BAA+B,YAAW,aAAa,EAAE,aAAa;IACjF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAwC;IACtE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwD;IAChF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA+B;IAChE,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAuC;IAGhF,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,iBAAiB,CAAuB;gBAEpC,OAAO,GAAE,gBAAqB;IAK1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAGpB;IAEH,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM;IAMvC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,UAAO,GAAG,EAAE,CAAC,cAAc,GAAG,EAAE,CAAC,UAAU;IA2BhF,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,YAAY;IAmDpB,OAAO,CAAC,sBAAsB;IAK9B;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAkDrC;;OAEG;IACH,OAAO,CAAC,aAAa;IA2BrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA2EzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAgB9B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyBjC,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,gBAAgB;IAmGxB,OAAO,CAAC,gCAAgC;IAwBxC,OAAO,CAAC,yBAAyB;IAuBjC,OAAO,CAAC,sBAAsB;IA8pB9B,OAAO,CAAC,kBAAkB;IAgE1B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAoC9B,OAAO,CAAC,mBAAmB;IAgH3B,OAAO,CAAC,mBAAmB;IA6D3B,OAAO,CAAC,qBAAqB;IAwF7B,OAAO,CAAC,gBAAgB;IA0CxB,OAAO,CAAC,iBAAiB;IAmCzB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,eAAe;IAuDvB,OAAO,CAAC,wBAAwB;IA4IhC,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,6BAA6B;IAkPrC,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuFzB,OAAO,CAAC,WAAW;IA0CnB,OAAO,CAAC,aAAa;IAmjBrB,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,oBAAoB;IAyE5B,OAAO,CAAC,8BAA8B;IActC,OAAO,CAAC,wBAAwB;IAyBhC,OAAO,CAAC,yBAAyB;IA8BjC,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,kBAAkB;IA8B1B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAmB3B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAiFlC,OAAO,CAAC,eAAe;CAuCxB"}

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

@@ -53,9 +53,12 @@ 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,
@@ -79,8 +82,11 @@ export class TypeScriptCodeGeneratorService {
             const schemaExpression = this.buildSchema(schema);
             // Clear context
             this.currentSchemaName = null;
+            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(this.typeBuilder.sanitizeIdentifier(name)), undefined, undefined, schemaExpression),
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier(sanitizedName), undefined, typeAnnotation, schemaExpression),
             ], ts.NodeFlags.Const));
             return {
                 ...schemaRegistered,
@@ -88,11 +94,157 @@ export class TypeScriptCodeGeneratorService {
             };
         }, {});
     }
-    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);
     }
     buildClientClass(openapi, schemas) {
         const clientName = this.generateClientName(openapi.info.title);

package/generated/type.ts

@@ -1,6 +1,6 @@
 // THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-// Built with zod-codegen@1.6.2
-// Latest edit: Mon, 19 Jan 2026 15:14:43 GMT
+// Built with zod-codegen@1.6.3
+// Latest edit: Thu, 22 Jan 2026 16:08:32 GMT
 // Source file: ./samples/swagger-petstore.yaml
 /* eslint-disable */
 // @ts-nocheck
@@ -10,9 +10,62 @@
 ;
 import { z } from 'zod';
 
+// Explicit type declarations
+;
+export interface Order {
+    id?: number;
+    petId?: number;
+    quantity?: number;
+    shipDate?: string;
+    status?: 'placed' | 'approved' | 'delivered';
+    complete?: boolean;
+}
+export interface Address {
+    street?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+}
+export interface Customer {
+    id?: number;
+    username?: string;
+    address?: Address[];
+}
+export interface Category {
+    id?: number;
+    name?: string;
+}
+export interface User {
+    id?: number;
+    username?: string;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    password?: string;
+    phone?: string;
+    userStatus?: number;
+}
+export interface Tag {
+    id?: number;
+    name?: string;
+}
+export interface Pet {
+    id?: number;
+    name: string;
+    category?: Category;
+    photoUrls: string[];
+    tags?: Tag[];
+    status?: 'available' | 'pending' | 'sold';
+}
+export interface ApiResponse {
+    code?: number;
+    type?: string;
+    message?: string;
+}
+
 // Components schemas
 ;
-export const Order = z.object({
+export const Order: z.ZodType<Order> = z.object({
     id: z.number().int().optional(),
     petId: z.number().int().optional(),
     quantity: z.number().int().optional(),
@@ -22,22 +75,22 @@ export const Order = z.object({
     status: z.enum(['placed', 'approved', 'delivered']).optional(),
     complete: z.boolean().optional()
 });
-export const Address = z.object({
+export const Address: z.ZodType<Address> = z.object({
     street: z.string().optional(),
     city: z.string().optional(),
     state: z.string().optional(),
     zip: z.string().optional()
 });
-export const Customer = z.object({
+export const Customer: z.ZodType<Customer> = z.object({
     id: z.number().int().optional(),
     username: z.string().optional(),
     address: z.array(Address).optional()
 });
-export const Category = z.object({
+export const Category: z.ZodType<Category> = z.object({
     id: z.number().int().optional(),
     name: z.string().optional()
 });
-export const User = z.object({
+export const User: z.ZodType<User> = z.object({
     id: z.number().int().optional(),
     username: z.string().optional(),
     firstName: z.string().optional(),
@@ -47,11 +100,11 @@ export const User = z.object({
     phone: z.string().optional(),
     userStatus: z.number().int().optional()
 });
-export const Tag = z.object({
+export const Tag: z.ZodType<Tag> = z.object({
     id: z.number().int().optional(),
     name: z.string().optional()
 });
-export const Pet = z.object({
+export const Pet: z.ZodType<Pet> = z.object({
     id: z.number().int().optional(),
     name: z.string(),
     category: Category.optional(),
@@ -59,19 +112,11 @@ export const Pet = z.object({
     tags: z.array(Tag).optional(),
     status: z.enum(['available', 'pending', 'sold']).optional()
 });
-export const ApiResponse = z.object({
+export const ApiResponse: z.ZodType<ApiResponse> = z.object({
     code: z.number().int().optional(),
     type: z.string().optional(),
     message: z.string().optional()
 });
-export type Order = z.infer<typeof Order>;
-export type Address = z.infer<typeof Address>;
-export type Customer = z.infer<typeof Customer>;
-export type Category = z.infer<typeof Category>;
-export type User = z.infer<typeof User>;
-export type Tag = z.infer<typeof Tag>;
-export type Pet = z.infer<typeof Pet>;
-export type ApiResponse = z.infer<typeof ApiResponse>;
 export const serverConfigurations = [{
         url: 'https://petstore3.swagger.io/api/v3'
     }];

package/package.json

@@ -105,5 +105,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.6.2"
+  "version": "1.6.3"
 }

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

@@ -75,9 +75,13 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     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,
@@ -108,14 +112,22 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
       // Clear context
       this.currentSchemaName = null;
 
+      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(this.typeBuilder.sanitizeIdentifier(name)),
-              undefined,
+              ts.factory.createIdentifier(sanitizedName),
               undefined,
+              typeAnnotation,
               schemaExpression,
             ),
           ],
@@ -130,19 +142,218 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     }, {});
   }
 
-  private buildSchemaTypeAliases(schemas: Record<string, ts.VariableStatement>): ts.TypeAliasDeclaration[] {
-    return Object.keys(schemas).map((name) => {
+  private buildSchemaTypeAliases(_schemas: Record<string, ts.VariableStatement>): ts.TypeAliasDeclaration[] {
+    // 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.
+   */
+  private buildExplicitTypeDeclarations(openapi: OpenApiSpecType): ts.Statement[] {
+    const schemasEntries = Object.entries(openapi.components?.schemas ?? {});
+    const schemasMap = Object.fromEntries(schemasEntries);
+    const sortedSchemaNames = this.topologicalSort(schemasMap);
+
+    const statements: ts.Statement[] = [];
+
+    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.
+   */
+  private buildTypeNode(schema: unknown): ts.TypeNode {
+    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.
+   */
+  private buildBaseTypeNode(prop: Record<string, unknown>): ts.TypeNode {
+    // Handle anyOf/oneOf (union types)
+    if (prop['anyOf'] && Array.isArray(prop['anyOf']) && prop['anyOf'].length > 0) {
+      const types = prop['anyOf'].map((s: unknown) => 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: unknown) => 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: unknown) => 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: unknown) => {
+        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'] ?? {}) as Record<string, unknown>;
+        const requiredProps = (prop['required'] ?? []) as string[];
+
+        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.
+   */
+  private buildObjectTypeLiteral(properties: Record<string, unknown>, requiredProps: string[]): ts.TypeLiteralNode {
+    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.
+   */
+  private buildInterfaceDeclaration(name: string, schema: Record<string, unknown>): ts.InterfaceDeclaration {
+    const properties = (schema['properties'] ?? {}) as Record<string, unknown>;
+    const requiredProps = (schema['required'] ?? []) as string[];
+
+    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,
+    );
   }
 
   private buildClientClass(

package/tests/unit/code-generator.test.ts

@@ -1085,4 +1085,309 @@ describe('TypeScriptCodeGeneratorService', () => {
       expect(code).toContain('https://{env}.example.com');
     });
   });
+
+  describe('explicit types', () => {
+    it('should generate explicit interface for object schema', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Order: {
+              type: 'object',
+              properties: {
+                id: {type: 'integer'},
+                name: {type: 'string'},
+              },
+              required: ['id', 'name'],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate explicit interface
+      expect(code).toContain('export interface Order');
+      expect(code).toContain('id: number');
+      expect(code).toContain('name: string');
+
+      // Should add type annotation to schema
+      expect(code).toContain('export const Order: z.ZodType<Order>');
+
+      // Should NOT generate z.infer type export
+      expect(code).not.toContain('z.infer<typeof Order>');
+    });
+
+    it('should generate type alias for enum schema', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Status: {
+              type: 'string',
+              enum: ['active', 'inactive', 'pending'],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate type alias (not interface) for enum
+      expect(code).toContain('export type Status');
+      expect(code).toContain("'active'");
+      expect(code).toContain("'inactive'");
+      expect(code).toContain("'pending'");
+
+      // Should add type annotation to schema
+      expect(code).toContain('export const Status: z.ZodType<Status>');
+    });
+
+    it('should generate type alias for array schema', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Tags: {
+              type: 'array',
+              items: {type: 'string'},
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate type alias for array
+      expect(code).toContain('export type Tags = string[]');
+
+      // Should add type annotation to schema
+      expect(code).toContain('export const Tags: z.ZodType<Tags>');
+    });
+
+    it('should handle nested objects with references', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            User: {
+              type: 'object',
+              properties: {
+                id: {type: 'integer'},
+                profile: {$ref: '#/components/schemas/Profile'},
+              },
+              required: ['id'],
+            },
+            Profile: {
+              type: 'object',
+              properties: {
+                name: {type: 'string'},
+              },
+              required: ['name'],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate interfaces for both
+      expect(code).toContain('export interface User');
+      expect(code).toContain('export interface Profile');
+
+      // User should reference Profile type
+      expect(code).toContain('profile?: Profile');
+
+      // Both should have type annotations
+      expect(code).toContain('export const User: z.ZodType<User>');
+      expect(code).toContain('export const Profile: z.ZodType<Profile>');
+    });
+
+    it('should handle union types (anyOf)', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            StringOrNumber: {
+              anyOf: [{type: 'string'}, {type: 'number'}],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate type alias for union
+      expect(code).toContain('export type StringOrNumber = string | number');
+
+      // Should add type annotation to schema
+      expect(code).toContain('export const StringOrNumber: z.ZodType<StringOrNumber>');
+    });
+
+    it('should handle intersection types (allOf)', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Base: {
+              type: 'object',
+              properties: {
+                id: {type: 'integer'},
+              },
+              required: ['id'],
+            },
+            Extended: {
+              allOf: [
+                {$ref: '#/components/schemas/Base'},
+                {
+                  type: 'object',
+                  properties: {
+                    name: {type: 'string'},
+                  },
+                },
+              ],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate interface for Base
+      expect(code).toContain('export interface Base');
+
+      // Should generate type alias for Extended (intersection)
+      expect(code).toContain('export type Extended = Base &');
+
+      // Should add type annotations to schemas
+      expect(code).toContain('export const Base: z.ZodType<Base>');
+      expect(code).toContain('export const Extended: z.ZodType<Extended>');
+    });
+
+    it('should handle optional properties', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            User: {
+              type: 'object',
+              properties: {
+                id: {type: 'integer'},
+                email: {type: 'string'},
+              },
+              required: ['id'],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // id should be required (no ?)
+      expect(code).toContain('id: number');
+      // email should be optional (with ?)
+      expect(code).toContain('email?: string');
+    });
+
+    it('should handle circular dependencies', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Node: {
+              type: 'object',
+              properties: {
+                id: {type: 'integer'},
+                children: {
+                  type: 'array',
+                  items: {$ref: '#/components/schemas/Node'},
+                },
+              },
+              required: ['id'],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate interface with self-reference
+      expect(code).toContain('export interface Node');
+      expect(code).toContain('children?: Node[]');
+
+      // Should add type annotation to schema
+      expect(code).toContain('export const Node: z.ZodType<Node>');
+
+      // Zod schema should use z.lazy for circular reference
+      expect(code).toContain('z.lazy');
+    });
+
+    it('should handle numeric enum types', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Priority: {
+              type: 'integer',
+              enum: [0, 1, 2],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should generate type alias for numeric enum
+      expect(code).toContain('export type Priority');
+      expect(code).toMatch(/0\s*\|\s*1\s*\|\s*2/);
+
+      // Should add type annotation to schema
+      expect(code).toContain('export const Priority: z.ZodType<Priority>');
+    });
+  });
 });