From 77b79eff5e51d35d728f4d956ce6fc8f4a034d9a Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Tue, 26 Jul 2022 17:30:11 +0200
Subject: [PATCH 01/10] #1171

---
 .../lib/__tests__/discriminatedUnions.test.ts |  9 +++++
 deno/lib/types.ts                             | 35 +++++++++++++++++--
 src/__tests__/discriminatedUnions.test.ts     |  9 +++++
 src/types.ts                                  | 35 +++++++++++++++++--
 4 files changed, 82 insertions(+), 6 deletions(-)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index a5f8f8996..c61cb54a4 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -25,6 +25,11 @@ test("valid - discriminator value of various primitive types", () => {
     z.object({ type: z.literal(null), val: z.literal(7) }),
     z.object({ type: z.literal("undefined"), val: z.literal(8) }),
     z.object({ type: z.literal(undefined), val: z.literal(9) }),
+    z
+      .object({ type: z.literal("transform"), val: z.literal(10) })
+      .transform((val) => ({
+        val,
+      })),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -57,6 +62,10 @@ test("valid - discriminator value of various primitive types", () => {
     type: undefined,
     val: 9,
   });
+  // console.log("test");
+  // expect(schema.parse({ type: "transform", val: 10 })).toEqual({
+  //   val: 10,
+  // });
 });
 
 test("invalid - null", () => {
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 13f6eaaa9..3024d6a97 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -2137,7 +2137,7 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 
-export type ZodDiscriminatedUnionOption<
+export type ZodDiscriminatedUnionOptionBase<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
 > = ZodObject<
@@ -2146,6 +2146,15 @@ export type ZodDiscriminatedUnionOption<
   any
 >;
 
+export type ZodDiscriminatedUnionOption<
+  Discriminator extends string,
+  DiscriminatorValue extends Primitive
+> =
+  | ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+  | ZodEffects<
+      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+    >;
+
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
   DiscriminatorValue extends Primitive,
@@ -2243,8 +2252,22 @@ export class ZodDiscriminatedUnion<
 
     try {
       types.forEach((type) => {
-        const discriminatorValue = type.shape[discriminator].value;
-        options.set(discriminatorValue, type);
+        if (type._def.typeName === ZodFirstPartyTypeKind.ZodObject) {
+          const discriminatorValue = (
+            type as ZodDiscriminatedUnionOptionBase<
+              Discriminator,
+              DiscriminatorValue
+            >
+          ).shape[discriminator].value;
+          options.set(discriminatorValue, type);
+        } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
+          const discriminatorValue = (
+            type as ZodEffects<
+              ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+            >
+          ).sourceType().shape[discriminator].value;
+          options.set(discriminatorValue, type);
+        }
       });
     } catch (e) {
       throw new Error(
@@ -3417,6 +3440,12 @@ export class ZodEffects<
     return this._def.schema;
   }
 
+  sourceType(): T {
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects
+      ? (this._def.schema as unknown as ZodEffects<T>).sourceType()
+      : (this._def.schema as T);
+  }
+
   _parse(input: ParseInput): ParseReturnType<this["_output"]> {
     const { status, ctx } = this._processInputParams(input);
 
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index 3d26a14d9..dc6e70814 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -24,6 +24,11 @@ test("valid - discriminator value of various primitive types", () => {
     z.object({ type: z.literal(null), val: z.literal(7) }),
     z.object({ type: z.literal("undefined"), val: z.literal(8) }),
     z.object({ type: z.literal(undefined), val: z.literal(9) }),
+    z
+      .object({ type: z.literal("transform"), val: z.literal(10) })
+      .transform((val) => ({
+        val,
+      })),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -56,6 +61,10 @@ test("valid - discriminator value of various primitive types", () => {
     type: undefined,
     val: 9,
   });
+  // console.log("test");
+  // expect(schema.parse({ type: "transform", val: 10 })).toEqual({
+  //   val: 10,
+  // });
 });
 
 test("invalid - null", () => {
diff --git a/src/types.ts b/src/types.ts
index 1d4badcdd..2518f083f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2137,7 +2137,7 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 
-export type ZodDiscriminatedUnionOption<
+export type ZodDiscriminatedUnionOptionBase<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
 > = ZodObject<
@@ -2146,6 +2146,15 @@ export type ZodDiscriminatedUnionOption<
   any
 >;
 
+export type ZodDiscriminatedUnionOption<
+  Discriminator extends string,
+  DiscriminatorValue extends Primitive
+> =
+  | ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+  | ZodEffects<
+      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+    >;
+
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
   DiscriminatorValue extends Primitive,
@@ -2243,8 +2252,22 @@ export class ZodDiscriminatedUnion<
 
     try {
       types.forEach((type) => {
-        const discriminatorValue = type.shape[discriminator].value;
-        options.set(discriminatorValue, type);
+        if (type._def.typeName === ZodFirstPartyTypeKind.ZodObject) {
+          const discriminatorValue = (
+            type as ZodDiscriminatedUnionOptionBase<
+              Discriminator,
+              DiscriminatorValue
+            >
+          ).shape[discriminator].value;
+          options.set(discriminatorValue, type);
+        } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
+          const discriminatorValue = (
+            type as ZodEffects<
+              ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+            >
+          ).sourceType().shape[discriminator].value;
+          options.set(discriminatorValue, type);
+        }
       });
     } catch (e) {
       throw new Error(
@@ -3417,6 +3440,12 @@ export class ZodEffects<
     return this._def.schema;
   }
 
+  sourceType(): T {
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects
+      ? (this._def.schema as unknown as ZodEffects<T>).sourceType()
+      : (this._def.schema as T);
+  }
+
   _parse(input: ParseInput): ParseReturnType<this["_output"]> {
     const { status, ctx } = this._processInputParams(input);
 

From 9b0d9f22b08af6318fa407d50193003abe87055d Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Tue, 26 Jul 2022 17:39:48 +0200
Subject: [PATCH 02/10] fix tests

---
 deno/lib/__tests__/discriminatedUnions.test.ts | 16 +++++++++++-----
 src/__tests__/discriminatedUnions.test.ts      | 16 +++++++++++-----
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index c61cb54a4..57b98a013 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -28,8 +28,11 @@ test("valid - discriminator value of various primitive types", () => {
     z
       .object({ type: z.literal("transform"), val: z.literal(10) })
       .transform((val) => ({
-        val,
+        val: val.val,
       })),
+    z
+      .object({ type: z.literal("refine"), val: z.literal(11) })
+      .refine(() => true),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -62,10 +65,13 @@ test("valid - discriminator value of various primitive types", () => {
     type: undefined,
     val: 9,
   });
-  // console.log("test");
-  // expect(schema.parse({ type: "transform", val: 10 })).toEqual({
-  //   val: 10,
-  // });
+  expect(schema.parse({ type: "transform", val: 10 })).toEqual({
+    val: 10,
+  });
+  expect(schema.parse({ type: "refine", val: 11 })).toEqual({
+    type: "refine",
+    val: 11,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index dc6e70814..eb1d02bfe 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -27,8 +27,11 @@ test("valid - discriminator value of various primitive types", () => {
     z
       .object({ type: z.literal("transform"), val: z.literal(10) })
       .transform((val) => ({
-        val,
+        val: val.val,
       })),
+    z
+      .object({ type: z.literal("refine"), val: z.literal(11) })
+      .refine(() => true),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -61,10 +64,13 @@ test("valid - discriminator value of various primitive types", () => {
     type: undefined,
     val: 9,
   });
-  // console.log("test");
-  // expect(schema.parse({ type: "transform", val: 10 })).toEqual({
-  //   val: 10,
-  // });
+  expect(schema.parse({ type: "transform", val: 10 })).toEqual({
+    val: 10,
+  });
+  expect(schema.parse({ type: "refine", val: 11 })).toEqual({
+    type: "refine",
+    val: 11,
+  });
 });
 
 test("invalid - null", () => {

From 668bd5d5043c8726ed36b5118670bb508ce0b671 Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Tue, 26 Jul 2022 17:41:39 +0200
Subject: [PATCH 03/10] add superRefine in tests

---
 deno/lib/__tests__/discriminatedUnions.test.ts | 7 +++++++
 src/__tests__/discriminatedUnions.test.ts      | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index 57b98a013..d338abc62 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -33,6 +33,9 @@ test("valid - discriminator value of various primitive types", () => {
     z
       .object({ type: z.literal("refine"), val: z.literal(11) })
       .refine(() => true),
+    z
+      .object({ type: z.literal("superRefine"), val: z.literal(12) })
+      .superRefine(() => {}),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -72,6 +75,10 @@ test("valid - discriminator value of various primitive types", () => {
     type: "refine",
     val: 11,
   });
+  expect(schema.parse({ type: "superRefine", val: 12 })).toEqual({
+    type: "superRefine",
+    val: 12,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index eb1d02bfe..b119f5589 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -32,6 +32,9 @@ test("valid - discriminator value of various primitive types", () => {
     z
       .object({ type: z.literal("refine"), val: z.literal(11) })
       .refine(() => true),
+    z
+      .object({ type: z.literal("superRefine"), val: z.literal(12) })
+      .superRefine(() => {}),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -71,6 +74,10 @@ test("valid - discriminator value of various primitive types", () => {
     type: "refine",
     val: 11,
   });
+  expect(schema.parse({ type: "superRefine", val: 12 })).toEqual({
+    type: "superRefine",
+    val: 12,
+  });
 });
 
 test("invalid - null", () => {

From 87883fa354a59b57d40b66dd2fbf268fa7754ac1 Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Wed, 27 Jul 2022 12:00:08 +0200
Subject: [PATCH 04/10] add support for lazy

---
 deno/lib/README.md                            |  2 +-
 .../lib/__tests__/discriminatedUnions.test.ts | 25 ++++++++
 deno/lib/types.ts                             | 59 +++++++++++--------
 src/__tests__/discriminatedUnions.test.ts     | 25 ++++++++
 src/types.ts                                  | 59 +++++++++++--------
 5 files changed, 123 insertions(+), 47 deletions(-)

diff --git a/deno/lib/README.md b/deno/lib/README.md
index 2b6c41743..856f8c633 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -604,7 +604,7 @@ dateSchema.safeParse(new Date("1/12/22")); // success: true
 dateSchema.safeParse("2022-01-12T00:00:00.000Z"); // success: true
 ```
 
-## Zod enums-
+## Zod enums
 
 ```ts
 const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index d338abc62..45ecfa176 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -36,6 +36,21 @@ test("valid - discriminator value of various primitive types", () => {
     z
       .object({ type: z.literal("superRefine"), val: z.literal(12) })
       .superRefine(() => {}),
+    z.lazy(() => z.object({ type: z.literal("lazy"), val: z.literal(13) })),
+    z.lazy(() =>
+      z
+        .object({ type: z.literal("chained 1"), val: z.literal(14) })
+        .transform((val) => ({
+          val: val.val,
+        }))
+    ),
+    z
+      .lazy(() =>
+        z.object({ type: z.literal("chained 2"), val: z.literal(15) })
+      )
+      .transform((val) => ({
+        val: val.val,
+      })),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -79,6 +94,16 @@ test("valid - discriminator value of various primitive types", () => {
     type: "superRefine",
     val: 12,
   });
+  expect(schema.parse({ type: "lazy", val: 13 })).toEqual({
+    type: "lazy",
+    val: 13,
+  });
+  expect(schema.parse({ type: "chained 1", val: 14 })).toEqual({
+    val: 14,
+  });
+  expect(schema.parse({ type: "chained 2", val: 15 })).toEqual({
+    val: 15,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 3024d6a97..0305650fc 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -18,7 +18,7 @@ import {
   ParsePath,
   ParseReturnType,
   ParseStatus,
-  SyncParseReturnType,
+  SyncParseReturnType
 } from "./helpers/parseUtil.ts";
 import { partialUtil } from "./helpers/partialUtil.ts";
 import { Primitive } from "./helpers/typeAliases.ts";
@@ -30,7 +30,7 @@ import {
   ZodError,
   ZodErrorMap,
   ZodIssue,
-  ZodIssueCode,
+  ZodIssueCode
 } from "./ZodError.ts";
 
 ///////////////////////////////////////
@@ -2137,6 +2137,34 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 
+type ZodSourceType<T extends ZodTypeAny> = T extends ZodLazy<infer U>
+  ? ZodSourceType<U>
+  : T extends ZodEffects<infer U>
+  ? ZodSourceType<U>
+  : T;
+
+type ZodOriginType<T extends ZodTypeAny> =
+  | T
+  | ZodLazy<T>
+  | ZodEffects<T>
+  | ZodLazy<ZodEffects<T>>
+  | ZodEffects<ZodLazy<T>>;
+
+function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
+  if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
+    console.log("lazy");
+    return getSourceType(
+      (type as unknown as ZodLazy<ZodTypeAny>).schema
+    ) as ZodSourceType<T>;
+  } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
+    return getSourceType(
+      (type as unknown as ZodEffects<ZodTypeAny>).sourceType()
+    ) as ZodSourceType<T>;
+  } else {
+    return type as ZodSourceType<T>;
+  }
+}
+
 export type ZodDiscriminatedUnionOptionBase<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
@@ -2149,11 +2177,9 @@ export type ZodDiscriminatedUnionOptionBase<
 export type ZodDiscriminatedUnionOption<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
-> =
-  | ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-  | ZodEffects<
-      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-    >;
+> = ZodOriginType<
+  ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
@@ -2252,22 +2278,9 @@ export class ZodDiscriminatedUnion<
 
     try {
       types.forEach((type) => {
-        if (type._def.typeName === ZodFirstPartyTypeKind.ZodObject) {
-          const discriminatorValue = (
-            type as ZodDiscriminatedUnionOptionBase<
-              Discriminator,
-              DiscriminatorValue
-            >
-          ).shape[discriminator].value;
-          options.set(discriminatorValue, type);
-        } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
-          const discriminatorValue = (
-            type as ZodEffects<
-              ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-            >
-          ).sourceType().shape[discriminator].value;
-          options.set(discriminatorValue, type);
-        }
+        const discriminatorValue =
+          getSourceType(type).shape[discriminator].value;
+        options.set(discriminatorValue, type);
       });
     } catch (e) {
       throw new Error(
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index b119f5589..3ea304918 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -35,6 +35,21 @@ test("valid - discriminator value of various primitive types", () => {
     z
       .object({ type: z.literal("superRefine"), val: z.literal(12) })
       .superRefine(() => {}),
+    z.lazy(() => z.object({ type: z.literal("lazy"), val: z.literal(13) })),
+    z.lazy(() =>
+      z
+        .object({ type: z.literal("chained 1"), val: z.literal(14) })
+        .transform((val) => ({
+          val: val.val,
+        }))
+    ),
+    z
+      .lazy(() =>
+        z.object({ type: z.literal("chained 2"), val: z.literal(15) })
+      )
+      .transform((val) => ({
+        val: val.val,
+      })),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -78,6 +93,16 @@ test("valid - discriminator value of various primitive types", () => {
     type: "superRefine",
     val: 12,
   });
+  expect(schema.parse({ type: "lazy", val: 13 })).toEqual({
+    type: "lazy",
+    val: 13,
+  });
+  expect(schema.parse({ type: "chained 1", val: 14 })).toEqual({
+    val: 14,
+  });
+  expect(schema.parse({ type: "chained 2", val: 15 })).toEqual({
+    val: 15,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/src/types.ts b/src/types.ts
index 2518f083f..897a44b87 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -18,7 +18,7 @@ import {
   ParsePath,
   ParseReturnType,
   ParseStatus,
-  SyncParseReturnType,
+  SyncParseReturnType
 } from "./helpers/parseUtil";
 import { partialUtil } from "./helpers/partialUtil";
 import { Primitive } from "./helpers/typeAliases";
@@ -30,7 +30,7 @@ import {
   ZodError,
   ZodErrorMap,
   ZodIssue,
-  ZodIssueCode,
+  ZodIssueCode
 } from "./ZodError";
 
 ///////////////////////////////////////
@@ -2137,6 +2137,34 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 
+type ZodSourceType<T extends ZodTypeAny> = T extends ZodLazy<infer U>
+  ? ZodSourceType<U>
+  : T extends ZodEffects<infer U>
+  ? ZodSourceType<U>
+  : T;
+
+type ZodOriginType<T extends ZodTypeAny> =
+  | T
+  | ZodLazy<T>
+  | ZodEffects<T>
+  | ZodLazy<ZodEffects<T>>
+  | ZodEffects<ZodLazy<T>>;
+
+function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
+  if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
+    console.log("lazy");
+    return getSourceType(
+      (type as unknown as ZodLazy<ZodTypeAny>).schema
+    ) as ZodSourceType<T>;
+  } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
+    return getSourceType(
+      (type as unknown as ZodEffects<ZodTypeAny>).sourceType()
+    ) as ZodSourceType<T>;
+  } else {
+    return type as ZodSourceType<T>;
+  }
+}
+
 export type ZodDiscriminatedUnionOptionBase<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
@@ -2149,11 +2177,9 @@ export type ZodDiscriminatedUnionOptionBase<
 export type ZodDiscriminatedUnionOption<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
-> =
-  | ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-  | ZodEffects<
-      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-    >;
+> = ZodOriginType<
+  ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
@@ -2252,22 +2278,9 @@ export class ZodDiscriminatedUnion<
 
     try {
       types.forEach((type) => {
-        if (type._def.typeName === ZodFirstPartyTypeKind.ZodObject) {
-          const discriminatorValue = (
-            type as ZodDiscriminatedUnionOptionBase<
-              Discriminator,
-              DiscriminatorValue
-            >
-          ).shape[discriminator].value;
-          options.set(discriminatorValue, type);
-        } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
-          const discriminatorValue = (
-            type as ZodEffects<
-              ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-            >
-          ).sourceType().shape[discriminator].value;
-          options.set(discriminatorValue, type);
-        }
+        const discriminatorValue =
+          getSourceType(type).shape[discriminator].value;
+        options.set(discriminatorValue, type);
       });
     } catch (e) {
       throw new Error(

From 9b591c0d2ddb5121cf5622d93f1a8599182c158b Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Wed, 27 Jul 2022 17:32:37 +0200
Subject: [PATCH 05/10] fix typings

---
 .../lib/__tests__/discriminatedUnions.test.ts | 11 +++++++++
 deno/lib/types.ts                             | 24 +++++++++++--------
 src/__tests__/discriminatedUnions.test.ts     | 11 +++++++++
 src/types.ts                                  | 24 +++++++++++--------
 4 files changed, 50 insertions(+), 20 deletions(-)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index 45ecfa176..1aa2702b9 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -51,6 +51,14 @@ test("valid - discriminator value of various primitive types", () => {
       .transform((val) => ({
         val: val.val,
       })),
+    z
+      .lazy(() =>
+        z.object({ type: z.literal("chained 3"), val: z.literal(16) })
+      )
+      .transform((val) => ({
+        val: val.val,
+      }))
+      .refine(() => true),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -104,6 +112,9 @@ test("valid - discriminator value of various primitive types", () => {
   expect(schema.parse({ type: "chained 2", val: 15 })).toEqual({
     val: 15,
   });
+  expect(schema.parse({ type: "chained 3", val: 16 })).toEqual({
+    val: 16,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 0305650fc..0ca4369f1 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -2143,12 +2143,16 @@ type ZodSourceType<T extends ZodTypeAny> = T extends ZodLazy<infer U>
   ? ZodSourceType<U>
   : T;
 
-type ZodOriginType<T extends ZodTypeAny> =
-  | T
-  | ZodLazy<T>
-  | ZodEffects<T>
-  | ZodLazy<ZodEffects<T>>
-  | ZodEffects<ZodLazy<T>>;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+type ZodOriginType<T extends ZodTypeAny, D extends Prev[number] = 9> = [
+  D
+] extends [never]
+  ? never
+  :
+      | T
+      | ZodEffects<ZodOriginType<T, Prev[D]>>
+      | ZodLazy<ZodOriginType<T, Prev[D]>>;
 
 function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
   if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
@@ -2196,9 +2200,9 @@ export class ZodDiscriminatedUnion<
   DiscriminatorValue extends Primitive,
   Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>
 > extends ZodType<
-  Option["_output"],
+  output<Option>,
   ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>,
-  Option["_input"]
+  input<Option>
 > {
   _parse(input: ParseInput): ParseReturnType<this["_output"]> {
     const { ctx } = this._processInputParams(input);
@@ -3446,8 +3450,8 @@ export interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny>
 
 export class ZodEffects<
   T extends ZodTypeAny,
-  Output = T["_output"],
-  Input = T["_input"]
+  Output = output<T>,
+  Input = input<T>
 > extends ZodType<Output, ZodEffectsDef<T>, Input> {
   innerType() {
     return this._def.schema;
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index 3ea304918..7b8c4807b 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -50,6 +50,14 @@ test("valid - discriminator value of various primitive types", () => {
       .transform((val) => ({
         val: val.val,
       })),
+    z
+      .lazy(() =>
+        z.object({ type: z.literal("chained 3"), val: z.literal(16) })
+      )
+      .transform((val) => ({
+        val: val.val,
+      }))
+      .refine(() => true),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -103,6 +111,9 @@ test("valid - discriminator value of various primitive types", () => {
   expect(schema.parse({ type: "chained 2", val: 15 })).toEqual({
     val: 15,
   });
+  expect(schema.parse({ type: "chained 3", val: 16 })).toEqual({
+    val: 16,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/src/types.ts b/src/types.ts
index 897a44b87..5c9b82989 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2143,12 +2143,16 @@ type ZodSourceType<T extends ZodTypeAny> = T extends ZodLazy<infer U>
   ? ZodSourceType<U>
   : T;
 
-type ZodOriginType<T extends ZodTypeAny> =
-  | T
-  | ZodLazy<T>
-  | ZodEffects<T>
-  | ZodLazy<ZodEffects<T>>
-  | ZodEffects<ZodLazy<T>>;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+type ZodOriginType<T extends ZodTypeAny, D extends Prev[number] = 9> = [
+  D
+] extends [never]
+  ? never
+  :
+      | T
+      | ZodEffects<ZodOriginType<T, Prev[D]>>
+      | ZodLazy<ZodOriginType<T, Prev[D]>>;
 
 function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
   if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
@@ -2196,9 +2200,9 @@ export class ZodDiscriminatedUnion<
   DiscriminatorValue extends Primitive,
   Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>
 > extends ZodType<
-  Option["_output"],
+  output<Option>,
   ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>,
-  Option["_input"]
+  input<Option>
 > {
   _parse(input: ParseInput): ParseReturnType<this["_output"]> {
     const { ctx } = this._processInputParams(input);
@@ -3446,8 +3450,8 @@ export interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny>
 
 export class ZodEffects<
   T extends ZodTypeAny,
-  Output = T["_output"],
-  Input = T["_input"]
+  Output = output<T>,
+  Input = input<T>
 > extends ZodType<Output, ZodEffectsDef<T>, Input> {
   innerType() {
     return this._def.schema;

From b745021dc81850dfa443d726d2ce32d774412650 Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Wed, 27 Jul 2022 18:04:29 +0200
Subject: [PATCH 06/10] fixe typings for asserted lazy

---
 .../lib/__tests__/discriminatedUnions.test.ts | 12 ++++++++++
 deno/lib/types.ts                             | 24 ++++++++++++++-----
 src/__tests__/discriminatedUnions.test.ts     | 12 ++++++++++
 src/types.ts                                  | 24 ++++++++++++++-----
 4 files changed, 60 insertions(+), 12 deletions(-)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index 1aa2702b9..5afd05e33 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -15,6 +15,11 @@ test("valid", () => {
 });
 
 test("valid - discriminator value of various primitive types", () => {
+  interface lazy {
+    type: "lazy typed";
+    val: 17;
+  }
+
   const schema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("1"), val: z.literal(1) }),
     z.object({ type: z.literal(1), val: z.literal(2) }),
@@ -59,6 +64,9 @@ test("valid - discriminator value of various primitive types", () => {
         val: val.val,
       }))
       .refine(() => true),
+    z.lazy(() =>
+      z.object({ type: z.literal("lazy typed"), val: z.literal(17) })
+    ) as z.ZodType<lazy>,
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -115,6 +123,10 @@ test("valid - discriminator value of various primitive types", () => {
   expect(schema.parse({ type: "chained 3", val: 16 })).toEqual({
     val: 16,
   });
+  expect(schema.parse({ type: "lazy typed", val: 17 })).toEqual({
+    type: "lazy typed",
+    val: 17,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 0ca4369f1..a9d79ce76 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -2169,7 +2169,7 @@ function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
   }
 }
 
-export type ZodDiscriminatedUnionOptionBase<
+type ZodDiscriminatedUnionOptionBase<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
 > = ZodObject<
@@ -2178,12 +2178,21 @@ export type ZodDiscriminatedUnionOptionBase<
   any
 >;
 
+type ZodDiscriminatedUnionType<Discriminator extends string> = Record<
+  any,
+  any
+> & {
+  [key in Discriminator]: Primitive;
+};
+
 export type ZodDiscriminatedUnionOption<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
-> = ZodOriginType<
-  ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
->;
+> =
+  | ZodOriginType<
+      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+    >
+  | ZodType<ZodDiscriminatedUnionType<Discriminator>, any, any>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
@@ -2282,8 +2291,11 @@ export class ZodDiscriminatedUnion<
 
     try {
       types.forEach((type) => {
-        const discriminatorValue =
-          getSourceType(type).shape[discriminator].value;
+        const discriminatorValue = getSourceType(
+          type as ZodOriginType<
+            ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+          >
+        ).shape[discriminator].value;
         options.set(discriminatorValue, type);
       });
     } catch (e) {
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index 7b8c4807b..1effe0f07 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -14,6 +14,11 @@ test("valid", () => {
 });
 
 test("valid - discriminator value of various primitive types", () => {
+  interface lazy {
+    type: "lazy typed";
+    val: 17;
+  }
+
   const schema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("1"), val: z.literal(1) }),
     z.object({ type: z.literal(1), val: z.literal(2) }),
@@ -58,6 +63,9 @@ test("valid - discriminator value of various primitive types", () => {
         val: val.val,
       }))
       .refine(() => true),
+    z.lazy(() =>
+      z.object({ type: z.literal("lazy typed"), val: z.literal(17) })
+    ) as z.ZodType<lazy>,
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -114,6 +122,10 @@ test("valid - discriminator value of various primitive types", () => {
   expect(schema.parse({ type: "chained 3", val: 16 })).toEqual({
     val: 16,
   });
+  expect(schema.parse({ type: "lazy typed", val: 17 })).toEqual({
+    type: "lazy typed",
+    val: 17,
+  });
 });
 
 test("invalid - null", () => {
diff --git a/src/types.ts b/src/types.ts
index 5c9b82989..335c9b4b8 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2169,7 +2169,7 @@ function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
   }
 }
 
-export type ZodDiscriminatedUnionOptionBase<
+type ZodDiscriminatedUnionOptionBase<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
 > = ZodObject<
@@ -2178,12 +2178,21 @@ export type ZodDiscriminatedUnionOptionBase<
   any
 >;
 
+type ZodDiscriminatedUnionType<Discriminator extends string> = Record<
+  any,
+  any
+> & {
+  [key in Discriminator]: Primitive;
+};
+
 export type ZodDiscriminatedUnionOption<
   Discriminator extends string,
   DiscriminatorValue extends Primitive
-> = ZodOriginType<
-  ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
->;
+> =
+  | ZodOriginType<
+      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+    >
+  | ZodType<ZodDiscriminatedUnionType<Discriminator>, any, any>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
@@ -2282,8 +2291,11 @@ export class ZodDiscriminatedUnion<
 
     try {
       types.forEach((type) => {
-        const discriminatorValue =
-          getSourceType(type).shape[discriminator].value;
+        const discriminatorValue = getSourceType(
+          type as ZodOriginType<
+            ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
+          >
+        ).shape[discriminator].value;
         options.set(discriminatorValue, type);
       });
     } catch (e) {

From 2657fa664a3d04ad6eaaa2f83b6b7479248768c6 Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Wed, 27 Jul 2022 18:09:06 +0200
Subject: [PATCH 07/10] fix

---
 deno/lib/types.ts | 4 ++--
 src/types.ts      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index a9d79ce76..3241e0f57 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -2179,7 +2179,7 @@ type ZodDiscriminatedUnionOptionBase<
 >;
 
 type ZodDiscriminatedUnionType<Discriminator extends string> = Record<
-  any,
+  string,
   any
 > & {
   [key in Discriminator]: Primitive;
@@ -2192,7 +2192,7 @@ export type ZodDiscriminatedUnionOption<
   | ZodOriginType<
       ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
     >
-  | ZodType<ZodDiscriminatedUnionType<Discriminator>, any, any>;
+  | ZodType<any, any, ZodDiscriminatedUnionType<Discriminator>>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
diff --git a/src/types.ts b/src/types.ts
index 335c9b4b8..9e3573f06 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2179,7 +2179,7 @@ type ZodDiscriminatedUnionOptionBase<
 >;
 
 type ZodDiscriminatedUnionType<Discriminator extends string> = Record<
-  any,
+  string,
   any
 > & {
   [key in Discriminator]: Primitive;
@@ -2192,7 +2192,7 @@ export type ZodDiscriminatedUnionOption<
   | ZodOriginType<
       ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
     >
-  | ZodType<ZodDiscriminatedUnionType<Discriminator>, any, any>;
+  | ZodType<any, any, ZodDiscriminatedUnionType<Discriminator>>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,

From 87a3caa944581ee2bdef7ec706ad85190fa240eb Mon Sep 17 00:00:00 2001
From: Robin Labat <roblabat@gmail.com>
Date: Fri, 29 Jul 2022 16:55:23 +0200
Subject: [PATCH 08/10] clean console.log from debug

---
 deno/lib/types.ts | 1 -
 src/types.ts      | 1 -
 2 files changed, 2 deletions(-)

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 3241e0f57..d41e66181 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -2156,7 +2156,6 @@ type ZodOriginType<T extends ZodTypeAny, D extends Prev[number] = 9> = [
 
 function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
   if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
-    console.log("lazy");
     return getSourceType(
       (type as unknown as ZodLazy<ZodTypeAny>).schema
     ) as ZodSourceType<T>;
diff --git a/src/types.ts b/src/types.ts
index 9e3573f06..d32db550a 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2156,7 +2156,6 @@ type ZodOriginType<T extends ZodTypeAny, D extends Prev[number] = 9> = [
 
 function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
   if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
-    console.log("lazy");
     return getSourceType(
       (type as unknown as ZodLazy<ZodTypeAny>).schema
     ) as ZodSourceType<T>;

From 2bd6c08ca090c9f83846f3d9001e086bd09b26fe Mon Sep 17 00:00:00 2001
From: Colin McDonnell <colinmcd@alum.mit.edu>
Date: Tue, 15 Nov 2022 00:23:22 -0800
Subject: [PATCH 09/10] Clean up discriminatedUnion

---
 .../lib/__tests__/discriminatedUnions.test.ts |  81 +--------
 deno/lib/types.ts                             | 161 +++++++-----------
 src/__tests__/discriminatedUnions.test.ts     |  81 +--------
 src/types.ts                                  | 161 +++++++-----------
 4 files changed, 134 insertions(+), 350 deletions(-)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index 5afd05e33..45b57f289 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -15,11 +15,6 @@ test("valid", () => {
 });
 
 test("valid - discriminator value of various primitive types", () => {
-  interface lazy {
-    type: "lazy typed";
-    val: 17;
-  }
-
   const schema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("1"), val: z.literal(1) }),
     z.object({ type: z.literal(1), val: z.literal(2) }),
@@ -30,43 +25,9 @@ test("valid - discriminator value of various primitive types", () => {
     z.object({ type: z.literal(null), val: z.literal(7) }),
     z.object({ type: z.literal("undefined"), val: z.literal(8) }),
     z.object({ type: z.literal(undefined), val: z.literal(9) }),
-    z
-      .object({ type: z.literal("transform"), val: z.literal(10) })
-      .transform((val) => ({
-        val: val.val,
-      })),
-    z
-      .object({ type: z.literal("refine"), val: z.literal(11) })
-      .refine(() => true),
-    z
-      .object({ type: z.literal("superRefine"), val: z.literal(12) })
-      .superRefine(() => {}),
-    z.lazy(() => z.object({ type: z.literal("lazy"), val: z.literal(13) })),
-    z.lazy(() =>
-      z
-        .object({ type: z.literal("chained 1"), val: z.literal(14) })
-        .transform((val) => ({
-          val: val.val,
-        }))
-    ),
-    z
-      .lazy(() =>
-        z.object({ type: z.literal("chained 2"), val: z.literal(15) })
-      )
-      .transform((val) => ({
-        val: val.val,
-      })),
-    z
-      .lazy(() =>
-        z.object({ type: z.literal("chained 3"), val: z.literal(16) })
-      )
-      .transform((val) => ({
-        val: val.val,
-      }))
-      .refine(() => true),
-    z.lazy(() =>
-      z.object({ type: z.literal("lazy typed"), val: z.literal(17) })
-    ) as z.ZodType<lazy>,
+    z.object({ type: z.literal("transform"), val: z.literal(10) }),
+    z.object({ type: z.literal("refine"), val: z.literal(11) }),
+    z.object({ type: z.literal("superRefine"), val: z.literal(12) }),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -99,34 +60,6 @@ test("valid - discriminator value of various primitive types", () => {
     type: undefined,
     val: 9,
   });
-  expect(schema.parse({ type: "transform", val: 10 })).toEqual({
-    val: 10,
-  });
-  expect(schema.parse({ type: "refine", val: 11 })).toEqual({
-    type: "refine",
-    val: 11,
-  });
-  expect(schema.parse({ type: "superRefine", val: 12 })).toEqual({
-    type: "superRefine",
-    val: 12,
-  });
-  expect(schema.parse({ type: "lazy", val: 13 })).toEqual({
-    type: "lazy",
-    val: 13,
-  });
-  expect(schema.parse({ type: "chained 1", val: 14 })).toEqual({
-    val: 14,
-  });
-  expect(schema.parse({ type: "chained 2", val: 15 })).toEqual({
-    val: 15,
-  });
-  expect(schema.parse({ type: "chained 3", val: 16 })).toEqual({
-    val: 16,
-  });
-  expect(schema.parse({ type: "lazy typed", val: 17 })).toEqual({
-    type: "lazy typed",
-    val: 17,
-  });
 });
 
 test("invalid - null", () => {
@@ -196,9 +129,7 @@ test("wrong schema - missing discriminator", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toEqual(
-      "The discriminator value could not be extracted from all the provided schemas"
-    );
+    expect(e.message).toContain("could not be extracted");
   }
 });
 
@@ -210,9 +141,7 @@ test("wrong schema - duplicate discriminator values", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toEqual(
-      "Some of the discriminator values are not unique"
-    );
+    expect(e.message).toContain("has duplicate value");
   }
 });
 
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index d41e66181..a167587d5 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -18,7 +18,7 @@ import {
   ParsePath,
   ParseReturnType,
   ParseStatus,
-  SyncParseReturnType
+  SyncParseReturnType,
 } from "./helpers/parseUtil.ts";
 import { partialUtil } from "./helpers/partialUtil.ts";
 import { Primitive } from "./helpers/typeAliases.ts";
@@ -30,7 +30,7 @@ import {
   ZodError,
   ZodErrorMap,
   ZodIssue,
-  ZodIssueCode
+  ZodIssueCode,
 } from "./ZodError.ts";
 
 ///////////////////////////////////////
@@ -2137,80 +2137,46 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 
-type ZodSourceType<T extends ZodTypeAny> = T extends ZodLazy<infer U>
-  ? ZodSourceType<U>
-  : T extends ZodEffects<infer U>
-  ? ZodSourceType<U>
-  : T;
-
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-type ZodOriginType<T extends ZodTypeAny, D extends Prev[number] = 9> = [
-  D
-] extends [never]
-  ? never
-  :
-      | T
-      | ZodEffects<ZodOriginType<T, Prev[D]>>
-      | ZodLazy<ZodOriginType<T, Prev[D]>>;
-
-function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
-  if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
-    return getSourceType(
-      (type as unknown as ZodLazy<ZodTypeAny>).schema
-    ) as ZodSourceType<T>;
-  } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
-    return getSourceType(
-      (type as unknown as ZodEffects<ZodTypeAny>).sourceType()
-    ) as ZodSourceType<T>;
+const getDiscriminator = <T extends ZodTypeAny>(
+  type: T
+): Primitive[] | null => {
+  if (type instanceof ZodLazy) {
+    return getDiscriminator(type.schema);
+  } else if (type instanceof ZodEffects) {
+    return getDiscriminator(type.innerType());
+  } else if (type instanceof ZodLiteral) {
+    return [type.value];
+  } else if (type instanceof ZodEnum) {
+    return type.options;
+  } else if (type instanceof ZodUndefined) {
+    return [undefined];
+  } else if (type instanceof ZodNull) {
+    return [null];
   } else {
-    return type as ZodSourceType<T>;
+    return null;
   }
-}
-
-type ZodDiscriminatedUnionOptionBase<
-  Discriminator extends string,
-  DiscriminatorValue extends Primitive
-> = ZodObject<
-  { [key in Discriminator]: ZodLiteral<DiscriminatorValue> } & ZodRawShape,
-  any,
-  any
->;
-
-type ZodDiscriminatedUnionType<Discriminator extends string> = Record<
-  string,
-  any
-> & {
-  [key in Discriminator]: Primitive;
 };
 
-export type ZodDiscriminatedUnionOption<
-  Discriminator extends string,
-  DiscriminatorValue extends Primitive
-> =
-  | ZodOriginType<
-      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-    >
-  | ZodType<any, any, ZodDiscriminatedUnionType<Discriminator>>;
+export type ZodDiscriminatedUnionOption<Discriminator extends string> =
+  ZodObject<{ [key in Discriminator]: ZodTypeAny } & ZodRawShape, any, any>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
-  DiscriminatorValue extends Primitive,
-  Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>
+  Options extends ZodDiscriminatedUnionOption<any>[]
 > extends ZodTypeDef {
   discriminator: Discriminator;
-  options: Map<DiscriminatorValue, Option>;
+  options: Options;
+  optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
   typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
 }
 
 export class ZodDiscriminatedUnion<
   Discriminator extends string,
-  DiscriminatorValue extends Primitive,
-  Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>
+  Options extends ZodDiscriminatedUnionOption<Discriminator>[]
 > extends ZodType<
-  output<Option>,
-  ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>,
-  input<Option>
+  output<Options[number]>,
+  ZodDiscriminatedUnionDef<Discriminator, Options>,
+  input<Options[number]>
 > {
   _parse(input: ParseInput): ParseReturnType<this["_output"]> {
     const { ctx } = this._processInputParams(input);
@@ -2225,13 +2191,13 @@ export class ZodDiscriminatedUnion<
     }
 
     const discriminator = this.discriminator;
-    const discriminatorValue: DiscriminatorValue = ctx.data[discriminator];
-    const option = this.options.get(discriminatorValue);
+    const discriminatorValue: string = ctx.data[discriminator];
+    const option = this.optionsMap.get(discriminatorValue);
 
     if (!option) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
-        options: this.validDiscriminatorValues,
+        options: Array.from(this.optionsMap.keys()),
         path: [discriminator],
       });
       return INVALID;
@@ -2242,13 +2208,13 @@ export class ZodDiscriminatedUnion<
         data: ctx.data,
         path: ctx.path,
         parent: ctx,
-      });
+      }) as any;
     } else {
       return option._parseSync({
         data: ctx.data,
         path: ctx.path,
         parent: ctx,
-      });
+      }) as any;
     }
   }
 
@@ -2256,14 +2222,14 @@ export class ZodDiscriminatedUnion<
     return this._def.discriminator;
   }
 
-  get validDiscriminatorValues() {
-    return Array.from(this.options.keys());
-  }
-
   get options() {
     return this._def.options;
   }
 
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+
   /**
    * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
    * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
@@ -2274,48 +2240,45 @@ export class ZodDiscriminatedUnion<
    */
   static create<
     Discriminator extends string,
-    DiscriminatorValue extends Primitive,
     Types extends [
-      ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
-      ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
-      ...ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>[]
+      ZodDiscriminatedUnionOption<Discriminator>,
+      ...ZodDiscriminatedUnionOption<Discriminator>[]
     ]
   >(
     discriminator: Discriminator,
-    types: Types,
+    options: Types,
     params?: RawCreateParams
-  ): ZodDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]> {
+  ): ZodDiscriminatedUnion<Discriminator, Types> {
     // Get all the valid discriminator values
-    const options: Map<DiscriminatorValue, Types[number]> = new Map();
-
-    try {
-      types.forEach((type) => {
-        const discriminatorValue = getSourceType(
-          type as ZodOriginType<
-            ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-          >
-        ).shape[discriminator].value;
-        options.set(discriminatorValue, type);
-      });
-    } catch (e) {
-      throw new Error(
-        "The discriminator value could not be extracted from all the provided schemas"
-      );
-    }
-
-    // Assert that all the discriminator values are unique
-    if (options.size !== types.length) {
-      throw new Error("Some of the discriminator values are not unique");
+    const optionsMap: Map<Primitive, Types[number]> = new Map();
+
+    // try {
+    for (const type of options) {
+      const discriminatorValues = getDiscriminator(type.shape[discriminator]);
+      if (!discriminatorValues) {
+        throw new Error(
+          `A discriminator value for key \`${discriminator}\`could not be extracted from all schema options`
+        );
+      }
+      for (const value of discriminatorValues) {
+        if (optionsMap.has(value)) {
+          throw new Error(
+            `Discriminator property ${discriminator} has duplicate value ${value}`
+          );
+        }
+        optionsMap.set(value, type);
+      }
     }
 
     return new ZodDiscriminatedUnion<
       Discriminator,
-      DiscriminatorValue,
-      Types[number]
+      // DiscriminatorValue,
+      Types
     >({
       typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
       discriminator,
       options,
+      optionsMap,
       ...processCreateParams(params),
     });
   }
@@ -3911,7 +3874,7 @@ export type ZodFirstPartySchemaTypes =
   | ZodArray<any, any>
   | ZodObject<any, any, any, any, any>
   | ZodUnion<any>
-  | ZodDiscriminatedUnion<any, any, any>
+  | ZodDiscriminatedUnion<any, any>
   | ZodIntersection<any, any>
   | ZodTuple<any, any>
   | ZodRecord<any, any>
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index 1effe0f07..009f65949 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -14,11 +14,6 @@ test("valid", () => {
 });
 
 test("valid - discriminator value of various primitive types", () => {
-  interface lazy {
-    type: "lazy typed";
-    val: 17;
-  }
-
   const schema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("1"), val: z.literal(1) }),
     z.object({ type: z.literal(1), val: z.literal(2) }),
@@ -29,43 +24,9 @@ test("valid - discriminator value of various primitive types", () => {
     z.object({ type: z.literal(null), val: z.literal(7) }),
     z.object({ type: z.literal("undefined"), val: z.literal(8) }),
     z.object({ type: z.literal(undefined), val: z.literal(9) }),
-    z
-      .object({ type: z.literal("transform"), val: z.literal(10) })
-      .transform((val) => ({
-        val: val.val,
-      })),
-    z
-      .object({ type: z.literal("refine"), val: z.literal(11) })
-      .refine(() => true),
-    z
-      .object({ type: z.literal("superRefine"), val: z.literal(12) })
-      .superRefine(() => {}),
-    z.lazy(() => z.object({ type: z.literal("lazy"), val: z.literal(13) })),
-    z.lazy(() =>
-      z
-        .object({ type: z.literal("chained 1"), val: z.literal(14) })
-        .transform((val) => ({
-          val: val.val,
-        }))
-    ),
-    z
-      .lazy(() =>
-        z.object({ type: z.literal("chained 2"), val: z.literal(15) })
-      )
-      .transform((val) => ({
-        val: val.val,
-      })),
-    z
-      .lazy(() =>
-        z.object({ type: z.literal("chained 3"), val: z.literal(16) })
-      )
-      .transform((val) => ({
-        val: val.val,
-      }))
-      .refine(() => true),
-    z.lazy(() =>
-      z.object({ type: z.literal("lazy typed"), val: z.literal(17) })
-    ) as z.ZodType<lazy>,
+    z.object({ type: z.literal("transform"), val: z.literal(10) }),
+    z.object({ type: z.literal("refine"), val: z.literal(11) }),
+    z.object({ type: z.literal("superRefine"), val: z.literal(12) }),
   ]);
 
   expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
@@ -98,34 +59,6 @@ test("valid - discriminator value of various primitive types", () => {
     type: undefined,
     val: 9,
   });
-  expect(schema.parse({ type: "transform", val: 10 })).toEqual({
-    val: 10,
-  });
-  expect(schema.parse({ type: "refine", val: 11 })).toEqual({
-    type: "refine",
-    val: 11,
-  });
-  expect(schema.parse({ type: "superRefine", val: 12 })).toEqual({
-    type: "superRefine",
-    val: 12,
-  });
-  expect(schema.parse({ type: "lazy", val: 13 })).toEqual({
-    type: "lazy",
-    val: 13,
-  });
-  expect(schema.parse({ type: "chained 1", val: 14 })).toEqual({
-    val: 14,
-  });
-  expect(schema.parse({ type: "chained 2", val: 15 })).toEqual({
-    val: 15,
-  });
-  expect(schema.parse({ type: "chained 3", val: 16 })).toEqual({
-    val: 16,
-  });
-  expect(schema.parse({ type: "lazy typed", val: 17 })).toEqual({
-    type: "lazy typed",
-    val: 17,
-  });
 });
 
 test("invalid - null", () => {
@@ -195,9 +128,7 @@ test("wrong schema - missing discriminator", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toEqual(
-      "The discriminator value could not be extracted from all the provided schemas"
-    );
+    expect(e.message).toContain("could not be extracted");
   }
 });
 
@@ -209,9 +140,7 @@ test("wrong schema - duplicate discriminator values", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toEqual(
-      "Some of the discriminator values are not unique"
-    );
+    expect(e.message).toContain("has duplicate value");
   }
 });
 
diff --git a/src/types.ts b/src/types.ts
index d32db550a..3a15bfe5c 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -18,7 +18,7 @@ import {
   ParsePath,
   ParseReturnType,
   ParseStatus,
-  SyncParseReturnType
+  SyncParseReturnType,
 } from "./helpers/parseUtil";
 import { partialUtil } from "./helpers/partialUtil";
 import { Primitive } from "./helpers/typeAliases";
@@ -30,7 +30,7 @@ import {
   ZodError,
   ZodErrorMap,
   ZodIssue,
-  ZodIssueCode
+  ZodIssueCode,
 } from "./ZodError";
 
 ///////////////////////////////////////
@@ -2137,80 +2137,46 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 
-type ZodSourceType<T extends ZodTypeAny> = T extends ZodLazy<infer U>
-  ? ZodSourceType<U>
-  : T extends ZodEffects<infer U>
-  ? ZodSourceType<U>
-  : T;
-
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-type ZodOriginType<T extends ZodTypeAny, D extends Prev[number] = 9> = [
-  D
-] extends [never]
-  ? never
-  :
-      | T
-      | ZodEffects<ZodOriginType<T, Prev[D]>>
-      | ZodLazy<ZodOriginType<T, Prev[D]>>;
-
-function getSourceType<T extends ZodTypeAny>(type: T): ZodSourceType<T> {
-  if (type._def.typeName === ZodFirstPartyTypeKind.ZodLazy) {
-    return getSourceType(
-      (type as unknown as ZodLazy<ZodTypeAny>).schema
-    ) as ZodSourceType<T>;
-  } else if (type._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
-    return getSourceType(
-      (type as unknown as ZodEffects<ZodTypeAny>).sourceType()
-    ) as ZodSourceType<T>;
+const getDiscriminator = <T extends ZodTypeAny>(
+  type: T
+): Primitive[] | null => {
+  if (type instanceof ZodLazy) {
+    return getDiscriminator(type.schema);
+  } else if (type instanceof ZodEffects) {
+    return getDiscriminator(type.innerType());
+  } else if (type instanceof ZodLiteral) {
+    return [type.value];
+  } else if (type instanceof ZodEnum) {
+    return type.options;
+  } else if (type instanceof ZodUndefined) {
+    return [undefined];
+  } else if (type instanceof ZodNull) {
+    return [null];
   } else {
-    return type as ZodSourceType<T>;
+    return null;
   }
-}
-
-type ZodDiscriminatedUnionOptionBase<
-  Discriminator extends string,
-  DiscriminatorValue extends Primitive
-> = ZodObject<
-  { [key in Discriminator]: ZodLiteral<DiscriminatorValue> } & ZodRawShape,
-  any,
-  any
->;
-
-type ZodDiscriminatedUnionType<Discriminator extends string> = Record<
-  string,
-  any
-> & {
-  [key in Discriminator]: Primitive;
 };
 
-export type ZodDiscriminatedUnionOption<
-  Discriminator extends string,
-  DiscriminatorValue extends Primitive
-> =
-  | ZodOriginType<
-      ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-    >
-  | ZodType<any, any, ZodDiscriminatedUnionType<Discriminator>>;
+export type ZodDiscriminatedUnionOption<Discriminator extends string> =
+  ZodObject<{ [key in Discriminator]: ZodTypeAny } & ZodRawShape, any, any>;
 
 export interface ZodDiscriminatedUnionDef<
   Discriminator extends string,
-  DiscriminatorValue extends Primitive,
-  Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>
+  Options extends ZodDiscriminatedUnionOption<any>[]
 > extends ZodTypeDef {
   discriminator: Discriminator;
-  options: Map<DiscriminatorValue, Option>;
+  options: Options;
+  optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
   typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
 }
 
 export class ZodDiscriminatedUnion<
   Discriminator extends string,
-  DiscriminatorValue extends Primitive,
-  Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>
+  Options extends ZodDiscriminatedUnionOption<Discriminator>[]
 > extends ZodType<
-  output<Option>,
-  ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>,
-  input<Option>
+  output<Options[number]>,
+  ZodDiscriminatedUnionDef<Discriminator, Options>,
+  input<Options[number]>
 > {
   _parse(input: ParseInput): ParseReturnType<this["_output"]> {
     const { ctx } = this._processInputParams(input);
@@ -2225,13 +2191,13 @@ export class ZodDiscriminatedUnion<
     }
 
     const discriminator = this.discriminator;
-    const discriminatorValue: DiscriminatorValue = ctx.data[discriminator];
-    const option = this.options.get(discriminatorValue);
+    const discriminatorValue: string = ctx.data[discriminator];
+    const option = this.optionsMap.get(discriminatorValue);
 
     if (!option) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
-        options: this.validDiscriminatorValues,
+        options: Array.from(this.optionsMap.keys()),
         path: [discriminator],
       });
       return INVALID;
@@ -2242,13 +2208,13 @@ export class ZodDiscriminatedUnion<
         data: ctx.data,
         path: ctx.path,
         parent: ctx,
-      });
+      }) as any;
     } else {
       return option._parseSync({
         data: ctx.data,
         path: ctx.path,
         parent: ctx,
-      });
+      }) as any;
     }
   }
 
@@ -2256,14 +2222,14 @@ export class ZodDiscriminatedUnion<
     return this._def.discriminator;
   }
 
-  get validDiscriminatorValues() {
-    return Array.from(this.options.keys());
-  }
-
   get options() {
     return this._def.options;
   }
 
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+
   /**
    * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
    * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
@@ -2274,48 +2240,45 @@ export class ZodDiscriminatedUnion<
    */
   static create<
     Discriminator extends string,
-    DiscriminatorValue extends Primitive,
     Types extends [
-      ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
-      ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
-      ...ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>[]
+      ZodDiscriminatedUnionOption<Discriminator>,
+      ...ZodDiscriminatedUnionOption<Discriminator>[]
     ]
   >(
     discriminator: Discriminator,
-    types: Types,
+    options: Types,
     params?: RawCreateParams
-  ): ZodDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]> {
+  ): ZodDiscriminatedUnion<Discriminator, Types> {
     // Get all the valid discriminator values
-    const options: Map<DiscriminatorValue, Types[number]> = new Map();
-
-    try {
-      types.forEach((type) => {
-        const discriminatorValue = getSourceType(
-          type as ZodOriginType<
-            ZodDiscriminatedUnionOptionBase<Discriminator, DiscriminatorValue>
-          >
-        ).shape[discriminator].value;
-        options.set(discriminatorValue, type);
-      });
-    } catch (e) {
-      throw new Error(
-        "The discriminator value could not be extracted from all the provided schemas"
-      );
-    }
-
-    // Assert that all the discriminator values are unique
-    if (options.size !== types.length) {
-      throw new Error("Some of the discriminator values are not unique");
+    const optionsMap: Map<Primitive, Types[number]> = new Map();
+
+    // try {
+    for (const type of options) {
+      const discriminatorValues = getDiscriminator(type.shape[discriminator]);
+      if (!discriminatorValues) {
+        throw new Error(
+          `A discriminator value for key \`${discriminator}\`could not be extracted from all schema options`
+        );
+      }
+      for (const value of discriminatorValues) {
+        if (optionsMap.has(value)) {
+          throw new Error(
+            `Discriminator property ${discriminator} has duplicate value ${value}`
+          );
+        }
+        optionsMap.set(value, type);
+      }
     }
 
     return new ZodDiscriminatedUnion<
       Discriminator,
-      DiscriminatorValue,
-      Types[number]
+      // DiscriminatorValue,
+      Types
     >({
       typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
       discriminator,
       options,
+      optionsMap,
       ...processCreateParams(params),
     });
   }
@@ -3911,7 +3874,7 @@ export type ZodFirstPartySchemaTypes =
   | ZodArray<any, any>
   | ZodObject<any, any, any, any, any>
   | ZodUnion<any>
-  | ZodDiscriminatedUnion<any, any, any>
+  | ZodDiscriminatedUnion<any, any>
   | ZodIntersection<any, any>
   | ZodTuple<any, any>
   | ZodRecord<any, any>

From c39d1746f179d39290867566953bf76d54d83303 Mon Sep 17 00:00:00 2001
From: Colin McDonnell <colinmcd@alum.mit.edu>
Date: Tue, 15 Nov 2022 00:37:27 -0800
Subject: [PATCH 10/10] Fix deno test

---
 deno/lib/__tests__/discriminatedUnions.test.ts | 4 ++--
 src/__tests__/discriminatedUnions.test.ts      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/deno/lib/__tests__/discriminatedUnions.test.ts b/deno/lib/__tests__/discriminatedUnions.test.ts
index 45b57f289..9b9919b39 100644
--- a/deno/lib/__tests__/discriminatedUnions.test.ts
+++ b/deno/lib/__tests__/discriminatedUnions.test.ts
@@ -129,7 +129,7 @@ test("wrong schema - missing discriminator", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toContain("could not be extracted");
+    expect(e.message.includes("could not be extracted")).toBe(true);
   }
 });
 
@@ -141,7 +141,7 @@ test("wrong schema - duplicate discriminator values", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toContain("has duplicate value");
+    expect(e.message.includes("has duplicate value")).toEqual(true);
   }
 });
 
diff --git a/src/__tests__/discriminatedUnions.test.ts b/src/__tests__/discriminatedUnions.test.ts
index 009f65949..6f4615aa5 100644
--- a/src/__tests__/discriminatedUnions.test.ts
+++ b/src/__tests__/discriminatedUnions.test.ts
@@ -128,7 +128,7 @@ test("wrong schema - missing discriminator", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toContain("could not be extracted");
+    expect(e.message.includes("could not be extracted")).toBe(true);
   }
 });
 
@@ -140,7 +140,7 @@ test("wrong schema - duplicate discriminator values", () => {
     ]);
     throw new Error();
   } catch (e: any) {
-    expect(e.message).toContain("has duplicate value");
+    expect(e.message.includes("has duplicate value")).toEqual(true);
   }
 });