zod 3.25.26 → 3.25.27

package/dist/cjs/v4/classic/schemas.js

@@ -828,6 +828,14 @@ exports.ZodLiteral = core.$constructor("ZodLiteral", (inst, def) => {
     core.$ZodLiteral.init(inst, def);
     exports.ZodType.init(inst, def);
     inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+        get() {
+            if (def.values.length > 1) {
+                throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+            }
+            return def.values[0];
+        },
+    });
 });
 function literal(value, params) {
     return new exports.ZodLiteral({

package/dist/cjs/v4/core/to-json-schema.js

@@ -595,7 +595,7 @@ class JSONSchemaGenerator {
             }
             if (!seen.isParent)
                 this.override({
-                    zodSchema,
+                    zodSchema: zodSchema,
                     jsonSchema: schema,
                 });
         };

package/dist/esm/v4/classic/schemas.js

@@ -725,6 +725,14 @@ export const ZodLiteral = /*@__PURE__*/ core.$constructor("ZodLiteral", (inst, d
     core.$ZodLiteral.init(inst, def);
     ZodType.init(inst, def);
     inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+        get() {
+            if (def.values.length > 1) {
+                throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+            }
+            return def.values[0];
+        },
+    });
 });
 export function literal(value, params) {
     return new ZodLiteral({

package/dist/esm/v4/core/to-json-schema.js

@@ -591,7 +591,7 @@ export class JSONSchemaGenerator {
             }
             if (!seen.isParent)
                 this.override({
-                    zodSchema,
+                    zodSchema: zodSchema,
                     jsonSchema: schema,
                 });
         };

package/dist/types/v4/classic/schemas.d.ts

@@ -527,6 +527,8 @@ export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?:
 export interface ZodLiteral<T extends util.Primitive = util.Primitive> extends ZodType {
     _zod: core.$ZodLiteralInternals<T>;
     values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
 }
 export declare const ZodLiteral: core.$constructor<ZodLiteral>;
 export declare function literal<const T extends Array<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;

package/dist/types/v4/core/schemas.d.ts

@@ -715,7 +715,7 @@ export interface $ZodLiteralDef extends $ZodTypeDef {
 }
 export interface $ZodLiteralInternals<T extends util.Primitive = util.Primitive> extends $ZodTypeInternals<T, T> {
     def: $ZodLiteralDef;
-    values: util.PrimitiveSet;
+    values: Set<T>;
     pattern: RegExp;
     isst: errors.$ZodIssueInvalidValue;
 }

package/dist/types/v4/core/to-json-schema.d.ts

@@ -15,7 +15,7 @@ interface JSONSchemaGeneratorParams {
     unrepresentable?: "throw" | "any";
     /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
     override?: (ctx: {
-        zodSchema: schemas.$ZodType;
+        zodSchema: schemas.$ZodTypes;
         jsonSchema: JSONSchema.BaseSchema;
     }) => void;
     /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, Error converting schema to JSONz, defaults, coerced primitives, etc.
@@ -60,7 +60,7 @@ export declare class JSONSchemaGenerator {
     target: "draft-7" | "draft-2020-12";
     unrepresentable: "throw" | "any";
     override: (ctx: {
-        zodSchema: schemas.$ZodType;
+        zodSchema: schemas.$ZodTypes;
         jsonSchema: JSONSchema.BaseSchema;
     }) => void;
     io: "input" | "output";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.26",
+  "version": "3.25.27",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",