Emit type for enum dependencies of circular schemas, not just object dependencies

lib/src/generateZodClientFromOpenAPI.test.ts

@@ -3816,6 +3816,7 @@ test("with optional, partial, all required objects", async () => {
           "emittedType": {
               "Nested2": true,
               "Root2": true,
+              "VeryDeeplyNested": true,
           },
           "endpoints": [
               {
@@ -3916,7 +3917,11 @@ test("with optional, partial, all required objects", async () => {
         requiredProp: string;
       };
 
-      const VeryDeeplyNested = z.enum(["aaa", "bbb", "ccc"]);
+      const VeryDeeplyNested: z.ZodType<VeryDeeplyNested> = z.enum([
+        "aaa",
+        "bbb",
+        "ccc",
+      ]);
       const DeeplyNested = z.array(VeryDeeplyNested);
       const PartialObject = z
         .object({ something: z.string(), another: z.number() })

lib/src/getOpenApiDependencyGraph.test.ts

@@ -351,3 +351,44 @@ test("recursive relations along with some basics schemas", () => {
       ]
     `);
 });
+
+test("union type array dependencies", () => {
+    const schemas = {
+        Parent: {
+            type: "object",
+            properties: {
+                children: {
+                    type: ["array", "null"], // Union type with array - this was causing the bug
+                    items: { $ref: "Child" }
+                }
+            }
+        },
+        Child: {
+            type: "object",
+            properties: {
+                name: { type: "string" }
+            }
+        }
+    } as Record<string, SchemaObject>;
+
+    const getSchemaByRef = (ref: string) => schemas[ref]!;
+    const { refsDependencyGraph, deepDependencyGraph } = getOpenApiDependencyGraph(
+        Object.keys(schemas),
+        getSchemaByRef
+    );
+
+    expect(refsDependencyGraph).toMatchInlineSnapshot(`
+      {
+          "Parent": Set {
+              "Child",
+          },
+      }
+    `);
+    expect(deepDependencyGraph).toMatchInlineSnapshot(`
+      {
+          "Parent": Set {
+              "Child",
+          },
+      }
+    `);
+});

lib/src/getOpenApiDependencyGraph.ts

@@ -50,7 +50,7 @@ export const getOpenApiDependencyGraph = (
             return;
         }
 
-        if (schema.type === "array") {
+        if (schema.type === "array" || (Array.isArray(schema.type) && schema.type.includes("array"))) {
             if (!schema.items) return;
             return void visit(schema.items, fromRef);
         }

lib/src/template-context.ts

@@ -89,6 +89,10 @@ export const getZodClientTemplateContext = (
                     if (options?.shouldExportAllTypes && nodeSchema.type === "object") {
                         data.emittedType[depSchemaName] = true;
                     }
+                    // Also set emittedType for enum dependencies of circular schemas to ensure proper type annotations
+                    if (nodeSchema.type === "string" && nodeSchema.enum) {
+                        data.emittedType[depSchemaName] = true;
+                    }
                 }
             }
         }

lib/tests/circular-dependency-missing-enum-refs.test.ts

@@ -0,0 +1,69 @@
+import type { SchemaObject, SchemasObject } from "openapi3-ts";
+import { describe, expect, test } from "vitest";
+import { generateZodClientFromOpenAPI } from "../src/generateZodClientFromOpenAPI";
+
+describe("circular-dependency-missing-enum-refs", () => {
+    test("should generate enum dependencies with proper type annotations when circular schemas use z.lazy", async () => {
+        // - CircularA references CircularB (circular dependency)
+        // - CircularA also references enum Status which should get proper type annotation
+        const schemas: SchemasObject = {
+            CircularA: {
+                type: "object",
+                properties: {
+                    id: { type: "string" },
+                    status: { $ref: "#/components/schemas/Status" },
+                    circularB: { $ref: "#/components/schemas/CircularB" }
+                }
+            } as SchemaObject,
+
+            CircularB: {
+                type: "object",
+                properties: {
+                    id: { type: "string" },
+                    circularA: { $ref: "#/components/schemas/CircularA" }
+                }
+            } as SchemaObject,
+
+            Status: {
+                type: "string",
+                enum: ["active", "inactive"]
+            }
+        };
+
+        const openApiDoc = {
+            openapi: "3.1.0",
+            info: { title: "Test API", version: "1.0.0" },
+            paths: {
+                "/test": {
+                    get: {
+                        operationId: "getTest",
+                        responses: {
+                            "200": {
+                                description: "OK",
+                                content: {
+                                    "application/json": {
+                                        schema: { $ref: "#/components/schemas/CircularA" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            components: { schemas }
+        };
+
+        const output = await generateZodClientFromOpenAPI({
+            openApiDoc,
+            disableWriteToFile: true
+        });
+
+        // enum dependencies of circular schemas should get proper type annotations (: z.ZodType<...>):
+        expect(output).toContain("const Status: z.ZodType<Status> = z.enum");
+
+        // Circular schemas should also have type annotations, but that was already the case:
+        expect(output).toContain("const CircularA: z.ZodType<CircularA> = z.lazy");
+        expect(output).toContain("const CircularB: z.ZodType<CircularB> = z.lazy");
+    });
+});
+

lib/tests/enum-null.test.ts

@@ -119,10 +119,10 @@ test("enum-null", async () => {
       type Null3 = "a" | null;
       type Null4 = null;
 
-      const Null1 = z.literal(null);
-      const Null2 = z.enum(["a", null]);
-      const Null3 = z.enum(["a", null]);
-      const Null4 = z.literal(null);
+      const Null1: z.ZodType<Null1> = z.literal(null);
+      const Null2: z.ZodType<Null2> = z.enum(["a", null]);
+      const Null3: z.ZodType<Null3> = z.enum(["a", null]);
+      const Null4: z.ZodType<Null4> = z.literal(null);
       const Compound: z.ZodType<Compound> = z
         .object({ field: z.union([Null1, Null2, Null3, Null4, z.string()]) })
         .partial()