Make $ZodLiteralDef generic

Author: colinhacks

packages/zod/src/v4/classic/schemas.ts

@@ -1015,7 +1015,7 @@ export function array<T extends core.SomeType>(element: T, params?: string | cor
 }
 
 // .keyof
-export function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["output"]> {
+export function keyof<T extends ZodObject>(schema: T): ZodLiteral<Exclude<keyof T["_zod"]["output"], symbol>> {
   const shape = schema._zod.def.shape;
   return literal(Object.keys(shape)) as any;
 }
@@ -1487,7 +1487,7 @@ export function nativeEnum<T extends util.EnumLike>(entries: T, params?: string
 }
 
 // ZodLiteral
-export interface ZodLiteral<T extends util.Primitive = util.Primitive>
+export interface ZodLiteral<T extends util.Literal = util.Literal>
   extends _ZodType<core.$ZodLiteralInternals<T>>,
     core.$ZodLiteral<T> {
   values: Set<T>;

packages/zod/src/v4/core/schemas.ts

@@ -2687,19 +2687,19 @@ export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constru
 ////////////////////////////////////////
 ////////////////////////////////////////
 
-export interface $ZodLiteralDef extends $ZodTypeDef {
+export interface $ZodLiteralDef<T extends util.Literal> extends $ZodTypeDef {
   type: "literal";
-  values: util.LiteralArray;
+  values: T[];
 }
 
-export interface $ZodLiteralInternals<T extends util.Primitive = util.Primitive> extends $ZodTypeInternals<T, T> {
-  def: $ZodLiteralDef;
+export interface $ZodLiteralInternals<T extends util.Literal = util.Literal> extends $ZodTypeInternals<T, T> {
+  def: $ZodLiteralDef<T>;
   values: Set<T>;
   pattern: RegExp;
   isst: errors.$ZodIssueInvalidValue;
 }
 
-export interface $ZodLiteral<T extends util.Primitive = util.Primitive> extends $ZodType {
+export interface $ZodLiteral<T extends util.Literal = util.Literal> extends $ZodType {
   _zod: $ZodLiteralInternals<T>;
 }
 
@@ -2708,7 +2708,7 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
   (inst, def) => {
     $ZodType.init(inst, def);
 
-    inst._zod.values = new Set<util.Primitive>(def.values);
+    inst._zod.values = new Set<util.Literal>(def.values);
     inst._zod.pattern = new RegExp(
       `^(${def.values
 

packages/zod/src/v4/mini/schemas.ts

@@ -686,7 +686,7 @@ export function array<T extends SomeType>(element: SomeType, params?: any): ZodM
 }
 
 // .keyof
-export function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<keyof T["shape"]> {
+export function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<Exclude<keyof T["shape"], symbol>> {
   const shape = schema._zod.def.shape;
   return literal(Object.keys(shape)) as any;
 }
@@ -1094,7 +1094,7 @@ export function nativeEnum<T extends util.EnumLike>(entries: T, params?: string
 }
 
 // ZodMiniLiteral
-export interface ZodMiniLiteral<T extends util.Primitive = util.Primitive>
+export interface ZodMiniLiteral<T extends util.Literal = util.Literal>
   extends _ZodMiniType<core.$ZodLiteralInternals<T>> {
   // _zod: core.$ZodLiteralInternals<T>;
 }

packages/zod/src/v4/mini/tests/index.test.ts

@@ -852,6 +852,7 @@ test("def typing", () => {
   z.map(z.string(), z.number()).def.type satisfies "map";
   z.set(z.string()).def.type satisfies "set";
   z.literal("example").def.type satisfies "literal";
+  expectTypeOf(z.literal("example").def.values).toEqualTypeOf<"example"[]>();
   z.enum(["a", "b", "c"]).def.type satisfies "enum";
   z.promise(z.string()).def.type satisfies "promise";
   z.lazy(() => z.string()).def.type satisfies "lazy";

play.ts

@@ -1,3 +1,5 @@
 import { z } from "zod/v4";
 
 z.string().regex(/asdf/);
+
+z.literal;