From 4c3b953a3217cdb92561a627008f02e585af463a Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 31 Dec 2022 02:55:37 +0200
Subject: [PATCH 01/40] `ZodTemplateLiteral` initial commit.

---
 deno/lib/README.md | 34 +++++++++----------
 deno/lib/types.ts  | 84 ++++++++++++++++++++++++++++++++++++++++++++--
 src/types.ts       | 80 ++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 177 insertions(+), 21 deletions(-)

diff --git a/deno/lib/README.md b/deno/lib/README.md
index b502de431..d0a97ea10 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -47,8 +47,9 @@
   - [Sponsors](#sponsors)
   - [Ecosystem](#ecosystem)
 - [Installation](#installation)
-  - [Node/npm](#nodenpm)
-  - [Deno](#deno)
+  - [Requirements](#requirements)
+  - [Node/npm](#from-npm-nodebun)
+  - [Deno](#from-denolandx-deno)
 - [Basic usage](#basic-usage)
 - [Primitives](#primitives)
 - [Literals](#literals)
@@ -1294,7 +1295,7 @@ const myUnion = z.discriminatedUnion("status", [
   z.object({ status: z.literal("failed"), error: z.instanceof(Error) }),
 ]);
 
-myUnion.parse({ type: "success", data: "yippie ki yay" });
+myUnion.parse({ status: "success", data: "yippie ki yay" });
 ```
 
 ## Records
@@ -1682,7 +1683,7 @@ Given any Zod schema, you can call its `.parse` method to check `data` is valid.
 const stringSchema = z.string();
 
 stringSchema.parse("fish"); // => returns "fish"
-stringSchema.parse(12); // throws Error('Non-string type: number');
+stringSchema.parse(12); // throws error
 ```
 
 ### `.parseAsync`
@@ -1692,11 +1693,10 @@ stringSchema.parse(12); // throws Error('Non-string type: number');
 If you use asynchronous [refinements](#refine) or [transforms](#transform) (more on those later), you'll need to use `.parseAsync`
 
 ```ts
-const stringSchema1 = z.string().refine(async (val) => val.length < 20);
-const value1 = await stringSchema.parseAsync("hello"); // => hello
+const stringSchema = z.string().refine(async (val) => val.length <= 8);
 
-const stringSchema2 = z.string().refine(async (val) => val.length > 20);
-const value2 = await stringSchema.parseAsync("hello"); // => throws
+await stringSchema.parseAsync("hello"); // => returns "hello"
+await stringSchema.parseAsync("hello world"); // => throws error
 ```
 
 ### `.safeParse`
@@ -1781,7 +1781,7 @@ type RefineParams = {
 };
 ```
 
-For advanced cases, the second argument can also be a function that returns `RefineParams`/
+For advanced cases, the second argument can also be a function that returns `RefineParams`.
 
 ```ts
 const longString = z.string().refine(
@@ -1892,7 +1892,7 @@ const Strings = z.array(z.string()).superRefine((val, ctx) => {
 
 You can add as many issues as you like. If `ctx.addIssue` is _not_ called during the execution of the function, validation passes.
 
-Normally refinements always create issues with a `ZodIssueCode.custom` error code, but with `superRefine` you can create any issue of any code. Each issue code is described in detail in the Error Handling guide: [ERROR_HANDLING.md](ERROR_HANDLING.md).
+Normally refinements always create issues with a `ZodIssueCode.custom` error code, but with `superRefine` it's possible to throw issues of any `ZodIssueCode`. Each issue code is described in detail in the Error Handling guide: [ERROR_HANDLING.md](ERROR_HANDLING.md).
 
 #### Abort early
 
@@ -1921,7 +1921,7 @@ const schema = z.number().superRefine((val, ctx) => {
 
 #### Type refinements
 
-If you provide a [type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) to `.refine()` or `superRefine()`, the resulting type will be narrowed down to your predicate's type. This is useful if you are mixing multiple chained refinements and transformations:
+If you provide a [type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) to `.refine()` or `.superRefine()`, the resulting type will be narrowed down to your predicate's type. This is useful if you are mixing multiple chained refinements and transformations:
 
 ```ts
 const schema = z
@@ -1936,15 +1936,15 @@ const schema = z
         code: z.ZodIssueCode.custom, // customize your issue
         message: "object should exist",
       });
-      return false;
     }
-    return true;
+
+    return z.NEVER; // The return value is not used, but we need to return something to satisfy the typing
   })
   // here, TS knows that arg is not null
   .refine((arg) => arg.first === "bob", "`first` is not `bob`!");
 ```
 
-> ⚠️ You must **still** call `ctx.addIssue()` if using `superRefine()` with a type predicate function. Otherwise the refinement won't be validated.
+> ⚠️ You **must** use `ctx.addIssue()` instead of returning a boolean value to indicate whether the validation passes. If `ctx.addIssue` is _not_ called during the execution of the function, validation passes.
 
 ### `.transform`
 
@@ -1971,12 +1971,12 @@ emailToDomain.parse("colinhacks@example.com"); // => example.com
 
 #### Validating during transform
 
-The `.transform` method can simultaneously validate and transform the value. This is often simpler and less duplicative than chaining `refine` and `validate`.
+The `.transform` method can simultaneously validate and transform the value. This is often simpler and less duplicative than chaining `transform` and `refine`.
 
 As with `.superRefine`, the transform function receives a `ctx` object with a `addIssue` method that can be used to register validation issues.
 
 ```ts
-const Strings = z.string().transform((val, ctx) => {
+const numberInString = z.string().transform((val, ctx) => {
   const parsed = parseInt(val);
   if (isNaN(parsed)) {
     ctx.addIssue({
@@ -2464,7 +2464,7 @@ This more declarative API makes schema definitions vastly more concise.
 
 [https://github.com/pelotom/runtypes](https://github.com/pelotom/runtypes)
 
-Good type inference support, but limited options for object type masking (no `.pick` , `.omit` , `.extend` , etc.). No support for `Record` s (their `Record` is equivalent to Zod's `object` ). They DO support branded and readonly types, which Zod does not.
+Good type inference support, but limited options for object type masking (no `.pick` , `.omit` , `.extend` , etc.). No support for `Record` s (their `Record` is equivalent to Zod's `object` ). They DO support readonly types, which Zod does not.
 
 - Supports "pattern matching": computed properties that distribute over unions
 - Supports readonly types
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 895da711f..d5ece9bb4 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -1713,7 +1713,7 @@ export class ZodArray<
 
     if (ctx.common.async) {
       return Promise.all(
-        (ctx.data as any[]).map((item, i) => {
+        ([...ctx.data] as any[]).map((item, i) => {
           return def.type._parseAsync(
             new ParseInputLazyPath(ctx, item, ctx.path, i)
           );
@@ -1723,7 +1723,7 @@ export class ZodArray<
       });
     }
 
-    const result = (ctx.data as any[]).map((item, i) => {
+    const result = ([...ctx.data] as any[]).map((item, i) => {
       return def.type._parseSync(
         new ParseInputLazyPath(ctx, item, ctx.path, i)
       );
@@ -4286,6 +4286,80 @@ export class ZodPipeline<
   }
 }
 
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////  ZodTemplateLiteral  //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+type TemplateLiteralPrimitivePart =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | undefined;
+
+type TemplateLiteralZodTypePart = ZodType<TemplateLiteralPrimitivePart>;
+
+type appendToTemplateLiteral<
+  Template extends string,
+  Suffix extends TemplateLiteralPrimitivePart | ZodType
+> = Suffix extends TemplateLiteralPrimitivePart
+  ? `${Template}${Suffix}`
+  : Suffix extends ZodType<infer Output, any, any>
+  ? Output extends TemplateLiteralPrimitivePart
+    ? `${Template}${Output}`
+    : never
+  : never;
+
+export interface ZodTemplateLiteralDef extends ZodTypeDef {
+  parts: readonly (string | number | bigint | ZodType)[];
+  typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
+}
+
+export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
+  Template,
+  ZodTemplateLiteralDef
+> {
+  addPart<Z extends TemplateLiteralZodTypePart>(
+    part: Z
+  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, Z>> {
+    return new ZodTemplateLiteral({
+      ...this._def,
+      parts: [...this._def.parts, part],
+    });
+  }
+
+  _parse(input: ParseInput): ParseReturnType<Template> {
+    const parsedType = this._getType(input);
+
+    if (parsedType !== ZodParsedType.string) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.string,
+        received: ctx.parsedType,
+      });
+      return INVALID;
+    }
+
+    // TODO: validate!!!
+
+    throw new Error("unimplemented!");
+  }
+
+  static create = (params?: RawCreateParams): ZodTemplateLiteral => {
+    return new ZodTemplateLiteral({
+      ...processCreateParams(params),
+      parts: [],
+      typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral,
+    });
+  };
+}
+
 export const custom = <T>(
   check?: (data: unknown) => any,
   params: Parameters<ZodTypeAny["refine"]>[1] = {},
@@ -4344,6 +4418,7 @@ export enum ZodFirstPartyTypeKind {
   ZodPromise = "ZodPromise",
   ZodBranded = "ZodBranded",
   ZodPipeline = "ZodPipeline",
+  ZodTemplateLiteral = "ZodTemplateLiteral",
 }
 export type ZodFirstPartySchemaTypes =
   | ZodString
@@ -4379,7 +4454,8 @@ export type ZodFirstPartySchemaTypes =
   | ZodCatch<any>
   | ZodPromise<any>
   | ZodBranded<any, any>
-  | ZodPipeline<any, any>;
+  | ZodPipeline<any, any>
+  | ZodTemplateLiteral<any>;
 
 // new approach that works for abstract classes
 // but requires TS 4.4+
@@ -4428,6 +4504,7 @@ const optionalType = ZodOptional.create;
 const nullableType = ZodNullable.create;
 const preprocessType = ZodEffects.createWithPreprocess;
 const pipelineType = ZodPipeline.create;
+const templateLiteralType = ZodTemplateLiteral.create;
 const ostring = () => stringType().optional();
 const onumber = () => numberType().optional();
 const oboolean = () => booleanType().optional();
@@ -4479,6 +4556,7 @@ export {
   strictObjectType as strictObject,
   stringType as string,
   symbolType as symbol,
+  templateLiteralType as templateLiteral,
   effectsType as transformer,
   tupleType as tuple,
   undefinedType as undefined,
diff --git a/src/types.ts b/src/types.ts
index b26982250..103362b21 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4286,6 +4286,80 @@ export class ZodPipeline<
   }
 }
 
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////  ZodTemplateLiteral  //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+type TemplateLiteralPrimitivePart =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | undefined;
+
+type TemplateLiteralZodTypePart = ZodType<TemplateLiteralPrimitivePart>;
+
+type appendToTemplateLiteral<
+  Template extends string,
+  Suffix extends TemplateLiteralPrimitivePart | ZodType
+> = Suffix extends TemplateLiteralPrimitivePart
+  ? `${Template}${Suffix}`
+  : Suffix extends ZodType<infer Output, any, any>
+  ? Output extends TemplateLiteralPrimitivePart
+    ? `${Template}${Output}`
+    : never
+  : never;
+
+export interface ZodTemplateLiteralDef extends ZodTypeDef {
+  parts: readonly (string | number | bigint | ZodType)[];
+  typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
+}
+
+export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
+  Template,
+  ZodTemplateLiteralDef
+> {
+  addPart<Z extends TemplateLiteralZodTypePart>(
+    part: Z
+  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, Z>> {
+    return new ZodTemplateLiteral({
+      ...this._def,
+      parts: [...this._def.parts, part],
+    });
+  }
+
+  _parse(input: ParseInput): ParseReturnType<Template> {
+    const parsedType = this._getType(input);
+
+    if (parsedType !== ZodParsedType.string) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.string,
+        received: ctx.parsedType,
+      });
+      return INVALID;
+    }
+
+    // TODO: validate!!!
+
+    throw new Error("unimplemented!");
+  }
+
+  static create = (params?: RawCreateParams): ZodTemplateLiteral => {
+    return new ZodTemplateLiteral({
+      ...processCreateParams(params),
+      parts: [],
+      typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral,
+    });
+  };
+}
+
 export const custom = <T>(
   check?: (data: unknown) => any,
   params: Parameters<ZodTypeAny["refine"]>[1] = {},
@@ -4344,6 +4418,7 @@ export enum ZodFirstPartyTypeKind {
   ZodPromise = "ZodPromise",
   ZodBranded = "ZodBranded",
   ZodPipeline = "ZodPipeline",
+  ZodTemplateLiteral = "ZodTemplateLiteral",
 }
 export type ZodFirstPartySchemaTypes =
   | ZodString
@@ -4379,7 +4454,8 @@ export type ZodFirstPartySchemaTypes =
   | ZodCatch<any>
   | ZodPromise<any>
   | ZodBranded<any, any>
-  | ZodPipeline<any, any>;
+  | ZodPipeline<any, any>
+  | ZodTemplateLiteral<any>;
 
 // new approach that works for abstract classes
 // but requires TS 4.4+
@@ -4428,6 +4504,7 @@ const optionalType = ZodOptional.create;
 const nullableType = ZodNullable.create;
 const preprocessType = ZodEffects.createWithPreprocess;
 const pipelineType = ZodPipeline.create;
+const templateLiteralType = ZodTemplateLiteral.create;
 const ostring = () => stringType().optional();
 const onumber = () => numberType().optional();
 const oboolean = () => booleanType().optional();
@@ -4479,6 +4556,7 @@ export {
   strictObjectType as strictObject,
   stringType as string,
   symbolType as symbol,
+  templateLiteralType as templateLiteral,
   effectsType as transformer,
   tupleType as tuple,
   undefinedType as undefined,

From 6aeb3e47210e5eb2b05a3d547aedcc5ac7d41e41 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 31 Dec 2022 16:45:24 +0200
Subject: [PATCH 02/40] `ZodTemplateLiteral` regex building & parsing.

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

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index d5ece9bb4..2ddcae4c6 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4316,7 +4316,8 @@ type appendToTemplateLiteral<
   : never;
 
 export interface ZodTemplateLiteralDef extends ZodTypeDef {
-  parts: readonly (string | number | bigint | ZodType)[];
+  parts: readonly (TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart)[];
+  regexString: string;
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
 
@@ -4327,9 +4328,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   addPart<Z extends TemplateLiteralZodTypePart>(
     part: Z
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, Z>> {
+    const parts = [...this._def.parts, part];
+
     return new ZodTemplateLiteral({
       ...this._def,
-      parts: [...this._def.parts, part],
+      parts,
+      regexString: this._buildRegexString(parts),
     });
   }
 
@@ -4346,15 +4350,114 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return INVALID;
     }
 
-    // TODO: validate!!!
+    if (!new RegExp(this._def.regexString).test(input.data)) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_string,
+        message: `does not match template literal with pattern /${this._def.regexString}/`,
+        path: ctx.path,
+        validation: "regex",
+      });
+      return INVALID;
+    }
+
+    return { status: "valid", value: input.data };
+  }
+
+  protected _buildRegexString(
+    parts: readonly (
+      | TemplateLiteralPrimitivePart
+      | TemplateLiteralZodTypePart
+    )[]
+  ): string {
+    return (
+      parts.reduce<string>((acc, part) => {
+        if (typeof part !== "object") {
+          return `${acc}${this._escapeForRegex(part)}`;
+        }
+
+        if (part instanceof ZodLiteral) {
+          return `${acc}${this._escapeForRegex(part._def.value)}`;
+        }
+
+        if (part instanceof ZodString) {
+          // FIXME: should we care for string's validations? e.g. regex, uuid, etc.
+          return `${acc}.{${part.minLength || 0},${part.maxLength ?? ""}}`;
+        }
+
+        if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
+          const values =
+            part instanceof ZodEnum
+              ? part._def.values
+              : util.getValidEnumValues(part._def.values);
+
+          return `${acc}(${values.map(this._escapeForRegex).join("|")})`;
+        }
+
+        if (part instanceof ZodNumber) {
+          const max = part.maxValue || Infinity;
+          const min = part.minValue || -Infinity;
+          const isFinite = part.isFinite;
+
+          if (min < 0 || max < 0) {
+            acc = `${acc}\\-`;
+
+            if (max >= 0) {
+              acc = `${acc}?`;
+            }
+          }
+
+          if (!isFinite) {
+            acc = `${acc}(Infinity|(`;
+          }
+
+          acc = `${acc}\\d+`;
+
+          if (!part.isInt) {
+            acc = `${acc}(\\.\\d+)?`;
+          }
+
+          return !isFinite ? `${acc}))` : acc;
+        }
+
+        if (part instanceof ZodBigInt) {
+          // FIXME: include/exclude '-' based on min/max values after https://github.com/colinhacks/zod/pull/1711 is merged.
+          return `${acc}\\-?\\d+`;
+        }
+
+        if (part instanceof ZodBoolean) {
+          return `${acc}(true|false)`;
+        }
 
-    throw new Error("unimplemented!");
+        if (part instanceof ZodNull) {
+          return `${acc}null`;
+        }
+
+        if (part instanceof ZodUndefined) {
+          return `${acc}undefined`;
+        }
+
+        return acc;
+      }, "^") + "$"
+    );
+  }
+
+  protected _escapeForRegex(str: unknown): string {
+    if (typeof str !== "string") {
+      return `${str}`;
+    }
+
+    return str.replace(
+      /(\(|\)|\[|\]|\{|\}|\.|\\|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/,
+      "\\$1"
+    );
   }
 
   static create = (params?: RawCreateParams): ZodTemplateLiteral => {
     return new ZodTemplateLiteral({
       ...processCreateParams(params),
       parts: [],
+      regexString: "^$",
       typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral,
     });
   };
diff --git a/src/types.ts b/src/types.ts
index 103362b21..d15e88de2 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4316,7 +4316,8 @@ type appendToTemplateLiteral<
   : never;
 
 export interface ZodTemplateLiteralDef extends ZodTypeDef {
-  parts: readonly (string | number | bigint | ZodType)[];
+  parts: readonly (TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart)[];
+  regexString: string;
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
 
@@ -4327,9 +4328,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   addPart<Z extends TemplateLiteralZodTypePart>(
     part: Z
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, Z>> {
+    const parts = [...this._def.parts, part];
+
     return new ZodTemplateLiteral({
       ...this._def,
-      parts: [...this._def.parts, part],
+      parts,
+      regexString: this._buildRegexString(parts),
     });
   }
 
@@ -4346,15 +4350,114 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return INVALID;
     }
 
-    // TODO: validate!!!
+    if (!new RegExp(this._def.regexString).test(input.data)) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_string,
+        message: `does not match template literal with pattern /${this._def.regexString}/`,
+        path: ctx.path,
+        validation: "regex",
+      });
+      return INVALID;
+    }
+
+    return { status: "valid", value: input.data };
+  }
+
+  protected _buildRegexString(
+    parts: readonly (
+      | TemplateLiteralPrimitivePart
+      | TemplateLiteralZodTypePart
+    )[]
+  ): string {
+    return (
+      parts.reduce<string>((acc, part) => {
+        if (typeof part !== "object") {
+          return `${acc}${this._escapeForRegex(part)}`;
+        }
+
+        if (part instanceof ZodLiteral) {
+          return `${acc}${this._escapeForRegex(part._def.value)}`;
+        }
+
+        if (part instanceof ZodString) {
+          // FIXME: should we care for string's validations? e.g. regex, uuid, etc.
+          return `${acc}.{${part.minLength || 0},${part.maxLength ?? ""}}`;
+        }
+
+        if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
+          const values =
+            part instanceof ZodEnum
+              ? part._def.values
+              : util.getValidEnumValues(part._def.values);
+
+          return `${acc}(${values.map(this._escapeForRegex).join("|")})`;
+        }
+
+        if (part instanceof ZodNumber) {
+          const max = part.maxValue || Infinity;
+          const min = part.minValue || -Infinity;
+          const isFinite = part.isFinite;
+
+          if (min < 0 || max < 0) {
+            acc = `${acc}\\-`;
+
+            if (max >= 0) {
+              acc = `${acc}?`;
+            }
+          }
+
+          if (!isFinite) {
+            acc = `${acc}(Infinity|(`;
+          }
+
+          acc = `${acc}\\d+`;
+
+          if (!part.isInt) {
+            acc = `${acc}(\\.\\d+)?`;
+          }
+
+          return !isFinite ? `${acc}))` : acc;
+        }
+
+        if (part instanceof ZodBigInt) {
+          // FIXME: include/exclude '-' based on min/max values after https://github.com/colinhacks/zod/pull/1711 is merged.
+          return `${acc}\\-?\\d+`;
+        }
+
+        if (part instanceof ZodBoolean) {
+          return `${acc}(true|false)`;
+        }
 
-    throw new Error("unimplemented!");
+        if (part instanceof ZodNull) {
+          return `${acc}null`;
+        }
+
+        if (part instanceof ZodUndefined) {
+          return `${acc}undefined`;
+        }
+
+        return acc;
+      }, "^") + "$"
+    );
+  }
+
+  protected _escapeForRegex(str: unknown): string {
+    if (typeof str !== "string") {
+      return `${str}`;
+    }
+
+    return str.replace(
+      /(\(|\)|\[|\]|\{|\}|\.|\\|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/,
+      "\\$1"
+    );
   }
 
   static create = (params?: RawCreateParams): ZodTemplateLiteral => {
     return new ZodTemplateLiteral({
       ...processCreateParams(params),
       parts: [],
+      regexString: "^$",
       typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral,
     });
   };

From d87d81969e9bfa56044b5120a711a92cfeab46a7 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 31 Dec 2022 16:50:53 +0200
Subject: [PATCH 03/40] add `ZodTemplateLiteral` @ firstparty.test.

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

diff --git a/deno/lib/__tests__/firstparty.test.ts b/deno/lib/__tests__/firstparty.test.ts
index 4e49d1397..1225e9efb 100644
--- a/deno/lib/__tests__/firstparty.test.ts
+++ b/deno/lib/__tests__/firstparty.test.ts
@@ -77,6 +77,8 @@ test("first party switch", () => {
       break;
     case z.ZodFirstPartyTypeKind.ZodPipeline:
       break;
+    case z.ZodFirstPartyTypeKind.ZodTemplateLiteral:
+      break;
     default:
       util.assertNever(def);
   }
diff --git a/src/__tests__/firstparty.test.ts b/src/__tests__/firstparty.test.ts
index b8b51dec3..a5e826fd6 100644
--- a/src/__tests__/firstparty.test.ts
+++ b/src/__tests__/firstparty.test.ts
@@ -76,6 +76,8 @@ test("first party switch", () => {
       break;
     case z.ZodFirstPartyTypeKind.ZodPipeline:
       break;
+    case z.ZodFirstPartyTypeKind.ZodTemplateLiteral:
+      break;
     default:
       util.assertNever(def);
   }

From a04487dc4813e1b6794eba24413e9590441d363d Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Mon, 2 Jan 2023 01:20:39 +0200
Subject: [PATCH 04/40] some inference test cases for `ZodTemplateLiteral`.

---
 deno/lib/__tests__/template-literal.test.ts | 52 +++++++++++++++++++++
 deno/lib/types.ts                           |  2 +
 src/__tests__/template-literal.test.ts      | 51 ++++++++++++++++++++
 src/types.ts                                |  2 +
 4 files changed, 107 insertions(+)
 create mode 100644 deno/lib/__tests__/template-literal.test.ts
 create mode 100644 src/__tests__/template-literal.test.ts

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
new file mode 100644
index 000000000..8c975e0dd
--- /dev/null
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -0,0 +1,52 @@
+// @ts-ignore TS6133
+import { expect } from "https://deno.land/x/expect@v0.2.6/mod.ts";
+const test = Deno.test;
+
+import { util } from "../helpers/util.ts";
+import * as z from "../index.ts";
+
+const url = z
+  .templateLiteral()
+  .addPart(z.literal("https://"))
+  .addPart(z.string())
+  .addPart(z.literal("."))
+  .addPart(z.enum(["com", "net"]));
+
+const connectionString = z
+  .templateLiteral()
+  .addPart(z.literal("mongodb://"))
+  .addPart(z.string().min(1))
+  .addPart(z.literal(":"))
+  .addPart(z.string().min(1))
+  .addPart(z.literal("@"))
+  .addPart(z.string().min(1))
+  .addPart(z.literal(":"))
+  .addPart(z.number().int().positive())
+  .addPart(
+    z
+      .templateLiteral()
+      .addPart(z.literal("/"))
+      .addPart(z.string())
+      .addPart(
+        z
+          .templateLiteral()
+          .addPart(z.literal("?"))
+          .addPart(z.string().min(1))
+          .optional()
+      )
+      .optional()
+  );
+
+test("type inference", () => {
+  util.assertEqual<
+    z.infer<typeof url>,
+    `https://${string}.com` | `https://${string}.net`
+  >(true);
+
+  util.assertEqual<
+    z.infer<typeof connectionString>,
+    | `mongodb://${string}:${string}@${string}:${number}`
+    | `mongodb://${string}:${string}@${string}:${number}/${string}`
+    | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
+  >(true);
+});
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 2ddcae4c6..c207b41b1 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4309,6 +4309,8 @@ type appendToTemplateLiteral<
   Suffix extends TemplateLiteralPrimitivePart | ZodType
 > = Suffix extends TemplateLiteralPrimitivePart
   ? `${Template}${Suffix}`
+  : Suffix extends ZodOptional<infer UnderlyingType>
+  ? Template | appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
   ? Output extends TemplateLiteralPrimitivePart
     ? `${Template}${Output}`
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
new file mode 100644
index 000000000..5e8f085a0
--- /dev/null
+++ b/src/__tests__/template-literal.test.ts
@@ -0,0 +1,51 @@
+// @ts-ignore TS6133
+import { expect, test } from "@jest/globals";
+
+import { util } from "../helpers/util";
+import * as z from "../index";
+
+const url = z
+  .templateLiteral()
+  .addPart(z.literal("https://"))
+  .addPart(z.string())
+  .addPart(z.literal("."))
+  .addPart(z.enum(["com", "net"]));
+
+const connectionString = z
+  .templateLiteral()
+  .addPart(z.literal("mongodb://"))
+  .addPart(z.string().min(1))
+  .addPart(z.literal(":"))
+  .addPart(z.string().min(1))
+  .addPart(z.literal("@"))
+  .addPart(z.string().min(1))
+  .addPart(z.literal(":"))
+  .addPart(z.number().int().positive())
+  .addPart(
+    z
+      .templateLiteral()
+      .addPart(z.literal("/"))
+      .addPart(z.string())
+      .addPart(
+        z
+          .templateLiteral()
+          .addPart(z.literal("?"))
+          .addPart(z.string().min(1))
+          .optional()
+      )
+      .optional()
+  );
+
+test("type inference", () => {
+  util.assertEqual<
+    z.infer<typeof url>,
+    `https://${string}.com` | `https://${string}.net`
+  >(true);
+
+  util.assertEqual<
+    z.infer<typeof connectionString>,
+    | `mongodb://${string}:${string}@${string}:${number}`
+    | `mongodb://${string}:${string}@${string}:${number}/${string}`
+    | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
+  >(true);
+});
diff --git a/src/types.ts b/src/types.ts
index d15e88de2..4907384ad 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4309,6 +4309,8 @@ type appendToTemplateLiteral<
   Suffix extends TemplateLiteralPrimitivePart | ZodType
 > = Suffix extends TemplateLiteralPrimitivePart
   ? `${Template}${Suffix}`
+  : Suffix extends ZodOptional<infer UnderlyingType>
+  ? Template | appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
   ? Output extends TemplateLiteralPrimitivePart
     ? `${Template}${Output}`

From 9c0d1e816fd28e259658024893d1447a6f526eb5 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 4 Jan 2023 02:32:13 +0200
Subject: [PATCH 05/40] append to regexString instead of rebuild @
 `ZodTemplateLiteral.addPart`.

---
 deno/lib/README.md                          |   2 +-
 deno/lib/__tests__/template-literal.test.ts |  71 +++++++--
 deno/lib/types.ts                           | 157 ++++++++++++--------
 src/types.ts                                | 157 ++++++++++++--------
 4 files changed, 254 insertions(+), 133 deletions(-)

diff --git a/deno/lib/README.md b/deno/lib/README.md
index d0a97ea10..55a24a12f 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -785,7 +785,7 @@ FishEnum.enum;
 You can also retrieve the list of options as a tuple with the `.options` property:
 
 ```ts
-FishEnum.options; // ["Salmon", "Tuna", "Trout"]);
+FishEnum.options; // ["Salmon", "Tuna", "Trout"];
 ```
 
 ## Native enums
diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 8c975e0dd..696556225 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -8,36 +8,42 @@ import * as z from "../index.ts";
 const url = z
   .templateLiteral()
   .addPart(z.literal("https://"))
-  .addPart(z.string())
+  .addPart(z.string().min(1))
   .addPart(z.literal("."))
   .addPart(z.enum(["com", "net"]));
 
 const connectionString = z
   .templateLiteral()
   .addPart(z.literal("mongodb://"))
-  .addPart(z.string().min(1))
-  .addPart(z.literal(":"))
-  .addPart(z.string().min(1))
-  .addPart(z.literal("@"))
-  .addPart(z.string().min(1))
+  .addPart(
+    z
+      .templateLiteral()
+      .addPart(z.string().min(1).describe("username"))
+      .addPart(z.literal(":"))
+      .addPart(z.string().min(1).describe("password"))
+      .addPart(z.literal("@"))
+      .optional()
+  )
+  .addPart(z.string().min(1).describe("host"))
   .addPart(z.literal(":"))
-  .addPart(z.number().int().positive())
+  .addPart(z.number().int().positive().describe("port"))
   .addPart(
     z
       .templateLiteral()
       .addPart(z.literal("/"))
-      .addPart(z.string())
+      .addPart(z.string().min(1).optional().describe("defaultauthdb"))
       .addPart(
         z
           .templateLiteral()
           .addPart(z.literal("?"))
-          .addPart(z.string().min(1))
+          .addPart(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
+          .describe("options")
       )
       .optional()
   );
 
-test("type inference", () => {
+test("template literal type inference", () => {
   util.assertEqual<
     z.infer<typeof url>,
     `https://${string}.com` | `https://${string}.net`
@@ -45,8 +51,53 @@ test("type inference", () => {
 
   util.assertEqual<
     z.infer<typeof connectionString>,
+    | `mongodb://${string}:${number}`
+    | `mongodb://${string}:${number}/${string}`
+    | `mongodb://${string}:${number}/${string}?${string}`
     | `mongodb://${string}:${string}@${string}:${number}`
     | `mongodb://${string}:${string}@${string}:${number}/${string}`
     | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
   >(true);
 });
+
+test("template literal parsing", () => {
+  url.parse("https://example.com");
+  url.parse("https://speedtest.net");
+
+  // TODO: url throw checks.
+
+  connectionString.parse("mongodb://host:1234");
+  connectionString.parse("mongodb://host:1234/");
+  connectionString.parse("mongodb://host:1234/defaultauthdb");
+  connectionString.parse("mongodb://host:1234/defaultauthdb?authSource=admin");
+  connectionString.parse(
+    "mongodb://host:1234/defaultauthdb?authSource=admin&connectTimeoutMS=300000"
+  );
+  connectionString.parse("mongodb://host:1234/?authSource=admin");
+  connectionString.parse(
+    "mongodb://host:1234/?authSource=admin&connectTimeoutMS=300000"
+  );
+  connectionString.parse("mongodb://username:password@host:1234");
+  connectionString.parse("mongodb://username:password@host:1234/");
+  connectionString.parse("mongodb://username:password@host:1234/defaultauthdb");
+  connectionString.parse(
+    "mongodb://username:password@host:1234/defaultauthdb?authSource=admin"
+  );
+  connectionString.parse(
+    "mongodb://username:password@host:1234/defaultauthdb?authSource=admin&connectTimeoutMS=300000"
+  );
+  connectionString.parse(
+    "mongodb://username:password@host:1234/?authSource=admin"
+  );
+  connectionString.parse(
+    "mongodb://username:password@host:1234/?authSource=admin&connectTimeoutMS=300000"
+  );
+
+  expect(() => connectionString.parse("mongod://host:1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://:1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:d234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:")).toThrow();
+
+  // TODO: more connectionString throw checks.
+});
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index cee56093f..834a56746 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4339,7 +4339,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return new ZodTemplateLiteral({
       ...this._def,
       parts,
-      regexString: this._buildRegexString(parts),
+      regexString: this._appendToRegexString(this._def.regexString, part),
     });
   }
 
@@ -4370,91 +4370,126 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return { status: "valid", value: input.data };
   }
 
-  protected _buildRegexString(
-    parts: readonly (
-      | TemplateLiteralPrimitivePart
-      | TemplateLiteralZodTypePart
-    )[]
+  protected _appendToRegexString(
+    regexString: string,
+    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
   ): string {
-    return (
-      parts.reduce<string>((acc, part) => {
-        if (typeof part !== "object") {
-          return `${acc}${this._escapeForRegex(part)}`;
-        }
+    return `^${this._unwrapRegexString(
+      regexString
+    )}${this._transformPartToRegexString(part)}$`;
+  }
 
-        if (part instanceof ZodLiteral) {
-          return `${acc}${this._escapeForRegex(part._def.value)}`;
-        }
+  protected _transformPartToRegexString(
+    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
+  ): string {
+    if (typeof part !== "object") {
+      return this._escapeStringForRegex(part);
+    }
 
-        if (part instanceof ZodString) {
-          // FIXME: should we care for string's validations? e.g. regex, uuid, etc.
-          return `${acc}.{${part.minLength || 0},${part.maxLength ?? ""}}`;
-        }
+    if (part instanceof ZodLiteral) {
+      return this._escapeStringForRegex(part._def.value);
+    }
+
+    if (part instanceof ZodString) {
+      const regexCheck = part._def.checks.find(
+        (check) => check.kind === "regex"
+      );
+
+      if (regexCheck) {
+        return this._unwrapRegexString(
+          ((regexCheck as any).regex as RegExp).source
+        );
+      }
+
+      // FIXME: should we care for string's validations? e.g. uuid, etc.
+      return `.{${part.minLength || 0},${part.maxLength ?? ""}}`;
+    }
+
+    if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
+      const values =
+        part instanceof ZodEnum
+          ? part._def.values
+          : util.getValidEnumValues(part._def.values);
 
-        if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
-          const values =
-            part instanceof ZodEnum
-              ? part._def.values
-              : util.getValidEnumValues(part._def.values);
+      return `(${values.map(this._escapeStringForRegex).join("|")})`;
+    }
 
-          return `${acc}(${values.map(this._escapeForRegex).join("|")})`;
+    if (part instanceof ZodNumber) {
+      const max = part.maxValue || Infinity;
+      const min = part.minValue || -Infinity;
+      const isFinite = part.isFinite;
+      let acc = "";
+
+      if ((min < 0 && min > -Infinity) || max < 0) {
+        acc = `${acc}\\-`;
+
+        if (max >= 0) {
+          acc = `${acc}?`;
         }
+      }
 
-        if (part instanceof ZodNumber) {
-          const max = part.maxValue || Infinity;
-          const min = part.minValue || -Infinity;
-          const isFinite = part.isFinite;
+      if (!isFinite) {
+        acc = `${acc}(Infinity|(`;
+      }
 
-          if (min < 0 || max < 0) {
-            acc = `${acc}\\-`;
+      acc = `${acc}\\d+`;
 
-            if (max >= 0) {
-              acc = `${acc}?`;
-            }
-          }
+      if (!part.isInt) {
+        acc = `${acc}(\\.\\d+)?`;
+      }
 
-          if (!isFinite) {
-            acc = `${acc}(Infinity|(`;
-          }
+      return !isFinite ? `${acc}))` : acc;
+    }
 
-          acc = `${acc}\\d+`;
+    if (part instanceof ZodOptional) {
+      return `(${this._transformPartToRegexString(part.unwrap())})?`;
+    }
 
-          if (!part.isInt) {
-            acc = `${acc}(\\.\\d+)?`;
-          }
+    if (part instanceof ZodTemplateLiteral) {
+      return this._unwrapRegexString(part._def.regexString);
+    }
 
-          return !isFinite ? `${acc}))` : acc;
-        }
+    if (part instanceof ZodBigInt) {
+      // FIXME: include/exclude '-' based on min/max values after https://github.com/colinhacks/zod/pull/1711 is merged.
+      return "\\-?\\d+";
+    }
 
-        if (part instanceof ZodBigInt) {
-          // FIXME: include/exclude '-' based on min/max values after https://github.com/colinhacks/zod/pull/1711 is merged.
-          return `${acc}\\-?\\d+`;
-        }
+    if (part instanceof ZodBoolean) {
+      return "(true|false)";
+    }
 
-        if (part instanceof ZodBoolean) {
-          return `${acc}(true|false)`;
-        }
+    if (part instanceof ZodNullable) {
+      do {
+        part = part.unwrap();
+      } while (part instanceof ZodNullable);
 
-        if (part instanceof ZodNull) {
-          return `${acc}null`;
-        }
+      return `(${this._transformPartToRegexString(part)}|null)${
+        part instanceof ZodOptional ? "?" : ""
+      }`;
+    }
 
-        if (part instanceof ZodUndefined) {
-          return `${acc}undefined`;
-        }
+    if (part instanceof ZodNull) {
+      return "null";
+    }
 
-        return acc;
-      }, "^") + "$"
-    );
+    if (part instanceof ZodUndefined) {
+      return "undefined";
+    }
+
+    return "<<UNSUPPORTED_TEMPLATE_LITERAL_PART>>";
+  }
+
+  protected _unwrapRegexString(regexString: string): string {
+    return regexString.replace(/(^\^)|(\$$)/g, "");
   }
 
-  protected _escapeForRegex(str: unknown): string {
+  protected _escapeStringForRegex(str: unknown): string {
     if (typeof str !== "string") {
       return `${str}`;
     }
 
     return str.replace(
-      /(\(|\)|\[|\]|\{|\}|\.|\\|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/,
+      /(\(|\)|\[|\]|\{|\}|\.|\\|\/|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/g,
       "\\$1"
     );
   }
diff --git a/src/types.ts b/src/types.ts
index cfae2b8d4..2424f5e9d 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4339,7 +4339,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return new ZodTemplateLiteral({
       ...this._def,
       parts,
-      regexString: this._buildRegexString(parts),
+      regexString: this._appendToRegexString(this._def.regexString, part),
     });
   }
 
@@ -4370,91 +4370,126 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return { status: "valid", value: input.data };
   }
 
-  protected _buildRegexString(
-    parts: readonly (
-      | TemplateLiteralPrimitivePart
-      | TemplateLiteralZodTypePart
-    )[]
+  protected _appendToRegexString(
+    regexString: string,
+    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
   ): string {
-    return (
-      parts.reduce<string>((acc, part) => {
-        if (typeof part !== "object") {
-          return `${acc}${this._escapeForRegex(part)}`;
-        }
+    return `^${this._unwrapRegexString(
+      regexString
+    )}${this._transformPartToRegexString(part)}$`;
+  }
 
-        if (part instanceof ZodLiteral) {
-          return `${acc}${this._escapeForRegex(part._def.value)}`;
-        }
+  protected _transformPartToRegexString(
+    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
+  ): string {
+    if (typeof part !== "object") {
+      return this._escapeStringForRegex(part);
+    }
 
-        if (part instanceof ZodString) {
-          // FIXME: should we care for string's validations? e.g. regex, uuid, etc.
-          return `${acc}.{${part.minLength || 0},${part.maxLength ?? ""}}`;
-        }
+    if (part instanceof ZodLiteral) {
+      return this._escapeStringForRegex(part._def.value);
+    }
+
+    if (part instanceof ZodString) {
+      const regexCheck = part._def.checks.find(
+        (check) => check.kind === "regex"
+      );
+
+      if (regexCheck) {
+        return this._unwrapRegexString(
+          ((regexCheck as any).regex as RegExp).source
+        );
+      }
+
+      // FIXME: should we care for string's validations? e.g. uuid, etc.
+      return `.{${part.minLength || 0},${part.maxLength ?? ""}}`;
+    }
+
+    if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
+      const values =
+        part instanceof ZodEnum
+          ? part._def.values
+          : util.getValidEnumValues(part._def.values);
 
-        if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
-          const values =
-            part instanceof ZodEnum
-              ? part._def.values
-              : util.getValidEnumValues(part._def.values);
+      return `(${values.map(this._escapeStringForRegex).join("|")})`;
+    }
 
-          return `${acc}(${values.map(this._escapeForRegex).join("|")})`;
+    if (part instanceof ZodNumber) {
+      const max = part.maxValue || Infinity;
+      const min = part.minValue || -Infinity;
+      const isFinite = part.isFinite;
+      let acc = "";
+
+      if ((min < 0 && min > -Infinity) || max < 0) {
+        acc = `${acc}\\-`;
+
+        if (max >= 0) {
+          acc = `${acc}?`;
         }
+      }
 
-        if (part instanceof ZodNumber) {
-          const max = part.maxValue || Infinity;
-          const min = part.minValue || -Infinity;
-          const isFinite = part.isFinite;
+      if (!isFinite) {
+        acc = `${acc}(Infinity|(`;
+      }
 
-          if (min < 0 || max < 0) {
-            acc = `${acc}\\-`;
+      acc = `${acc}\\d+`;
 
-            if (max >= 0) {
-              acc = `${acc}?`;
-            }
-          }
+      if (!part.isInt) {
+        acc = `${acc}(\\.\\d+)?`;
+      }
 
-          if (!isFinite) {
-            acc = `${acc}(Infinity|(`;
-          }
+      return !isFinite ? `${acc}))` : acc;
+    }
 
-          acc = `${acc}\\d+`;
+    if (part instanceof ZodOptional) {
+      return `(${this._transformPartToRegexString(part.unwrap())})?`;
+    }
 
-          if (!part.isInt) {
-            acc = `${acc}(\\.\\d+)?`;
-          }
+    if (part instanceof ZodTemplateLiteral) {
+      return this._unwrapRegexString(part._def.regexString);
+    }
 
-          return !isFinite ? `${acc}))` : acc;
-        }
+    if (part instanceof ZodBigInt) {
+      // FIXME: include/exclude '-' based on min/max values after https://github.com/colinhacks/zod/pull/1711 is merged.
+      return "\\-?\\d+";
+    }
 
-        if (part instanceof ZodBigInt) {
-          // FIXME: include/exclude '-' based on min/max values after https://github.com/colinhacks/zod/pull/1711 is merged.
-          return `${acc}\\-?\\d+`;
-        }
+    if (part instanceof ZodBoolean) {
+      return "(true|false)";
+    }
 
-        if (part instanceof ZodBoolean) {
-          return `${acc}(true|false)`;
-        }
+    if (part instanceof ZodNullable) {
+      do {
+        part = part.unwrap();
+      } while (part instanceof ZodNullable);
 
-        if (part instanceof ZodNull) {
-          return `${acc}null`;
-        }
+      return `(${this._transformPartToRegexString(part)}|null)${
+        part instanceof ZodOptional ? "?" : ""
+      }`;
+    }
 
-        if (part instanceof ZodUndefined) {
-          return `${acc}undefined`;
-        }
+    if (part instanceof ZodNull) {
+      return "null";
+    }
 
-        return acc;
-      }, "^") + "$"
-    );
+    if (part instanceof ZodUndefined) {
+      return "undefined";
+    }
+
+    return "<<UNSUPPORTED_TEMPLATE_LITERAL_PART>>";
+  }
+
+  protected _unwrapRegexString(regexString: string): string {
+    return regexString.replace(/(^\^)|(\$$)/g, "");
   }
 
-  protected _escapeForRegex(str: unknown): string {
+  protected _escapeStringForRegex(str: unknown): string {
     if (typeof str !== "string") {
       return `${str}`;
     }
 
     return str.replace(
-      /(\(|\)|\[|\]|\{|\}|\.|\\|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/,
+      /(\(|\)|\[|\]|\{|\}|\.|\\|\/|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/g,
       "\\$1"
     );
   }

From 40be49a7fafd23251a8bd68ed51917cdd8b07d9a Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 4 Jan 2023 02:32:58 +0200
Subject: [PATCH 06/40] initial parse tests for `ZodTemplateLiteral`.

---
 src/__tests__/template-literal.test.ts | 71 ++++++++++++++++++++++----
 1 file changed, 61 insertions(+), 10 deletions(-)

diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index 5e8f085a0..c799a3fc6 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -7,36 +7,42 @@ import * as z from "../index";
 const url = z
   .templateLiteral()
   .addPart(z.literal("https://"))
-  .addPart(z.string())
+  .addPart(z.string().min(1))
   .addPart(z.literal("."))
   .addPart(z.enum(["com", "net"]));
 
 const connectionString = z
   .templateLiteral()
   .addPart(z.literal("mongodb://"))
-  .addPart(z.string().min(1))
-  .addPart(z.literal(":"))
-  .addPart(z.string().min(1))
-  .addPart(z.literal("@"))
-  .addPart(z.string().min(1))
+  .addPart(
+    z
+      .templateLiteral()
+      .addPart(z.string().min(1).describe("username"))
+      .addPart(z.literal(":"))
+      .addPart(z.string().min(1).describe("password"))
+      .addPart(z.literal("@"))
+      .optional()
+  )
+  .addPart(z.string().min(1).describe("host"))
   .addPart(z.literal(":"))
-  .addPart(z.number().int().positive())
+  .addPart(z.number().int().positive().describe("port"))
   .addPart(
     z
       .templateLiteral()
       .addPart(z.literal("/"))
-      .addPart(z.string())
+      .addPart(z.string().min(1).optional().describe("defaultauthdb"))
       .addPart(
         z
           .templateLiteral()
           .addPart(z.literal("?"))
-          .addPart(z.string().min(1))
+          .addPart(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
+          .describe("options")
       )
       .optional()
   );
 
-test("type inference", () => {
+test("template literal type inference", () => {
   util.assertEqual<
     z.infer<typeof url>,
     `https://${string}.com` | `https://${string}.net`
@@ -44,8 +50,53 @@ test("type inference", () => {
 
   util.assertEqual<
     z.infer<typeof connectionString>,
+    | `mongodb://${string}:${number}`
+    | `mongodb://${string}:${number}/${string}`
+    | `mongodb://${string}:${number}/${string}?${string}`
     | `mongodb://${string}:${string}@${string}:${number}`
     | `mongodb://${string}:${string}@${string}:${number}/${string}`
     | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
   >(true);
 });
+
+test("template literal parsing", () => {
+  url.parse("https://example.com");
+  url.parse("https://speedtest.net");
+
+  // TODO: url throw checks.
+
+  connectionString.parse("mongodb://host:1234");
+  connectionString.parse("mongodb://host:1234/");
+  connectionString.parse("mongodb://host:1234/defaultauthdb");
+  connectionString.parse("mongodb://host:1234/defaultauthdb?authSource=admin");
+  connectionString.parse(
+    "mongodb://host:1234/defaultauthdb?authSource=admin&connectTimeoutMS=300000"
+  );
+  connectionString.parse("mongodb://host:1234/?authSource=admin");
+  connectionString.parse(
+    "mongodb://host:1234/?authSource=admin&connectTimeoutMS=300000"
+  );
+  connectionString.parse("mongodb://username:password@host:1234");
+  connectionString.parse("mongodb://username:password@host:1234/");
+  connectionString.parse("mongodb://username:password@host:1234/defaultauthdb");
+  connectionString.parse(
+    "mongodb://username:password@host:1234/defaultauthdb?authSource=admin"
+  );
+  connectionString.parse(
+    "mongodb://username:password@host:1234/defaultauthdb?authSource=admin&connectTimeoutMS=300000"
+  );
+  connectionString.parse(
+    "mongodb://username:password@host:1234/?authSource=admin"
+  );
+  connectionString.parse(
+    "mongodb://username:password@host:1234/?authSource=admin&connectTimeoutMS=300000"
+  );
+
+  expect(() => connectionString.parse("mongod://host:1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://:1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:d234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:")).toThrow();
+
+  // TODO: more connectionString throw checks.
+});

From 6a0248c8ee71958438e7463cb18735d3d9965118 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 6 Jan 2023 22:50:10 +0200
Subject: [PATCH 07/40] "internalize" `addPart`, add `addLiteral` &
 `addInterpolatedPosition`.

---
 deno/lib/__tests__/template-literal.test.ts | 67 ++++++++++++++-------
 deno/lib/types.ts                           | 49 +++++++++------
 src/__tests__/template-literal.test.ts      | 67 ++++++++++++++-------
 src/types.ts                                | 49 +++++++++------
 4 files changed, 154 insertions(+), 78 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 696556225..97687765a 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -7,36 +7,38 @@ import * as z from "../index.ts";
 
 const url = z
   .templateLiteral()
-  .addPart(z.literal("https://"))
-  .addPart(z.string().min(1))
-  .addPart(z.literal("."))
-  .addPart(z.enum(["com", "net"]));
+  .addLiteral("https://")
+  .addInterpolatedPosition(z.string().min(1))
+  .addLiteral(".")
+  .addInterpolatedPosition(z.enum(["com", "net"]));
 
 const connectionString = z
   .templateLiteral()
-  .addPart(z.literal("mongodb://"))
-  .addPart(
+  .addLiteral("mongodb://")
+  .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addPart(z.string().min(1).describe("username"))
-      .addPart(z.literal(":"))
-      .addPart(z.string().min(1).describe("password"))
-      .addPart(z.literal("@"))
+      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addLiteral(":")
+      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addLiteral("@")
       .optional()
   )
-  .addPart(z.string().min(1).describe("host"))
-  .addPart(z.literal(":"))
-  .addPart(z.number().int().positive().describe("port"))
-  .addPart(
+  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addLiteral(":")
+  .addInterpolatedPosition(z.number().int().positive().describe("port"))
+  .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addPart(z.literal("/"))
-      .addPart(z.string().min(1).optional().describe("defaultauthdb"))
-      .addPart(
+      .addLiteral("/")
+      .addInterpolatedPosition(
+        z.string().min(1).optional().describe("defaultauthdb")
+      )
+      .addInterpolatedPosition(
         z
           .templateLiteral()
-          .addPart(z.literal("?"))
-          .addPart(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .addLiteral("?")
+          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
           .describe("options")
       )
@@ -64,7 +66,11 @@ test("template literal parsing", () => {
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
-  // TODO: url throw checks.
+  expect(() => url.parse("http://example.com")).toThrow();
+  expect(() => url.parse("https://.com")).toThrow();
+  expect(() => url.parse("https://examplecom")).toThrow();
+  expect(() => url.parse("https://example.org")).toThrow();
+  expect(() => url.parse("https://example.net.il")).toThrow();
 
   connectionString.parse("mongodb://host:1234");
   connectionString.parse("mongodb://host:1234/");
@@ -97,7 +103,24 @@ test("template literal parsing", () => {
   expect(() => connectionString.parse("mongodb://:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host:d234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:12.34")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:-1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:-12.34")).toThrow();
   expect(() => connectionString.parse("mongodb://host:")).toThrow();
-
-  // TODO: more connectionString throw checks.
+  expect(() => connectionString.parse("mongodb://:password@host:1234"));
+  expect(() => connectionString.parse("mongodb://usernamepassword@host:1234"));
+  expect(() => connectionString.parse("mongodb://username:@host:1234"));
+  expect(() => connectionString.parse("mongodb://@host:1234"));
+  expect(() =>
+    connectionString.parse("mongodb://host:1234/defaultauthdb?authSourceadmin")
+  );
+  expect(() => connectionString.parse("mongodb://host:1234/?authSourceadmin"));
+  expect(() =>
+    connectionString.parse(
+      "mongodb://host:1234/defaultauthdb?&authSource=admin"
+    )
+  );
+  expect(() =>
+    connectionString.parse("mongodb://host:1234/?&authSource=admin")
+  );
 });
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 834a56746..0731d225e 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4298,7 +4298,7 @@ export class ZodPipeline<
 //////////////////////////////////////////
 //////////////////////////////////////////
 
-type TemplateLiteralPrimitivePart =
+type TemplateLiteralPrimitive =
   | string
   | number
   | bigint
@@ -4306,23 +4306,26 @@ type TemplateLiteralPrimitivePart =
   | null
   | undefined;
 
-type TemplateLiteralZodTypePart = ZodType<TemplateLiteralPrimitivePart>;
+type TemplateLiteralInterpolatedPosition = ZodType<TemplateLiteralPrimitive>;
 
 type appendToTemplateLiteral<
   Template extends string,
-  Suffix extends TemplateLiteralPrimitivePart | ZodType
-> = Suffix extends TemplateLiteralPrimitivePart
+  Suffix extends TemplateLiteralPrimitive | ZodType
+> = Suffix extends TemplateLiteralPrimitive
   ? `${Template}${Suffix}`
   : Suffix extends ZodOptional<infer UnderlyingType>
   ? Template | appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
-  ? Output extends TemplateLiteralPrimitivePart
+  ? Output extends TemplateLiteralPrimitive
     ? `${Template}${Output}`
     : never
   : never;
 
 export interface ZodTemplateLiteralDef extends ZodTypeDef {
-  parts: readonly (TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart)[];
+  parts: readonly (
+    | TemplateLiteralPrimitive
+    | TemplateLiteralInterpolatedPosition
+  )[];
   regexString: string;
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
@@ -4331,16 +4334,16 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef
 > {
-  addPart<Z extends TemplateLiteralZodTypePart>(
-    part: Z
-  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, Z>> {
-    const parts = [...this._def.parts, part];
+  addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
+    type: I
+  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
+    return this._addPart(type) as any;
+  }
 
-    return new ZodTemplateLiteral({
-      ...this._def,
-      parts,
-      regexString: this._appendToRegexString(this._def.regexString, part),
-    });
+  addLiteral<L extends TemplateLiteralPrimitive>(
+    literal: L
+  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, L>> {
+    return this._addPart(literal) as any;
   }
 
   _parse(input: ParseInput): ParseReturnType<Template> {
@@ -4370,9 +4373,21 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return { status: "valid", value: input.data };
   }
 
+  protected _addPart(
+    part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
+  ): ZodTemplateLiteral {
+    const parts = [...this._def.parts, part];
+
+    return new ZodTemplateLiteral({
+      ...this._def,
+      parts,
+      regexString: this._appendToRegexString(this._def.regexString, part),
+    });
+  }
+
   protected _appendToRegexString(
     regexString: string,
-    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
+    part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
     return `^${this._unwrapRegexString(
       regexString
@@ -4380,7 +4395,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   }
 
   protected _transformPartToRegexString(
-    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
+    part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
     if (typeof part !== "object") {
       return this._escapeStringForRegex(part);
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index c799a3fc6..a1b074713 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -6,36 +6,38 @@ import * as z from "../index";
 
 const url = z
   .templateLiteral()
-  .addPart(z.literal("https://"))
-  .addPart(z.string().min(1))
-  .addPart(z.literal("."))
-  .addPart(z.enum(["com", "net"]));
+  .addLiteral("https://")
+  .addInterpolatedPosition(z.string().min(1))
+  .addLiteral(".")
+  .addInterpolatedPosition(z.enum(["com", "net"]));
 
 const connectionString = z
   .templateLiteral()
-  .addPart(z.literal("mongodb://"))
-  .addPart(
+  .addLiteral("mongodb://")
+  .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addPart(z.string().min(1).describe("username"))
-      .addPart(z.literal(":"))
-      .addPart(z.string().min(1).describe("password"))
-      .addPart(z.literal("@"))
+      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addLiteral(":")
+      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addLiteral("@")
       .optional()
   )
-  .addPart(z.string().min(1).describe("host"))
-  .addPart(z.literal(":"))
-  .addPart(z.number().int().positive().describe("port"))
-  .addPart(
+  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addLiteral(":")
+  .addInterpolatedPosition(z.number().int().positive().describe("port"))
+  .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addPart(z.literal("/"))
-      .addPart(z.string().min(1).optional().describe("defaultauthdb"))
-      .addPart(
+      .addLiteral("/")
+      .addInterpolatedPosition(
+        z.string().min(1).optional().describe("defaultauthdb")
+      )
+      .addInterpolatedPosition(
         z
           .templateLiteral()
-          .addPart(z.literal("?"))
-          .addPart(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .addLiteral("?")
+          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
           .describe("options")
       )
@@ -63,7 +65,11 @@ test("template literal parsing", () => {
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
-  // TODO: url throw checks.
+  expect(() => url.parse("http://example.com")).toThrow();
+  expect(() => url.parse("https://.com")).toThrow();
+  expect(() => url.parse("https://examplecom")).toThrow();
+  expect(() => url.parse("https://example.org")).toThrow();
+  expect(() => url.parse("https://example.net.il")).toThrow();
 
   connectionString.parse("mongodb://host:1234");
   connectionString.parse("mongodb://host:1234/");
@@ -96,7 +102,24 @@ test("template literal parsing", () => {
   expect(() => connectionString.parse("mongodb://:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host:d234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:12.34")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:-1234")).toThrow();
+  expect(() => connectionString.parse("mongodb://host:-12.34")).toThrow();
   expect(() => connectionString.parse("mongodb://host:")).toThrow();
-
-  // TODO: more connectionString throw checks.
+  expect(() => connectionString.parse("mongodb://:password@host:1234"));
+  expect(() => connectionString.parse("mongodb://usernamepassword@host:1234"));
+  expect(() => connectionString.parse("mongodb://username:@host:1234"));
+  expect(() => connectionString.parse("mongodb://@host:1234"));
+  expect(() =>
+    connectionString.parse("mongodb://host:1234/defaultauthdb?authSourceadmin")
+  );
+  expect(() => connectionString.parse("mongodb://host:1234/?authSourceadmin"));
+  expect(() =>
+    connectionString.parse(
+      "mongodb://host:1234/defaultauthdb?&authSource=admin"
+    )
+  );
+  expect(() =>
+    connectionString.parse("mongodb://host:1234/?&authSource=admin")
+  );
 });
diff --git a/src/types.ts b/src/types.ts
index 2424f5e9d..52d50ddca 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4298,7 +4298,7 @@ export class ZodPipeline<
 //////////////////////////////////////////
 //////////////////////////////////////////
 
-type TemplateLiteralPrimitivePart =
+type TemplateLiteralPrimitive =
   | string
   | number
   | bigint
@@ -4306,23 +4306,26 @@ type TemplateLiteralPrimitivePart =
   | null
   | undefined;
 
-type TemplateLiteralZodTypePart = ZodType<TemplateLiteralPrimitivePart>;
+type TemplateLiteralInterpolatedPosition = ZodType<TemplateLiteralPrimitive>;
 
 type appendToTemplateLiteral<
   Template extends string,
-  Suffix extends TemplateLiteralPrimitivePart | ZodType
-> = Suffix extends TemplateLiteralPrimitivePart
+  Suffix extends TemplateLiteralPrimitive | ZodType
+> = Suffix extends TemplateLiteralPrimitive
   ? `${Template}${Suffix}`
   : Suffix extends ZodOptional<infer UnderlyingType>
   ? Template | appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
-  ? Output extends TemplateLiteralPrimitivePart
+  ? Output extends TemplateLiteralPrimitive
     ? `${Template}${Output}`
     : never
   : never;
 
 export interface ZodTemplateLiteralDef extends ZodTypeDef {
-  parts: readonly (TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart)[];
+  parts: readonly (
+    | TemplateLiteralPrimitive
+    | TemplateLiteralInterpolatedPosition
+  )[];
   regexString: string;
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
@@ -4331,16 +4334,16 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef
 > {
-  addPart<Z extends TemplateLiteralZodTypePart>(
-    part: Z
-  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, Z>> {
-    const parts = [...this._def.parts, part];
+  addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
+    type: I
+  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
+    return this._addPart(type) as any;
+  }
 
-    return new ZodTemplateLiteral({
-      ...this._def,
-      parts,
-      regexString: this._appendToRegexString(this._def.regexString, part),
-    });
+  addLiteral<L extends TemplateLiteralPrimitive>(
+    literal: L
+  ): ZodTemplateLiteral<appendToTemplateLiteral<Template, L>> {
+    return this._addPart(literal) as any;
   }
 
   _parse(input: ParseInput): ParseReturnType<Template> {
@@ -4370,9 +4373,21 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return { status: "valid", value: input.data };
   }
 
+  protected _addPart(
+    part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
+  ): ZodTemplateLiteral {
+    const parts = [...this._def.parts, part];
+
+    return new ZodTemplateLiteral({
+      ...this._def,
+      parts,
+      regexString: this._appendToRegexString(this._def.regexString, part),
+    });
+  }
+
   protected _appendToRegexString(
     regexString: string,
-    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
+    part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
     return `^${this._unwrapRegexString(
       regexString
@@ -4380,7 +4395,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   }
 
   protected _transformPartToRegexString(
-    part: TemplateLiteralPrimitivePart | TemplateLiteralZodTypePart
+    part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
     if (typeof part !== "object") {
       return this._escapeStringForRegex(part);

From d12535270f8039a31567b53b13f495e8afa3bf87 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 7 Jan 2023 04:52:39 +0200
Subject: [PATCH 08/40] move `ZodTemplateLiteral` unit test cases and minor
 fixes.

---
 deno/lib/__tests__/template-literal.test.ts | 124 +++++++++++++++++++-
 deno/lib/types.ts                           |  32 ++---
 src/__tests__/template-literal.test.ts      | 124 +++++++++++++++++++-
 src/types.ts                                |  32 ++---
 4 files changed, 278 insertions(+), 34 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 97687765a..51fec39cb 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -5,6 +5,43 @@ const test = Deno.test;
 import { util } from "../helpers/util.ts";
 import * as z from "../index.ts";
 
+const empty = z.templateLiteral();
+const hello = z.templateLiteral().addLiteral("hello");
+const world = z.templateLiteral().addInterpolatedPosition(z.literal("world"));
+const one = z.templateLiteral().addLiteral(1);
+const two = z.templateLiteral().addInterpolatedPosition(z.literal(2));
+const truee = z.templateLiteral().addLiteral(true);
+const anotherTrue = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal(true));
+const falsee = z.templateLiteral().addLiteral(false);
+const anotherFalse = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal(false));
+const nulll = z.templateLiteral().addLiteral(null);
+const anotherNull = z.templateLiteral().addInterpolatedPosition(z.null());
+const undefinedd = z.templateLiteral().addLiteral(undefined);
+const anotherUndefined = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.undefined());
+const anyString = z.templateLiteral().addInterpolatedPosition(z.string());
+const anyNumber = z.templateLiteral().addInterpolatedPosition(z.number());
+const anyFiniteNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().finite());
+const anyInt = z.templateLiteral().addInterpolatedPosition(z.number().int());
+const anyNegativeNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().negative());
+const anyPositiveNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().positive());
+const bool = z.templateLiteral().addInterpolatedPosition(z.boolean());
+const bigone = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal(BigInt(1)));
+const anyBigint = z.templateLiteral().addInterpolatedPosition(z.bigint());
+
 const url = z
   .templateLiteral()
   .addLiteral("https://")
@@ -26,7 +63,9 @@ const connectionString = z
   )
   .addInterpolatedPosition(z.string().min(1).describe("host"))
   .addLiteral(":")
-  .addInterpolatedPosition(z.number().int().positive().describe("port"))
+  .addInterpolatedPosition(
+    z.number().finite().int().positive().describe("port")
+  )
   .addInterpolatedPosition(
     z
       .templateLiteral()
@@ -46,6 +85,29 @@ const connectionString = z
   );
 
 test("template literal type inference", () => {
+  util.assertEqual<z.infer<typeof empty>, ``>(true);
+  util.assertEqual<z.infer<typeof hello>, `hello`>(true);
+  util.assertEqual<z.infer<typeof world>, `world`>(true);
+  util.assertEqual<z.infer<typeof one>, `1`>(true);
+  util.assertEqual<z.infer<typeof two>, `2`>(true);
+  util.assertEqual<z.infer<typeof truee>, `true`>(true);
+  util.assertEqual<z.infer<typeof anotherTrue>, `true`>(true);
+  util.assertEqual<z.infer<typeof falsee>, `false`>(true);
+  util.assertEqual<z.infer<typeof anotherFalse>, `false`>(true);
+  util.assertEqual<z.infer<typeof nulll>, `null`>(true);
+  util.assertEqual<z.infer<typeof anotherNull>, `null`>(true);
+  util.assertEqual<z.infer<typeof undefinedd>, `undefined`>(true);
+  util.assertEqual<z.infer<typeof anotherUndefined>, `undefined`>(true);
+  util.assertEqual<z.infer<typeof anyString>, `${string}`>(true);
+  util.assertEqual<z.infer<typeof anyNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyFiniteNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyNegativeNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyPositiveNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
+  util.assertEqual<z.infer<typeof bigone>, `${bigint}`>(true);
+  util.assertEqual<z.infer<typeof anyBigint>, `${bigint}`>(true);
+
   util.assertEqual<
     z.infer<typeof url>,
     `https://${string}.com` | `https://${string}.net`
@@ -63,6 +125,66 @@ test("template literal type inference", () => {
 });
 
 test("template literal parsing", () => {
+  empty.parse("");
+  hello.parse("hello");
+  world.parse("world");
+  one.parse("1");
+  two.parse("2");
+  truee.parse("true");
+  anotherTrue.parse("true");
+  falsee.parse("false");
+  anotherFalse.parse("false");
+  nulll.parse("null");
+  anotherNull.parse("null");
+  undefinedd.parse("undefined");
+  anotherUndefined.parse("undefined");
+  anyString.parse("blahblahblah");
+  anyString.parse("");
+  anyNumber.parse("123");
+  anyNumber.parse("1.23");
+  anyNumber.parse("0");
+  anyNumber.parse("-1.23");
+  anyNumber.parse("-123");
+  anyNumber.parse("Infinity");
+  anyNumber.parse("-Infinity");
+  anyFiniteNumber.parse("123");
+  anyFiniteNumber.parse("1.23");
+  anyFiniteNumber.parse("0");
+  anyFiniteNumber.parse("-1.23");
+  anyFiniteNumber.parse("-123");
+  anyInt.parse("123");
+  anyInt.parse("-123");
+  anyNegativeNumber.parse("-123");
+  anyNegativeNumber.parse("-1.23");
+  anyNegativeNumber.parse("-Infinity");
+  anyPositiveNumber.parse("123");
+  anyPositiveNumber.parse("1.23");
+  anyPositiveNumber.parse("Infinity");
+
+  expect(() => empty.parse("a")).toThrow();
+  expect(() => hello.parse("world"));
+  expect(() => world.parse("hello"));
+  expect(() => one.parse("2"));
+  expect(() => two.parse("1"));
+  expect(() => truee.parse("false"));
+  expect(() => anotherTrue.parse("false"));
+  expect(() => falsee.parse("true"));
+  expect(() => anotherFalse.parse("true"));
+  expect(() => nulll.parse("123"));
+  expect(() => anotherNull.parse("123"));
+  expect(() => undefinedd.parse("123"));
+  expect(() => anotherUndefined.parse("123"));
+  expect(() => anyFiniteNumber.parse("Infinity"));
+  expect(() => anyFiniteNumber.parse("-Infinity"));
+  expect(() => anyInt.parse("1.23"));
+  expect(() => anyInt.parse("-1.23"));
+  expect(() => anyNegativeNumber.parse("0"));
+  expect(() => anyNegativeNumber.parse("1"));
+  expect(() => anyNegativeNumber.parse("Infinity"));
+  expect(() => anyPositiveNumber.parse("0"));
+  expect(() => anyPositiveNumber.parse("-1"));
+  expect(() => anyPositiveNumber.parse("-Infinity"));
+
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 0731d225e..95a4dd152 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4298,15 +4298,11 @@ export class ZodPipeline<
 //////////////////////////////////////////
 //////////////////////////////////////////
 
-type TemplateLiteralPrimitive =
-  | string
-  | number
-  | bigint
-  | boolean
-  | null
-  | undefined;
+type TemplateLiteralPrimitive = string | number | boolean | null | undefined;
 
-type TemplateLiteralInterpolatedPosition = ZodType<TemplateLiteralPrimitive>;
+type TemplateLiteralInterpolatedPosition = ZodType<
+  TemplateLiteralPrimitive | bigint
+>;
 
 type appendToTemplateLiteral<
   Template extends string,
@@ -4316,7 +4312,7 @@ type appendToTemplateLiteral<
   : Suffix extends ZodOptional<infer UnderlyingType>
   ? Template | appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
-  ? Output extends TemplateLiteralPrimitive
+  ? Output extends TemplateLiteralPrimitive | bigint
     ? `${Template}${Output}`
     : never
   : never;
@@ -4397,7 +4393,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   protected _transformPartToRegexString(
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
-    if (typeof part !== "object") {
+    if (typeof part !== "object" || part === null) {
       return this._escapeStringForRegex(part);
     }
 
@@ -4430,12 +4426,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     }
 
     if (part instanceof ZodNumber) {
-      const max = part.maxValue || Infinity;
-      const min = part.minValue || -Infinity;
+      const max = part.maxValue ?? Infinity;
+      const min = part.minValue ?? -Infinity;
       const isFinite = part.isFinite;
       let acc = "";
 
-      if ((min < 0 && min > -Infinity) || max < 0) {
+      if (min < 0) {
         acc = `${acc}\\-`;
 
         if (max >= 0) {
@@ -4453,7 +4449,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         acc = `${acc}(\\.\\d+)?`;
       }
 
-      return !isFinite ? `${acc}))` : acc;
+      if (!isFinite) {
+        acc = `${acc}))`;
+      }
+
+      return acc;
     }
 
     if (part instanceof ZodOptional) {
@@ -4500,10 +4500,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
 
   protected _escapeStringForRegex(str: unknown): string {
     if (typeof str !== "string") {
-      return `${str}`;
+      str = `${str}`;
     }
 
-    return str.replace(
+    return (str as string).replace(
       /(\(|\)|\[|\]|\{|\}|\.|\\|\/|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/g,
       "\\$1"
     );
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index a1b074713..295ae8b4c 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -4,6 +4,43 @@ import { expect, test } from "@jest/globals";
 import { util } from "../helpers/util";
 import * as z from "../index";
 
+const empty = z.templateLiteral();
+const hello = z.templateLiteral().addLiteral("hello");
+const world = z.templateLiteral().addInterpolatedPosition(z.literal("world"));
+const one = z.templateLiteral().addLiteral(1);
+const two = z.templateLiteral().addInterpolatedPosition(z.literal(2));
+const truee = z.templateLiteral().addLiteral(true);
+const anotherTrue = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal(true));
+const falsee = z.templateLiteral().addLiteral(false);
+const anotherFalse = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal(false));
+const nulll = z.templateLiteral().addLiteral(null);
+const anotherNull = z.templateLiteral().addInterpolatedPosition(z.null());
+const undefinedd = z.templateLiteral().addLiteral(undefined);
+const anotherUndefined = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.undefined());
+const anyString = z.templateLiteral().addInterpolatedPosition(z.string());
+const anyNumber = z.templateLiteral().addInterpolatedPosition(z.number());
+const anyFiniteNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().finite());
+const anyInt = z.templateLiteral().addInterpolatedPosition(z.number().int());
+const anyNegativeNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().negative());
+const anyPositiveNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().positive());
+const bool = z.templateLiteral().addInterpolatedPosition(z.boolean());
+const bigone = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal(BigInt(1)));
+const anyBigint = z.templateLiteral().addInterpolatedPosition(z.bigint());
+
 const url = z
   .templateLiteral()
   .addLiteral("https://")
@@ -25,7 +62,9 @@ const connectionString = z
   )
   .addInterpolatedPosition(z.string().min(1).describe("host"))
   .addLiteral(":")
-  .addInterpolatedPosition(z.number().int().positive().describe("port"))
+  .addInterpolatedPosition(
+    z.number().finite().int().positive().describe("port")
+  )
   .addInterpolatedPosition(
     z
       .templateLiteral()
@@ -45,6 +84,29 @@ const connectionString = z
   );
 
 test("template literal type inference", () => {
+  util.assertEqual<z.infer<typeof empty>, ``>(true);
+  util.assertEqual<z.infer<typeof hello>, `hello`>(true);
+  util.assertEqual<z.infer<typeof world>, `world`>(true);
+  util.assertEqual<z.infer<typeof one>, `1`>(true);
+  util.assertEqual<z.infer<typeof two>, `2`>(true);
+  util.assertEqual<z.infer<typeof truee>, `true`>(true);
+  util.assertEqual<z.infer<typeof anotherTrue>, `true`>(true);
+  util.assertEqual<z.infer<typeof falsee>, `false`>(true);
+  util.assertEqual<z.infer<typeof anotherFalse>, `false`>(true);
+  util.assertEqual<z.infer<typeof nulll>, `null`>(true);
+  util.assertEqual<z.infer<typeof anotherNull>, `null`>(true);
+  util.assertEqual<z.infer<typeof undefinedd>, `undefined`>(true);
+  util.assertEqual<z.infer<typeof anotherUndefined>, `undefined`>(true);
+  util.assertEqual<z.infer<typeof anyString>, `${string}`>(true);
+  util.assertEqual<z.infer<typeof anyNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyFiniteNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyNegativeNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof anyPositiveNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
+  util.assertEqual<z.infer<typeof bigone>, `${bigint}`>(true);
+  util.assertEqual<z.infer<typeof anyBigint>, `${bigint}`>(true);
+
   util.assertEqual<
     z.infer<typeof url>,
     `https://${string}.com` | `https://${string}.net`
@@ -62,6 +124,66 @@ test("template literal type inference", () => {
 });
 
 test("template literal parsing", () => {
+  empty.parse("");
+  hello.parse("hello");
+  world.parse("world");
+  one.parse("1");
+  two.parse("2");
+  truee.parse("true");
+  anotherTrue.parse("true");
+  falsee.parse("false");
+  anotherFalse.parse("false");
+  nulll.parse("null");
+  anotherNull.parse("null");
+  undefinedd.parse("undefined");
+  anotherUndefined.parse("undefined");
+  anyString.parse("blahblahblah");
+  anyString.parse("");
+  anyNumber.parse("123");
+  anyNumber.parse("1.23");
+  anyNumber.parse("0");
+  anyNumber.parse("-1.23");
+  anyNumber.parse("-123");
+  anyNumber.parse("Infinity");
+  anyNumber.parse("-Infinity");
+  anyFiniteNumber.parse("123");
+  anyFiniteNumber.parse("1.23");
+  anyFiniteNumber.parse("0");
+  anyFiniteNumber.parse("-1.23");
+  anyFiniteNumber.parse("-123");
+  anyInt.parse("123");
+  anyInt.parse("-123");
+  anyNegativeNumber.parse("-123");
+  anyNegativeNumber.parse("-1.23");
+  anyNegativeNumber.parse("-Infinity");
+  anyPositiveNumber.parse("123");
+  anyPositiveNumber.parse("1.23");
+  anyPositiveNumber.parse("Infinity");
+
+  expect(() => empty.parse("a")).toThrow();
+  expect(() => hello.parse("world"));
+  expect(() => world.parse("hello"));
+  expect(() => one.parse("2"));
+  expect(() => two.parse("1"));
+  expect(() => truee.parse("false"));
+  expect(() => anotherTrue.parse("false"));
+  expect(() => falsee.parse("true"));
+  expect(() => anotherFalse.parse("true"));
+  expect(() => nulll.parse("123"));
+  expect(() => anotherNull.parse("123"));
+  expect(() => undefinedd.parse("123"));
+  expect(() => anotherUndefined.parse("123"));
+  expect(() => anyFiniteNumber.parse("Infinity"));
+  expect(() => anyFiniteNumber.parse("-Infinity"));
+  expect(() => anyInt.parse("1.23"));
+  expect(() => anyInt.parse("-1.23"));
+  expect(() => anyNegativeNumber.parse("0"));
+  expect(() => anyNegativeNumber.parse("1"));
+  expect(() => anyNegativeNumber.parse("Infinity"));
+  expect(() => anyPositiveNumber.parse("0"));
+  expect(() => anyPositiveNumber.parse("-1"));
+  expect(() => anyPositiveNumber.parse("-Infinity"));
+
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
diff --git a/src/types.ts b/src/types.ts
index 52d50ddca..c0a20d899 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4298,15 +4298,11 @@ export class ZodPipeline<
 //////////////////////////////////////////
 //////////////////////////////////////////
 
-type TemplateLiteralPrimitive =
-  | string
-  | number
-  | bigint
-  | boolean
-  | null
-  | undefined;
+type TemplateLiteralPrimitive = string | number | boolean | null | undefined;
 
-type TemplateLiteralInterpolatedPosition = ZodType<TemplateLiteralPrimitive>;
+type TemplateLiteralInterpolatedPosition = ZodType<
+  TemplateLiteralPrimitive | bigint
+>;
 
 type appendToTemplateLiteral<
   Template extends string,
@@ -4316,7 +4312,7 @@ type appendToTemplateLiteral<
   : Suffix extends ZodOptional<infer UnderlyingType>
   ? Template | appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
-  ? Output extends TemplateLiteralPrimitive
+  ? Output extends TemplateLiteralPrimitive | bigint
     ? `${Template}${Output}`
     : never
   : never;
@@ -4397,7 +4393,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   protected _transformPartToRegexString(
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
-    if (typeof part !== "object") {
+    if (typeof part !== "object" || part === null) {
       return this._escapeStringForRegex(part);
     }
 
@@ -4430,12 +4426,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     }
 
     if (part instanceof ZodNumber) {
-      const max = part.maxValue || Infinity;
-      const min = part.minValue || -Infinity;
+      const max = part.maxValue ?? Infinity;
+      const min = part.minValue ?? -Infinity;
       const isFinite = part.isFinite;
       let acc = "";
 
-      if ((min < 0 && min > -Infinity) || max < 0) {
+      if (min < 0) {
         acc = `${acc}\\-`;
 
         if (max >= 0) {
@@ -4453,7 +4449,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         acc = `${acc}(\\.\\d+)?`;
       }
 
-      return !isFinite ? `${acc}))` : acc;
+      if (!isFinite) {
+        acc = `${acc}))`;
+      }
+
+      return acc;
     }
 
     if (part instanceof ZodOptional) {
@@ -4500,10 +4500,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
 
   protected _escapeStringForRegex(str: unknown): string {
     if (typeof str !== "string") {
-      return `${str}`;
+      str = `${str}`;
     }
 
-    return str.replace(
+    return (str as string).replace(
       /(\(|\)|\[|\]|\{|\}|\.|\\|\/|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/g,
       "\\$1"
     );

From ded7abcd8a24d5fc98a023dc3e1473099fd7c7eb Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sun, 8 Jan 2023 02:00:29 +0200
Subject: [PATCH 09/40] minor fixes, more tests.

---
 deno/lib/__tests__/template-literal.test.ts | 169 +++++++++++++---
 deno/lib/types.ts                           | 211 +++++++++++++++-----
 src/__tests__/template-literal.test.ts      | 169 +++++++++++++---
 src/types.ts                                | 211 +++++++++++++++-----
 4 files changed, 620 insertions(+), 140 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 51fec39cb..b107dd33d 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -41,6 +41,24 @@ const bigone = z
   .templateLiteral()
   .addInterpolatedPosition(z.literal(BigInt(1)));
 const anyBigint = z.templateLiteral().addInterpolatedPosition(z.bigint());
+const nullableYo = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.nullable(z.literal("yo")));
+const nullableString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.nullable(z.string()));
+const optionalYeah = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal("yeah").optional());
+const optionalString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().optional());
+const nullishBruh = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal("bruh").nullish());
+const nullishString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().nullish());
 
 const url = z
   .templateLiteral()
@@ -98,7 +116,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof anotherNull>, `null`>(true);
   util.assertEqual<z.infer<typeof undefinedd>, `undefined`>(true);
   util.assertEqual<z.infer<typeof anotherUndefined>, `undefined`>(true);
-  util.assertEqual<z.infer<typeof anyString>, `${string}`>(true);
+  util.assertEqual<z.infer<typeof anyString>, string>(true);
   util.assertEqual<z.infer<typeof anyNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyFiniteNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
@@ -107,6 +125,12 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
   util.assertEqual<z.infer<typeof bigone>, `${bigint}`>(true);
   util.assertEqual<z.infer<typeof anyBigint>, `${bigint}`>(true);
+  util.assertEqual<z.infer<typeof nullableYo>, `yo` | `null`>(true);
+  util.assertEqual<z.infer<typeof nullableString>, string>(true);
+  util.assertEqual<z.infer<typeof optionalYeah>, `yeah` | ``>(true);
+  util.assertEqual<z.infer<typeof optionalString>, string>(true);
+  util.assertEqual<z.infer<typeof nullishBruh>, `bruh` | `null` | ``>(true);
+  util.assertEqual<z.infer<typeof nullishString>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -124,7 +148,68 @@ test("template literal type inference", () => {
   >(true);
 });
 
+test("template literal unsupported args", () => {
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.object({}));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.array(z.object({})));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.union([z.object({}), z.string()])
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.any());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.never());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.date());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.custom<object>((data) => true));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.function());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.intersection(z.object({}), z.object({}))
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.preprocess(() => true, z.boolean())
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.promise());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.nan());
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.pipeline(z.string(), z.string())
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.set(z.string()));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.symbol());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.unknown());
+});
+
 test("template literal parsing", () => {
+  expect(() => z.templateLiteral().parse(7)).toThrow();
+
   empty.parse("");
   hello.parse("hello");
   world.parse("world");
@@ -160,30 +245,68 @@ test("template literal parsing", () => {
   anyPositiveNumber.parse("123");
   anyPositiveNumber.parse("1.23");
   anyPositiveNumber.parse("Infinity");
+  bool.parse("true");
+  bool.parse("false");
+  bigone.parse("1");
+  anyBigint.parse("123456");
+  anyBigint.parse("0");
+  anyBigint.parse("-123456");
 
   expect(() => empty.parse("a")).toThrow();
-  expect(() => hello.parse("world"));
-  expect(() => world.parse("hello"));
-  expect(() => one.parse("2"));
-  expect(() => two.parse("1"));
-  expect(() => truee.parse("false"));
-  expect(() => anotherTrue.parse("false"));
-  expect(() => falsee.parse("true"));
-  expect(() => anotherFalse.parse("true"));
-  expect(() => nulll.parse("123"));
-  expect(() => anotherNull.parse("123"));
-  expect(() => undefinedd.parse("123"));
-  expect(() => anotherUndefined.parse("123"));
-  expect(() => anyFiniteNumber.parse("Infinity"));
-  expect(() => anyFiniteNumber.parse("-Infinity"));
-  expect(() => anyInt.parse("1.23"));
-  expect(() => anyInt.parse("-1.23"));
-  expect(() => anyNegativeNumber.parse("0"));
-  expect(() => anyNegativeNumber.parse("1"));
-  expect(() => anyNegativeNumber.parse("Infinity"));
-  expect(() => anyPositiveNumber.parse("0"));
-  expect(() => anyPositiveNumber.parse("-1"));
-  expect(() => anyPositiveNumber.parse("-Infinity"));
+  expect(() => hello.parse("hello!")).toThrow();
+  expect(() => hello.parse("!hello")).toThrow();
+  expect(() => world.parse("world!")).toThrow();
+  expect(() => world.parse("!world")).toThrow();
+  expect(() => one.parse("2")).toThrow();
+  expect(() => one.parse("12")).toThrow();
+  expect(() => one.parse("21")).toThrow();
+  expect(() => two.parse("1")).toThrow();
+  expect(() => two.parse("21")).toThrow();
+  expect(() => two.parse("12")).toThrow();
+  expect(() => truee.parse("false")).toThrow();
+  expect(() => truee.parse("1true")).toThrow();
+  expect(() => truee.parse("true1")).toThrow();
+  expect(() => anotherTrue.parse("false")).toThrow();
+  expect(() => anotherTrue.parse("1true")).toThrow();
+  expect(() => anotherTrue.parse("true1")).toThrow();
+  expect(() => falsee.parse("true")).toThrow();
+  expect(() => falsee.parse("1false")).toThrow();
+  expect(() => falsee.parse("false1")).toThrow();
+  expect(() => anotherFalse.parse("true")).toThrow();
+  expect(() => anotherFalse.parse("1false")).toThrow();
+  expect(() => anotherFalse.parse("false1")).toThrow();
+  expect(() => nulll.parse("123")).toThrow();
+  expect(() => nulll.parse("null1")).toThrow();
+  expect(() => nulll.parse("1null")).toThrow();
+  expect(() => anotherNull.parse("123")).toThrow();
+  expect(() => anotherNull.parse("null1")).toThrow();
+  expect(() => anotherNull.parse("1null")).toThrow();
+  expect(() => undefinedd.parse("123")).toThrow();
+  expect(() => undefinedd.parse("undefined1")).toThrow();
+  expect(() => undefinedd.parse("1undefined")).toThrow();
+  expect(() => anotherUndefined.parse("123")).toThrow();
+  expect(() => anotherUndefined.parse("undefined1")).toThrow();
+  expect(() => anotherUndefined.parse("1undefined")).toThrow();
+  expect(() => anyFiniteNumber.parse("Infinity")).toThrow();
+  expect(() => anyFiniteNumber.parse("-Infinity")).toThrow();
+  expect(() => anyFiniteNumber.parse("123a")).toThrow();
+  expect(() => anyFiniteNumber.parse("a123")).toThrow();
+  expect(() => anyInt.parse("1.23")).toThrow();
+  expect(() => anyInt.parse("-1.23")).toThrow();
+  expect(() => anyInt.parse("d1")).toThrow();
+  expect(() => anyInt.parse("1d")).toThrow();
+  expect(() => anyNegativeNumber.parse("0")).toThrow();
+  expect(() => anyNegativeNumber.parse("1")).toThrow();
+  expect(() => anyNegativeNumber.parse("Infinity")).toThrow();
+  expect(() => anyPositiveNumber.parse("0")).toThrow();
+  expect(() => anyPositiveNumber.parse("-1")).toThrow();
+  expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
+  expect(() => bool.parse("123")).toThrow();
+  expect(() => bigone.parse("2")).toThrow();
+  expect(() => bigone.parse("c1")).toThrow();
+  expect(() => anyBigint.parse("1.23")).toThrow();
+  expect(() => anyBigint.parse("-1.23")).toThrow();
+  expect(() => anyBigint.parse("c123")).toThrow();
 
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 95a4dd152..ef952e988 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4331,7 +4331,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   ZodTemplateLiteralDef
 > {
   addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
-    type: I
+    type: Exclude<I, ZodNever | ZodAny | ZodNaN | ZodPipeline<any, any>>
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
     return this._addPart(type) as any;
   }
@@ -4393,27 +4393,16 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   protected _transformPartToRegexString(
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
-    if (typeof part !== "object" || part === null) {
-      return this._escapeStringForRegex(part);
+    if (!(part instanceof ZodType)) {
+      return this._getEscapedStringForRegex(part);
     }
 
     if (part instanceof ZodLiteral) {
-      return this._escapeStringForRegex(part._def.value);
+      return this._getEscapedStringForRegex(part._def.value);
     }
 
     if (part instanceof ZodString) {
-      const regexCheck = part._def.checks.find(
-        (check) => check.kind === "regex"
-      );
-
-      if (regexCheck) {
-        return this._unwrapRegexString(
-          ((regexCheck as any).regex as RegExp).source
-        );
-      }
-
-      // FIXME: should we care for string's validations? e.g. uuid, etc.
-      return `.{${part.minLength || 0},${part.maxLength ?? ""}}`;
+      return this._transformZodStringPartToRegexString(part);
     }
 
     if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
@@ -4422,38 +4411,17 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
           ? part._def.values
           : util.getValidEnumValues(part._def.values);
 
-      return `(${values.map(this._escapeStringForRegex).join("|")})`;
+      return `(${values.map(this._getEscapedStringForRegex).join("|")})`;
     }
 
-    if (part instanceof ZodNumber) {
-      const max = part.maxValue ?? Infinity;
-      const min = part.minValue ?? -Infinity;
-      const isFinite = part.isFinite;
-      let acc = "";
-
-      if (min < 0) {
-        acc = `${acc}\\-`;
-
-        if (max >= 0) {
-          acc = `${acc}?`;
-        }
-      }
-
-      if (!isFinite) {
-        acc = `${acc}(Infinity|(`;
-      }
-
-      acc = `${acc}\\d+`;
-
-      if (!part.isInt) {
-        acc = `${acc}(\\.\\d+)?`;
-      }
-
-      if (!isFinite) {
-        acc = `${acc}))`;
-      }
+    if (part instanceof ZodUnion) {
+      return `(${(part._def.options as any[])
+        .map((option) => this._transformPartToRegexString(option))
+        .join("|")})`;
+    }
 
-      return acc;
+    if (part instanceof ZodNumber) {
+      return this._transformZodNumberPartToRegexString(part);
     }
 
     if (part instanceof ZodOptional) {
@@ -4491,14 +4459,163 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return "undefined";
     }
 
-    return "<<UNSUPPORTED_TEMPLATE_LITERAL_PART>>";
+    throw new Error(
+      "Zod error: Unsupported ZodTemplateLiteral argument! Please submit an issue at https://github.com/colinhacks/zod/issues"
+    );
+  }
+
+  protected _transformZodStringPartToRegexString(part: ZodString): string {
+    let maxLength = Infinity,
+      minLength = 0,
+      endsWith = "",
+      startsWith = "";
+
+    for (const ch of part._def.checks) {
+      if (ch.kind === "cuid") {
+        return this._unwrapRegexString(cuidRegex.source);
+      }
+
+      if (ch.kind === "datetime") {
+        return this._unwrapRegexString(datetimeRegex(ch).source);
+      }
+
+      if (ch.kind === "email") {
+        return this._unwrapRegexString(emailRegex.source);
+      }
+
+      if (ch.kind === "regex") {
+        return this._unwrapRegexString(ch.regex.source);
+      }
+
+      if (ch.kind === "url") {
+        // FIXME: we use native URL for validation, so cannot regex test in such cases.
+        throw new Error(
+          "Zod error: ZodTemplateLiteral does not support use of ZodString with url check!"
+        );
+      }
+
+      if (ch.kind === "uuid") {
+        return this._unwrapRegexString(uuidRegex.source);
+      }
+
+      if (ch.kind === "endsWith") {
+        endsWith = ch.value;
+      } else if (ch.kind === "length") {
+        minLength = maxLength = ch.value;
+      } else if (ch.kind === "max") {
+        maxLength = Math.max(0, Math.min(maxLength, ch.value));
+      } else if (ch.kind === "min") {
+        minLength = Math.max(minLength, ch.value);
+      } else if (ch.kind === "startsWith") {
+        startsWith = ch.value;
+      }
+    }
+
+    const constrainedMinLength = Math.max(
+      0,
+      minLength - startsWith.length - endsWith.length
+    );
+    const constrainedMaxLength = Number.isFinite(maxLength)
+      ? Math.max(0, maxLength - startsWith.length - endsWith.length)
+      : Infinity;
+
+    if (
+      constrainedMinLength > constrainedMaxLength ||
+      constrainedMaxLength === 0
+    ) {
+      return `${startsWith}${endsWith}`;
+    }
+
+    const wildcardLength =
+      constrainedMinLength === constrainedMaxLength
+        ? constrainedMinLength === 1
+          ? ""
+          : `{${constrainedMinLength}}`
+        : !Number.isFinite(constrainedMaxLength)
+        ? constrainedMinLength === 0
+          ? "*"
+          : constrainedMinLength === 1
+          ? "+"
+          : `{${constrainedMinLength},}`
+        : `{${constrainedMinLength},${constrainedMinLength}}`;
+
+    return `${startsWith}.${wildcardLength}${endsWith}`;
+  }
+
+  protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
+    let isNegative = true,
+      isPositive = true,
+      isZero = true,
+      isFinite = false,
+      isInt = false,
+      acc = "";
+
+    for (const ch of part._def.checks) {
+      if (ch.kind === "finite") {
+        isFinite = true;
+      } else if (ch.kind === "int") {
+        isInt = true;
+      } else if (ch.kind === "max") {
+        if (ch.value < 0 || (ch.value === 0 && !ch.inclusive)) {
+          isPositive = false;
+
+          if (ch.value === 0) {
+            isZero = false;
+          }
+        }
+      } else if (ch.kind === "min") {
+        if (ch.value > 0 || (ch.value === 0 && !ch.inclusive)) {
+          isNegative = false;
+
+          if (ch.value === 0) {
+            isZero = false;
+          }
+        }
+      } else if (ch.kind === "multipleOf") {
+        if (util.isInteger(ch.value)) {
+          isInt = true;
+        }
+      }
+    }
+
+    if (isNegative) {
+      acc = `${acc}\\-`;
+
+      if (isPositive) {
+        acc = `${acc}?`;
+      }
+    } else if (!isPositive) {
+      return "0+";
+    }
+
+    if (!isFinite) {
+      acc = `${acc}(Infinity|(`;
+    }
+
+    if (!isZero) {
+      if (!isInt) {
+        acc = `${acc}((\\d*[1-9]\\d*(\\.\\d+)?)|(\\d+\\.\\d*[1-9]\\d*))`;
+      } else {
+        acc = `${acc}\\d*[1-9]\\d*`;
+      }
+    } else if (isInt) {
+      acc = `${acc}\\d+`;
+    } else {
+      acc = `${acc}\\d+(\\.\\d+)?`;
+    }
+
+    if (!isFinite) {
+      acc = `${acc}))`;
+    }
+
+    return acc;
   }
 
   protected _unwrapRegexString(regexString: string): string {
     return regexString.replace(/(^\^)|(\$$)/g, "");
   }
 
-  protected _escapeStringForRegex(str: unknown): string {
+  protected _getEscapedStringForRegex(str: unknown): string {
     if (typeof str !== "string") {
       str = `${str}`;
     }
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index 295ae8b4c..ac539f0e5 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -40,6 +40,24 @@ const bigone = z
   .templateLiteral()
   .addInterpolatedPosition(z.literal(BigInt(1)));
 const anyBigint = z.templateLiteral().addInterpolatedPosition(z.bigint());
+const nullableYo = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.nullable(z.literal("yo")));
+const nullableString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.nullable(z.string()));
+const optionalYeah = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal("yeah").optional());
+const optionalString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().optional());
+const nullishBruh = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.literal("bruh").nullish());
+const nullishString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().nullish());
 
 const url = z
   .templateLiteral()
@@ -97,7 +115,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof anotherNull>, `null`>(true);
   util.assertEqual<z.infer<typeof undefinedd>, `undefined`>(true);
   util.assertEqual<z.infer<typeof anotherUndefined>, `undefined`>(true);
-  util.assertEqual<z.infer<typeof anyString>, `${string}`>(true);
+  util.assertEqual<z.infer<typeof anyString>, string>(true);
   util.assertEqual<z.infer<typeof anyNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyFiniteNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
@@ -106,6 +124,12 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
   util.assertEqual<z.infer<typeof bigone>, `${bigint}`>(true);
   util.assertEqual<z.infer<typeof anyBigint>, `${bigint}`>(true);
+  util.assertEqual<z.infer<typeof nullableYo>, `yo` | `null`>(true);
+  util.assertEqual<z.infer<typeof nullableString>, string>(true);
+  util.assertEqual<z.infer<typeof optionalYeah>, `yeah` | ``>(true);
+  util.assertEqual<z.infer<typeof optionalString>, string>(true);
+  util.assertEqual<z.infer<typeof nullishBruh>, `bruh` | `null` | ``>(true);
+  util.assertEqual<z.infer<typeof nullishString>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -123,7 +147,68 @@ test("template literal type inference", () => {
   >(true);
 });
 
+test("template literal unsupported args", () => {
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.object({}));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.array(z.object({})));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.union([z.object({}), z.string()])
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.any());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.never());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.date());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.custom<object>((data) => true));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.function());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.intersection(z.object({}), z.object({}))
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})));
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.preprocess(() => true, z.boolean())
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.promise());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.nan());
+  z.templateLiteral().addInterpolatedPosition(
+    // @ts-expect-error
+    z.pipeline(z.string(), z.string())
+  );
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.set(z.string()));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.symbol());
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]));
+  // @ts-expect-error
+  z.templateLiteral().addInterpolatedPosition(z.unknown());
+});
+
 test("template literal parsing", () => {
+  expect(() => z.templateLiteral().parse(7)).toThrow();
+
   empty.parse("");
   hello.parse("hello");
   world.parse("world");
@@ -159,30 +244,68 @@ test("template literal parsing", () => {
   anyPositiveNumber.parse("123");
   anyPositiveNumber.parse("1.23");
   anyPositiveNumber.parse("Infinity");
+  bool.parse("true");
+  bool.parse("false");
+  bigone.parse("1");
+  anyBigint.parse("123456");
+  anyBigint.parse("0");
+  anyBigint.parse("-123456");
 
   expect(() => empty.parse("a")).toThrow();
-  expect(() => hello.parse("world"));
-  expect(() => world.parse("hello"));
-  expect(() => one.parse("2"));
-  expect(() => two.parse("1"));
-  expect(() => truee.parse("false"));
-  expect(() => anotherTrue.parse("false"));
-  expect(() => falsee.parse("true"));
-  expect(() => anotherFalse.parse("true"));
-  expect(() => nulll.parse("123"));
-  expect(() => anotherNull.parse("123"));
-  expect(() => undefinedd.parse("123"));
-  expect(() => anotherUndefined.parse("123"));
-  expect(() => anyFiniteNumber.parse("Infinity"));
-  expect(() => anyFiniteNumber.parse("-Infinity"));
-  expect(() => anyInt.parse("1.23"));
-  expect(() => anyInt.parse("-1.23"));
-  expect(() => anyNegativeNumber.parse("0"));
-  expect(() => anyNegativeNumber.parse("1"));
-  expect(() => anyNegativeNumber.parse("Infinity"));
-  expect(() => anyPositiveNumber.parse("0"));
-  expect(() => anyPositiveNumber.parse("-1"));
-  expect(() => anyPositiveNumber.parse("-Infinity"));
+  expect(() => hello.parse("hello!")).toThrow();
+  expect(() => hello.parse("!hello")).toThrow();
+  expect(() => world.parse("world!")).toThrow();
+  expect(() => world.parse("!world")).toThrow();
+  expect(() => one.parse("2")).toThrow();
+  expect(() => one.parse("12")).toThrow();
+  expect(() => one.parse("21")).toThrow();
+  expect(() => two.parse("1")).toThrow();
+  expect(() => two.parse("21")).toThrow();
+  expect(() => two.parse("12")).toThrow();
+  expect(() => truee.parse("false")).toThrow();
+  expect(() => truee.parse("1true")).toThrow();
+  expect(() => truee.parse("true1")).toThrow();
+  expect(() => anotherTrue.parse("false")).toThrow();
+  expect(() => anotherTrue.parse("1true")).toThrow();
+  expect(() => anotherTrue.parse("true1")).toThrow();
+  expect(() => falsee.parse("true")).toThrow();
+  expect(() => falsee.parse("1false")).toThrow();
+  expect(() => falsee.parse("false1")).toThrow();
+  expect(() => anotherFalse.parse("true")).toThrow();
+  expect(() => anotherFalse.parse("1false")).toThrow();
+  expect(() => anotherFalse.parse("false1")).toThrow();
+  expect(() => nulll.parse("123")).toThrow();
+  expect(() => nulll.parse("null1")).toThrow();
+  expect(() => nulll.parse("1null")).toThrow();
+  expect(() => anotherNull.parse("123")).toThrow();
+  expect(() => anotherNull.parse("null1")).toThrow();
+  expect(() => anotherNull.parse("1null")).toThrow();
+  expect(() => undefinedd.parse("123")).toThrow();
+  expect(() => undefinedd.parse("undefined1")).toThrow();
+  expect(() => undefinedd.parse("1undefined")).toThrow();
+  expect(() => anotherUndefined.parse("123")).toThrow();
+  expect(() => anotherUndefined.parse("undefined1")).toThrow();
+  expect(() => anotherUndefined.parse("1undefined")).toThrow();
+  expect(() => anyFiniteNumber.parse("Infinity")).toThrow();
+  expect(() => anyFiniteNumber.parse("-Infinity")).toThrow();
+  expect(() => anyFiniteNumber.parse("123a")).toThrow();
+  expect(() => anyFiniteNumber.parse("a123")).toThrow();
+  expect(() => anyInt.parse("1.23")).toThrow();
+  expect(() => anyInt.parse("-1.23")).toThrow();
+  expect(() => anyInt.parse("d1")).toThrow();
+  expect(() => anyInt.parse("1d")).toThrow();
+  expect(() => anyNegativeNumber.parse("0")).toThrow();
+  expect(() => anyNegativeNumber.parse("1")).toThrow();
+  expect(() => anyNegativeNumber.parse("Infinity")).toThrow();
+  expect(() => anyPositiveNumber.parse("0")).toThrow();
+  expect(() => anyPositiveNumber.parse("-1")).toThrow();
+  expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
+  expect(() => bool.parse("123")).toThrow();
+  expect(() => bigone.parse("2")).toThrow();
+  expect(() => bigone.parse("c1")).toThrow();
+  expect(() => anyBigint.parse("1.23")).toThrow();
+  expect(() => anyBigint.parse("-1.23")).toThrow();
+  expect(() => anyBigint.parse("c123")).toThrow();
 
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
diff --git a/src/types.ts b/src/types.ts
index c0a20d899..8ec9d353f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4331,7 +4331,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   ZodTemplateLiteralDef
 > {
   addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
-    type: I
+    type: Exclude<I, ZodNever | ZodAny | ZodNaN | ZodPipeline<any, any>>
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
     return this._addPart(type) as any;
   }
@@ -4393,27 +4393,16 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   protected _transformPartToRegexString(
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
-    if (typeof part !== "object" || part === null) {
-      return this._escapeStringForRegex(part);
+    if (!(part instanceof ZodType)) {
+      return this._getEscapedStringForRegex(part);
     }
 
     if (part instanceof ZodLiteral) {
-      return this._escapeStringForRegex(part._def.value);
+      return this._getEscapedStringForRegex(part._def.value);
     }
 
     if (part instanceof ZodString) {
-      const regexCheck = part._def.checks.find(
-        (check) => check.kind === "regex"
-      );
-
-      if (regexCheck) {
-        return this._unwrapRegexString(
-          ((regexCheck as any).regex as RegExp).source
-        );
-      }
-
-      // FIXME: should we care for string's validations? e.g. uuid, etc.
-      return `.{${part.minLength || 0},${part.maxLength ?? ""}}`;
+      return this._transformZodStringPartToRegexString(part);
     }
 
     if (part instanceof ZodEnum || part instanceof ZodNativeEnum) {
@@ -4422,38 +4411,17 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
           ? part._def.values
           : util.getValidEnumValues(part._def.values);
 
-      return `(${values.map(this._escapeStringForRegex).join("|")})`;
+      return `(${values.map(this._getEscapedStringForRegex).join("|")})`;
     }
 
-    if (part instanceof ZodNumber) {
-      const max = part.maxValue ?? Infinity;
-      const min = part.minValue ?? -Infinity;
-      const isFinite = part.isFinite;
-      let acc = "";
-
-      if (min < 0) {
-        acc = `${acc}\\-`;
-
-        if (max >= 0) {
-          acc = `${acc}?`;
-        }
-      }
-
-      if (!isFinite) {
-        acc = `${acc}(Infinity|(`;
-      }
-
-      acc = `${acc}\\d+`;
-
-      if (!part.isInt) {
-        acc = `${acc}(\\.\\d+)?`;
-      }
-
-      if (!isFinite) {
-        acc = `${acc}))`;
-      }
+    if (part instanceof ZodUnion) {
+      return `(${(part._def.options as any[])
+        .map((option) => this._transformPartToRegexString(option))
+        .join("|")})`;
+    }
 
-      return acc;
+    if (part instanceof ZodNumber) {
+      return this._transformZodNumberPartToRegexString(part);
     }
 
     if (part instanceof ZodOptional) {
@@ -4491,14 +4459,163 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return "undefined";
     }
 
-    return "<<UNSUPPORTED_TEMPLATE_LITERAL_PART>>";
+    throw new Error(
+      "Zod error: Unsupported ZodTemplateLiteral argument! Please submit an issue at https://github.com/colinhacks/zod/issues"
+    );
+  }
+
+  protected _transformZodStringPartToRegexString(part: ZodString): string {
+    let maxLength = Infinity,
+      minLength = 0,
+      endsWith = "",
+      startsWith = "";
+
+    for (const ch of part._def.checks) {
+      if (ch.kind === "cuid") {
+        return this._unwrapRegexString(cuidRegex.source);
+      }
+
+      if (ch.kind === "datetime") {
+        return this._unwrapRegexString(datetimeRegex(ch).source);
+      }
+
+      if (ch.kind === "email") {
+        return this._unwrapRegexString(emailRegex.source);
+      }
+
+      if (ch.kind === "regex") {
+        return this._unwrapRegexString(ch.regex.source);
+      }
+
+      if (ch.kind === "url") {
+        // FIXME: we use native URL for validation, so cannot regex test in such cases.
+        throw new Error(
+          "Zod error: ZodTemplateLiteral does not support use of ZodString with url check!"
+        );
+      }
+
+      if (ch.kind === "uuid") {
+        return this._unwrapRegexString(uuidRegex.source);
+      }
+
+      if (ch.kind === "endsWith") {
+        endsWith = ch.value;
+      } else if (ch.kind === "length") {
+        minLength = maxLength = ch.value;
+      } else if (ch.kind === "max") {
+        maxLength = Math.max(0, Math.min(maxLength, ch.value));
+      } else if (ch.kind === "min") {
+        minLength = Math.max(minLength, ch.value);
+      } else if (ch.kind === "startsWith") {
+        startsWith = ch.value;
+      }
+    }
+
+    const constrainedMinLength = Math.max(
+      0,
+      minLength - startsWith.length - endsWith.length
+    );
+    const constrainedMaxLength = Number.isFinite(maxLength)
+      ? Math.max(0, maxLength - startsWith.length - endsWith.length)
+      : Infinity;
+
+    if (
+      constrainedMinLength > constrainedMaxLength ||
+      constrainedMaxLength === 0
+    ) {
+      return `${startsWith}${endsWith}`;
+    }
+
+    const wildcardLength =
+      constrainedMinLength === constrainedMaxLength
+        ? constrainedMinLength === 1
+          ? ""
+          : `{${constrainedMinLength}}`
+        : !Number.isFinite(constrainedMaxLength)
+        ? constrainedMinLength === 0
+          ? "*"
+          : constrainedMinLength === 1
+          ? "+"
+          : `{${constrainedMinLength},}`
+        : `{${constrainedMinLength},${constrainedMinLength}}`;
+
+    return `${startsWith}.${wildcardLength}${endsWith}`;
+  }
+
+  protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
+    let isNegative = true,
+      isPositive = true,
+      isZero = true,
+      isFinite = false,
+      isInt = false,
+      acc = "";
+
+    for (const ch of part._def.checks) {
+      if (ch.kind === "finite") {
+        isFinite = true;
+      } else if (ch.kind === "int") {
+        isInt = true;
+      } else if (ch.kind === "max") {
+        if (ch.value < 0 || (ch.value === 0 && !ch.inclusive)) {
+          isPositive = false;
+
+          if (ch.value === 0) {
+            isZero = false;
+          }
+        }
+      } else if (ch.kind === "min") {
+        if (ch.value > 0 || (ch.value === 0 && !ch.inclusive)) {
+          isNegative = false;
+
+          if (ch.value === 0) {
+            isZero = false;
+          }
+        }
+      } else if (ch.kind === "multipleOf") {
+        if (util.isInteger(ch.value)) {
+          isInt = true;
+        }
+      }
+    }
+
+    if (isNegative) {
+      acc = `${acc}\\-`;
+
+      if (isPositive) {
+        acc = `${acc}?`;
+      }
+    } else if (!isPositive) {
+      return "0+";
+    }
+
+    if (!isFinite) {
+      acc = `${acc}(Infinity|(`;
+    }
+
+    if (!isZero) {
+      if (!isInt) {
+        acc = `${acc}((\\d*[1-9]\\d*(\\.\\d+)?)|(\\d+\\.\\d*[1-9]\\d*))`;
+      } else {
+        acc = `${acc}\\d*[1-9]\\d*`;
+      }
+    } else if (isInt) {
+      acc = `${acc}\\d+`;
+    } else {
+      acc = `${acc}\\d+(\\.\\d+)?`;
+    }
+
+    if (!isFinite) {
+      acc = `${acc}))`;
+    }
+
+    return acc;
   }
 
   protected _unwrapRegexString(regexString: string): string {
     return regexString.replace(/(^\^)|(\$$)/g, "");
   }
 
-  protected _escapeStringForRegex(str: unknown): string {
+  protected _getEscapedStringForRegex(str: unknown): string {
     if (typeof str !== "string") {
       str = `${str}`;
     }

From a733f54a18b73a671998bce38304f33cbdc3ba21 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sun, 8 Jan 2023 02:14:33 +0200
Subject: [PATCH 10/40] minor fixes, more tests pt. 2.

---
 deno/lib/__tests__/template-literal.test.ts | 138 +++++++++++++-------
 src/__tests__/template-literal.test.ts      | 138 +++++++++++++-------
 2 files changed, 180 insertions(+), 96 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index b107dd33d..0d01888c3 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -149,62 +149,104 @@ test("template literal type inference", () => {
 });
 
 test("template literal unsupported args", () => {
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.object({}));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.array(z.object({})));
-  z.templateLiteral().addInterpolatedPosition(
+  expect(() =>
     // @ts-expect-error
-    z.union([z.object({}), z.string()])
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.any());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.never());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.date());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.custom<object>((data) => true));
-  z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().addInterpolatedPosition(z.object({}))
+  ).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.function());
+    z.templateLiteral().addInterpolatedPosition(z.array(z.object({})))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.union([z.object({}), z.string()])
+    )
+  ).toThrow();
   // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}));
-  z.templateLiteral().addInterpolatedPosition(
+  expect(() => z.templateLiteral().addInterpolatedPosition(z.any())).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.intersection(z.object({}), z.object({}))
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()));
+    z.templateLiteral().addInterpolatedPosition(z.never())
+  ).toThrow();
   // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})));
-  z.templateLiteral().addInterpolatedPosition(
+  expect(() => z.templateLiteral().addInterpolatedPosition(z.date())).toThrow();
+  expect(() =>
+    z
+      .templateLiteral()
+      // @ts-expect-error
+      .addInterpolatedPosition(z.custom<object>((data) => true))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
+    )
+  ).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.preprocess(() => true, z.boolean())
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.promise());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.nan());
-  z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().addInterpolatedPosition(z.function())
+  ).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.pipeline(z.string(), z.string())
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.set(z.string()));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.symbol());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]));
+    z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.intersection(z.object({}), z.object({}))
+    )
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.preprocess(() => true, z.boolean())
+    )
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.promise())
+  ).toThrow();
   // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.unknown());
+  expect(() => z.templateLiteral().addInterpolatedPosition(z.nan())).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.pipeline(z.string(), z.string())
+    )
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.set(z.string()))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.symbol())
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.unknown())
+  ).toThrow();
 });
 
 test("template literal parsing", () => {
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index ac539f0e5..244aa03ee 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -148,62 +148,104 @@ test("template literal type inference", () => {
 });
 
 test("template literal unsupported args", () => {
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.object({}));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.array(z.object({})));
-  z.templateLiteral().addInterpolatedPosition(
+  expect(() =>
     // @ts-expect-error
-    z.union([z.object({}), z.string()])
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.any());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.never());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.date());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.custom<object>((data) => true));
-  z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().addInterpolatedPosition(z.object({}))
+  ).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.function());
+    z.templateLiteral().addInterpolatedPosition(z.array(z.object({})))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.union([z.object({}), z.string()])
+    )
+  ).toThrow();
   // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}));
-  z.templateLiteral().addInterpolatedPosition(
+  expect(() => z.templateLiteral().addInterpolatedPosition(z.any())).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.intersection(z.object({}), z.object({}))
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()));
+    z.templateLiteral().addInterpolatedPosition(z.never())
+  ).toThrow();
   // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})));
-  z.templateLiteral().addInterpolatedPosition(
+  expect(() => z.templateLiteral().addInterpolatedPosition(z.date())).toThrow();
+  expect(() =>
+    z
+      .templateLiteral()
+      // @ts-expect-error
+      .addInterpolatedPosition(z.custom<object>((data) => true))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
+    )
+  ).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.preprocess(() => true, z.boolean())
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.promise());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.nan());
-  z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().addInterpolatedPosition(z.function())
+  ).toThrow();
+  expect(() =>
     // @ts-expect-error
-    z.pipeline(z.string(), z.string())
-  );
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.set(z.string()));
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.symbol());
-  // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]));
+    z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.intersection(z.object({}), z.object({}))
+    )
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.preprocess(() => true, z.boolean())
+    )
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.promise())
+  ).toThrow();
   // @ts-expect-error
-  z.templateLiteral().addInterpolatedPosition(z.unknown());
+  expect(() => z.templateLiteral().addInterpolatedPosition(z.nan())).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.pipeline(z.string(), z.string())
+    )
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.set(z.string()))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.symbol())
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]))
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.unknown())
+  ).toThrow();
 });
 
 test("template literal parsing", () => {

From 3e41e018d9cbc3a717cb56cc4df554aa1208b1f0 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Thu, 12 Jan 2023 23:58:10 +0200
Subject: [PATCH 11/40] more tests pt. 3.

---
 deno/lib/__tests__/template-literal.test.ts | 54 +++++++++++++++++++++
 deno/lib/types.ts                           |  2 +
 src/__tests__/template-literal.test.ts      | 54 +++++++++++++++++++++
 src/types.ts                                |  2 +
 4 files changed, 112 insertions(+)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 0d01888c3..f0521410c 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -59,6 +59,16 @@ const nullishBruh = z
 const nullishString = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().nullish());
+const cuid = z.templateLiteral().addInterpolatedPosition(z.string().cuid());
+const cuidZZZ = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().cuid())
+  .addLiteral("ZZZ");
+const datetime = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().datetime());
+const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
+const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
 
 const url = z
   .templateLiteral()
@@ -131,6 +141,11 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof optionalString>, string>(true);
   util.assertEqual<z.infer<typeof nullishBruh>, `bruh` | `null` | ``>(true);
   util.assertEqual<z.infer<typeof nullishString>, string>(true);
+  util.assertEqual<z.infer<typeof cuid>, string>(true);
+  util.assertEqual<z.infer<typeof cuidZZZ>, `${string}ZZZ`>(true);
+  util.assertEqual<z.infer<typeof datetime>, string>(true);
+  util.assertEqual<z.infer<typeof email>, string>(true);
+  util.assertEqual<z.infer<typeof uuid>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -293,6 +308,20 @@ test("template literal parsing", () => {
   anyBigint.parse("123456");
   anyBigint.parse("0");
   anyBigint.parse("-123456");
+  nullableYo.parse("yo");
+  nullableYo.parse("null");
+  nullableString.parse("abc");
+  nullableString.parse("null");
+  optionalYeah.parse("yeah");
+  optionalYeah.parse("");
+  nullishBruh.parse("bruh");
+  nullishBruh.parse("null");
+  nullishBruh.parse("");
+  cuid.parse("cjld2cyuq0000t3rmniod1foy");
+  cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ");
+  datetime.parse(new Date().toISOString());
+  email.parse("info@example.com");
+  uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
 
   expect(() => empty.parse("a")).toThrow();
   expect(() => hello.parse("hello!")).toThrow();
@@ -349,6 +378,31 @@ test("template literal parsing", () => {
   expect(() => anyBigint.parse("1.23")).toThrow();
   expect(() => anyBigint.parse("-1.23")).toThrow();
   expect(() => anyBigint.parse("c123")).toThrow();
+  expect(() => nullableYo.parse("yo1")).toThrow();
+  expect(() => nullableYo.parse("1yo")).toThrow();
+  expect(() => nullableYo.parse("null1")).toThrow();
+  expect(() => nullableYo.parse("1null")).toThrow();
+  expect(() => optionalYeah.parse("yeah1")).toThrow();
+  expect(() => optionalYeah.parse("1yeah")).toThrow();
+  expect(() => optionalYeah.parse("undefined")).toThrow();
+  expect(() => nullishBruh.parse("bruh1")).toThrow();
+  expect(() => nullishBruh.parse("1bruh")).toThrow();
+  expect(() => nullishBruh.parse("null1")).toThrow();
+  expect(() => nullishBruh.parse("1null")).toThrow();
+  expect(() => nullishBruh.parse("undefined")).toThrow();
+  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy1"));
+  expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy"));
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy"));
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY"));
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1"));
+  expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ"));
+  expect(() => datetime.parse("2022-01-01 00:00:00"));
+  expect(() => email.parse("info@example.com@"));
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().url())
+  ).toThrow();
+  expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z"));
+  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6"));
 
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index ef952e988..a6c4e6a58 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4484,6 +4484,8 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }
 
       if (ch.kind === "regex") {
+        // FIXME: maybe allow combinations of endsWith, startsWith, min/max length with a regex,
+        // if it doesn't lock both ends with `^` & `$` ?
         return this._unwrapRegexString(ch.regex.source);
       }
 
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index 244aa03ee..bd6237191 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -58,6 +58,16 @@ const nullishBruh = z
 const nullishString = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().nullish());
+const cuid = z.templateLiteral().addInterpolatedPosition(z.string().cuid());
+const cuidZZZ = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().cuid())
+  .addLiteral("ZZZ");
+const datetime = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().datetime());
+const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
+const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
 
 const url = z
   .templateLiteral()
@@ -130,6 +140,11 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof optionalString>, string>(true);
   util.assertEqual<z.infer<typeof nullishBruh>, `bruh` | `null` | ``>(true);
   util.assertEqual<z.infer<typeof nullishString>, string>(true);
+  util.assertEqual<z.infer<typeof cuid>, string>(true);
+  util.assertEqual<z.infer<typeof cuidZZZ>, `${string}ZZZ`>(true);
+  util.assertEqual<z.infer<typeof datetime>, string>(true);
+  util.assertEqual<z.infer<typeof email>, string>(true);
+  util.assertEqual<z.infer<typeof uuid>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -292,6 +307,20 @@ test("template literal parsing", () => {
   anyBigint.parse("123456");
   anyBigint.parse("0");
   anyBigint.parse("-123456");
+  nullableYo.parse("yo");
+  nullableYo.parse("null");
+  nullableString.parse("abc");
+  nullableString.parse("null");
+  optionalYeah.parse("yeah");
+  optionalYeah.parse("");
+  nullishBruh.parse("bruh");
+  nullishBruh.parse("null");
+  nullishBruh.parse("");
+  cuid.parse("cjld2cyuq0000t3rmniod1foy");
+  cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ");
+  datetime.parse(new Date().toISOString());
+  email.parse("info@example.com");
+  uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
 
   expect(() => empty.parse("a")).toThrow();
   expect(() => hello.parse("hello!")).toThrow();
@@ -348,6 +377,31 @@ test("template literal parsing", () => {
   expect(() => anyBigint.parse("1.23")).toThrow();
   expect(() => anyBigint.parse("-1.23")).toThrow();
   expect(() => anyBigint.parse("c123")).toThrow();
+  expect(() => nullableYo.parse("yo1")).toThrow();
+  expect(() => nullableYo.parse("1yo")).toThrow();
+  expect(() => nullableYo.parse("null1")).toThrow();
+  expect(() => nullableYo.parse("1null")).toThrow();
+  expect(() => optionalYeah.parse("yeah1")).toThrow();
+  expect(() => optionalYeah.parse("1yeah")).toThrow();
+  expect(() => optionalYeah.parse("undefined")).toThrow();
+  expect(() => nullishBruh.parse("bruh1")).toThrow();
+  expect(() => nullishBruh.parse("1bruh")).toThrow();
+  expect(() => nullishBruh.parse("null1")).toThrow();
+  expect(() => nullishBruh.parse("1null")).toThrow();
+  expect(() => nullishBruh.parse("undefined")).toThrow();
+  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy1"));
+  expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy"));
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy"));
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY"));
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1"));
+  expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ"));
+  expect(() => datetime.parse("2022-01-01 00:00:00"));
+  expect(() => email.parse("info@example.com@"));
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().url())
+  ).toThrow();
+  expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z"));
+  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6"));
 
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
diff --git a/src/types.ts b/src/types.ts
index 8ec9d353f..0bef6f3d3 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4484,6 +4484,8 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }
 
       if (ch.kind === "regex") {
+        // FIXME: maybe allow combinations of endsWith, startsWith, min/max length with a regex,
+        // if it doesn't lock both ends with `^` & `$` ?
         return this._unwrapRegexString(ch.regex.source);
       }
 

From f1c9f01950da30af96492a75f7683d89a41d0a9c Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 13 Jan 2023 18:09:17 +0200
Subject: [PATCH 12/40] more tests pt. 4.

---
 deno/lib/README.md                          |   5 +
 deno/lib/__tests__/template-literal.test.ts | 121 ++++++++++++++++++--
 deno/lib/types.ts                           |  61 +++++++---
 src/__tests__/template-literal.test.ts      | 121 ++++++++++++++++++--
 src/types.ts                                |  61 +++++++---
 5 files changed, 317 insertions(+), 52 deletions(-)

diff --git a/deno/lib/README.md b/deno/lib/README.md
index 55a24a12f..78d4b3089 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -91,6 +91,7 @@
 - [Promises](#promises)
 - [Instanceof](#instanceof)
 - [Functions](#functions)
+- [Template Literals](#template-literals)
 - [Preprocess](#preprocess)
 - [Custom](#custom-schemas)
 - [Schema methods](#schema-methods)
@@ -1637,6 +1638,10 @@ myFunction.returnType();
 * `args: ZodTuple` The first argument is a tuple (created with `z.tuple([...])` and defines the schema of the arguments to your function. If the function doesn't accept arguments, you can pass an empty tuple (`z.tuple([])`).
 * `returnType: any Zod schema` The second argument is the function's return type. This can be any Zod schema. -->
 
+## Template Literals
+
+Building on the knowledge above, Zod supports building typescript template literal types with runtime validation.
+
 ## Preprocess
 
 > Zod now supports primitive coercion without the need for `.preprocess()`. See the [coercion docs](#coercion-for-primitives) for more information.
diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index f0521410c..6a7bda58a 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -36,6 +36,18 @@ const anyNegativeNumber = z
 const anyPositiveNumber = z
   .templateLiteral()
   .addInterpolatedPosition(z.number().positive());
+const multipleOfTwo = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().multipleOf(2));
+const multipleOfPi = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().multipleOf(Math.PI));
+const zeroButInADumbWay = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().nonnegative().nonpositive());
+const finiteButInADumbWay = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().min(5).max(10));
 const bool = z.templateLiteral().addInterpolatedPosition(z.boolean());
 const bigone = z
   .templateLiteral()
@@ -53,6 +65,9 @@ const optionalYeah = z
 const optionalString = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().optional());
+const optionalNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().optional());
 const nullishBruh = z
   .templateLiteral()
   .addInterpolatedPosition(z.literal("bruh").nullish());
@@ -69,6 +84,30 @@ const datetime = z
   .addInterpolatedPosition(z.string().datetime());
 const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
 const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
+const stringAToZ = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().regex(/^[a-z]+$/));
+const stringStartsWith = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().startsWith("hello"));
+const stringEndsWith = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().endsWith("world"));
+const stringMax5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().max(5));
+const stringMin5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().min(5));
+const stringLen5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().length(5));
+const stringMin5Max10 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().min(5).max(10));
+const stringStartsWithMax5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().startsWith("hello").max(5));
 
 const url = z
   .templateLiteral()
@@ -132,6 +171,10 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyNegativeNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyPositiveNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof multipleOfTwo>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof multipleOfPi>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof zeroButInADumbWay>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof finiteButInADumbWay>, `${number}`>(true);
   util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
   util.assertEqual<z.infer<typeof bigone>, `${bigint}`>(true);
   util.assertEqual<z.infer<typeof anyBigint>, `${bigint}`>(true);
@@ -139,6 +182,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof nullableString>, string>(true);
   util.assertEqual<z.infer<typeof optionalYeah>, `yeah` | ``>(true);
   util.assertEqual<z.infer<typeof optionalString>, string>(true);
+  util.assertEqual<z.infer<typeof optionalNumber>, `${number}` | ``>(true);
   util.assertEqual<z.infer<typeof nullishBruh>, `bruh` | `null` | ``>(true);
   util.assertEqual<z.infer<typeof nullishString>, string>(true);
   util.assertEqual<z.infer<typeof cuid>, string>(true);
@@ -146,6 +190,14 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof datetime>, string>(true);
   util.assertEqual<z.infer<typeof email>, string>(true);
   util.assertEqual<z.infer<typeof uuid>, string>(true);
+  util.assertEqual<z.infer<typeof stringAToZ>, string>(true);
+  util.assertEqual<z.infer<typeof stringStartsWith>, string>(true);
+  util.assertEqual<z.infer<typeof stringEndsWith>, string>(true);
+  util.assertEqual<z.infer<typeof stringMax5>, string>(true);
+  util.assertEqual<z.infer<typeof stringMin5>, string>(true);
+  util.assertEqual<z.infer<typeof stringLen5>, string>(true);
+  util.assertEqual<z.infer<typeof stringMin5Max10>, string>(true);
+  util.assertEqual<z.infer<typeof stringStartsWithMax5>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -264,7 +316,7 @@ test("template literal unsupported args", () => {
   ).toThrow();
 });
 
-test("template literal parsing", () => {
+test("template literal parsing - success - basic cases", () => {
   expect(() => z.templateLiteral().parse(7)).toThrow();
 
   empty.parse("");
@@ -302,6 +354,14 @@ test("template literal parsing", () => {
   anyPositiveNumber.parse("123");
   anyPositiveNumber.parse("1.23");
   anyPositiveNumber.parse("Infinity");
+  multipleOfTwo.parse("2");
+  multipleOfPi.parse("2");
+  multipleOfPi.parse("3.14");
+  zeroButInADumbWay.parse("0");
+  zeroButInADumbWay.parse("00000");
+  finiteButInADumbWay.parse("5");
+  finiteButInADumbWay.parse("10");
+  finiteButInADumbWay.parse("6.66");
   bool.parse("true");
   bool.parse("false");
   bigone.parse("1");
@@ -314,6 +374,15 @@ test("template literal parsing", () => {
   nullableString.parse("null");
   optionalYeah.parse("yeah");
   optionalYeah.parse("");
+  optionalString.parse("abc");
+  optionalString.parse("");
+  optionalNumber.parse("123");
+  optionalNumber.parse("1.23");
+  optionalNumber.parse("0");
+  optionalNumber.parse("-1.23");
+  optionalNumber.parse("-123");
+  optionalNumber.parse("Infinity");
+  optionalNumber.parse("-Infinity");
   nullishBruh.parse("bruh");
   nullishBruh.parse("null");
   nullishBruh.parse("");
@@ -322,7 +391,17 @@ test("template literal parsing", () => {
   datetime.parse(new Date().toISOString());
   email.parse("info@example.com");
   uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
+  stringAToZ.parse("asudgaskhdgashd");
+  stringStartsWith.parse("hello world");
+  stringEndsWith.parse("hello world");
+  stringMax5.parse("hello");
+  stringMin5.parse("hello");
+  stringLen5.parse("hello");
+  stringMin5Max10.parse("hello worl");
+  stringStartsWithMax5.parse("hello");
+});
 
+test("template literal parsing - failure - basic cases", () => {
   expect(() => empty.parse("a")).toThrow();
   expect(() => hello.parse("hello!")).toThrow();
   expect(() => hello.parse("!hello")).toThrow();
@@ -372,6 +451,14 @@ test("template literal parsing", () => {
   expect(() => anyPositiveNumber.parse("0")).toThrow();
   expect(() => anyPositiveNumber.parse("-1")).toThrow();
   expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
+  expect(() => multipleOfTwo.parse("3.14")).toThrow();
+  expect(() => zeroButInADumbWay.parse("1")).toThrow();
+  expect(() => zeroButInADumbWay.parse("-1")).toThrow();
+  expect(() => finiteButInADumbWay.parse("Infinity")).toThrow();
+  expect(() => finiteButInADumbWay.parse("-Infinity")).toThrow();
+  expect(() => finiteButInADumbWay.parse("-5")).toThrow();
+  expect(() => finiteButInADumbWay.parse("10a")).toThrow();
+  expect(() => finiteButInADumbWay.parse("a10")).toThrow();
   expect(() => bool.parse("123")).toThrow();
   expect(() => bigone.parse("2")).toThrow();
   expect(() => bigone.parse("c1")).toThrow();
@@ -385,6 +472,10 @@ test("template literal parsing", () => {
   expect(() => optionalYeah.parse("yeah1")).toThrow();
   expect(() => optionalYeah.parse("1yeah")).toThrow();
   expect(() => optionalYeah.parse("undefined")).toThrow();
+  expect(() => optionalNumber.parse("123a")).toThrow();
+  expect(() => optionalNumber.parse("a123")).toThrow();
+  expect(() => optionalNumber.parse("Infinitya")).toThrow();
+  expect(() => optionalNumber.parse("aInfinity")).toThrow();
   expect(() => nullishBruh.parse("bruh1")).toThrow();
   expect(() => nullishBruh.parse("1bruh")).toThrow();
   expect(() => nullishBruh.parse("null1")).toThrow();
@@ -403,16 +494,24 @@ test("template literal parsing", () => {
   ).toThrow();
   expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z"));
   expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6"));
+  expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
+  expect(() => stringAToZ.parse("1asdasdasd")).toThrow();
+  expect(() => stringStartsWith.parse("ahello")).toThrow();
+  expect(() => stringEndsWith.parse("worlda")).toThrow();
+  expect(() => stringMax5.parse("123456")).toThrow();
+  expect(() => stringMin5.parse("1234")).toThrow();
+  expect(() => stringLen5.parse("123456")).toThrow();
+  expect(() => stringLen5.parse("1234")).toThrow();
+  expect(() => stringMin5Max10.parse("1234")).toThrow();
+  expect(() => stringMin5Max10.parse("12345678901")).toThrow();
+  expect(() => stringStartsWithMax5.parse("hello1")).toThrow();
+  expect(() => stringStartsWithMax5.parse("1hell")).toThrow();
+});
 
+test("template literal parsing - success - complex cases", () => {
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
-  expect(() => url.parse("http://example.com")).toThrow();
-  expect(() => url.parse("https://.com")).toThrow();
-  expect(() => url.parse("https://examplecom")).toThrow();
-  expect(() => url.parse("https://example.org")).toThrow();
-  expect(() => url.parse("https://example.net.il")).toThrow();
-
   connectionString.parse("mongodb://host:1234");
   connectionString.parse("mongodb://host:1234/");
   connectionString.parse("mongodb://host:1234/defaultauthdb");
@@ -439,6 +538,14 @@ test("template literal parsing", () => {
   connectionString.parse(
     "mongodb://username:password@host:1234/?authSource=admin&connectTimeoutMS=300000"
   );
+});
+
+test("template literal parsing - failure - complex cases", () => {
+  expect(() => url.parse("http://example.com")).toThrow();
+  expect(() => url.parse("https://.com")).toThrow();
+  expect(() => url.parse("https://examplecom")).toThrow();
+  expect(() => url.parse("https://example.org")).toThrow();
+  expect(() => url.parse("https://example.net.il")).toThrow();
 
   expect(() => connectionString.parse("mongod://host:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://:1234")).toThrow();
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index a6c4e6a58..686ea4314 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4522,31 +4522,46 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       : Infinity;
 
     if (
-      constrainedMinLength > constrainedMaxLength ||
-      constrainedMaxLength === 0
+      constrainedMaxLength === 0 ||
+      constrainedMinLength > constrainedMaxLength
     ) {
       return `${startsWith}${endsWith}`;
     }
 
-    const wildcardLength =
-      constrainedMinLength === constrainedMaxLength
-        ? constrainedMinLength === 1
-          ? ""
-          : `{${constrainedMinLength}}`
-        : !Number.isFinite(constrainedMaxLength)
-        ? constrainedMinLength === 0
-          ? "*"
-          : constrainedMinLength === 1
-          ? "+"
-          : `{${constrainedMinLength},}`
-        : `{${constrainedMinLength},${constrainedMinLength}}`;
+    return `${startsWith}.${this._resolveRegexWildcardLength(
+      constrainedMinLength,
+      constrainedMaxLength
+    )}${endsWith}`;
+  }
+
+  protected _resolveRegexWildcardLength(
+    minLength: number,
+    maxLength: number
+  ): string {
+    if (minLength === maxLength) {
+      return minLength === 1 ? "" : `{${minLength}}`;
+    }
+
+    if (maxLength !== Infinity) {
+      return `{${minLength},${maxLength}}`;
+    }
+
+    if (minLength === 0) {
+      return "*";
+    }
+
+    if (minLength === 1) {
+      return "+";
+    }
 
-    return `${startsWith}.${wildcardLength}${endsWith}`;
+    return `{${minLength},}`;
   }
 
   protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
     let isNegative = true,
       isPositive = true,
+      min = -Infinity,
+      max = Infinity,
       isZero = true,
       isFinite = false,
       isInt = false,
@@ -4558,18 +4573,22 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       } else if (ch.kind === "int") {
         isInt = true;
       } else if (ch.kind === "max") {
-        if (ch.value < 0 || (ch.value === 0 && !ch.inclusive)) {
+        max = Math.min(max, ch.value);
+
+        if (ch.value <= 0) {
           isPositive = false;
 
-          if (ch.value === 0) {
+          if (ch.value === 0 && !ch.inclusive) {
             isZero = false;
           }
         }
       } else if (ch.kind === "min") {
-        if (ch.value > 0 || (ch.value === 0 && !ch.inclusive)) {
+        min = Math.max(min, ch.value);
+
+        if (ch.value >= 0) {
           isNegative = false;
 
-          if (ch.value === 0) {
+          if (ch.value === 0 && !ch.inclusive) {
             isZero = false;
           }
         }
@@ -4580,6 +4599,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }
     }
 
+    if (Number.isFinite(min) && Number.isFinite(max)) {
+      isFinite = true;
+    }
+
     if (isNegative) {
       acc = `${acc}\\-`;
 
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index bd6237191..12e182915 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -35,6 +35,18 @@ const anyNegativeNumber = z
 const anyPositiveNumber = z
   .templateLiteral()
   .addInterpolatedPosition(z.number().positive());
+const multipleOfTwo = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().multipleOf(2));
+const multipleOfPi = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().multipleOf(Math.PI));
+const zeroButInADumbWay = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().nonnegative().nonpositive());
+const finiteButInADumbWay = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().min(5).max(10));
 const bool = z.templateLiteral().addInterpolatedPosition(z.boolean());
 const bigone = z
   .templateLiteral()
@@ -52,6 +64,9 @@ const optionalYeah = z
 const optionalString = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().optional());
+const optionalNumber = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().optional());
 const nullishBruh = z
   .templateLiteral()
   .addInterpolatedPosition(z.literal("bruh").nullish());
@@ -68,6 +83,30 @@ const datetime = z
   .addInterpolatedPosition(z.string().datetime());
 const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
 const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
+const stringAToZ = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().regex(/^[a-z]+$/));
+const stringStartsWith = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().startsWith("hello"));
+const stringEndsWith = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().endsWith("world"));
+const stringMax5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().max(5));
+const stringMin5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().min(5));
+const stringLen5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().length(5));
+const stringMin5Max10 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().min(5).max(10));
+const stringStartsWithMax5 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().startsWith("hello").max(5));
 
 const url = z
   .templateLiteral()
@@ -131,6 +170,10 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyNegativeNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyPositiveNumber>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof multipleOfTwo>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof multipleOfPi>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof zeroButInADumbWay>, `${number}`>(true);
+  util.assertEqual<z.infer<typeof finiteButInADumbWay>, `${number}`>(true);
   util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
   util.assertEqual<z.infer<typeof bigone>, `${bigint}`>(true);
   util.assertEqual<z.infer<typeof anyBigint>, `${bigint}`>(true);
@@ -138,6 +181,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof nullableString>, string>(true);
   util.assertEqual<z.infer<typeof optionalYeah>, `yeah` | ``>(true);
   util.assertEqual<z.infer<typeof optionalString>, string>(true);
+  util.assertEqual<z.infer<typeof optionalNumber>, `${number}` | ``>(true);
   util.assertEqual<z.infer<typeof nullishBruh>, `bruh` | `null` | ``>(true);
   util.assertEqual<z.infer<typeof nullishString>, string>(true);
   util.assertEqual<z.infer<typeof cuid>, string>(true);
@@ -145,6 +189,14 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof datetime>, string>(true);
   util.assertEqual<z.infer<typeof email>, string>(true);
   util.assertEqual<z.infer<typeof uuid>, string>(true);
+  util.assertEqual<z.infer<typeof stringAToZ>, string>(true);
+  util.assertEqual<z.infer<typeof stringStartsWith>, string>(true);
+  util.assertEqual<z.infer<typeof stringEndsWith>, string>(true);
+  util.assertEqual<z.infer<typeof stringMax5>, string>(true);
+  util.assertEqual<z.infer<typeof stringMin5>, string>(true);
+  util.assertEqual<z.infer<typeof stringLen5>, string>(true);
+  util.assertEqual<z.infer<typeof stringMin5Max10>, string>(true);
+  util.assertEqual<z.infer<typeof stringStartsWithMax5>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -263,7 +315,7 @@ test("template literal unsupported args", () => {
   ).toThrow();
 });
 
-test("template literal parsing", () => {
+test("template literal parsing - success - basic cases", () => {
   expect(() => z.templateLiteral().parse(7)).toThrow();
 
   empty.parse("");
@@ -301,6 +353,14 @@ test("template literal parsing", () => {
   anyPositiveNumber.parse("123");
   anyPositiveNumber.parse("1.23");
   anyPositiveNumber.parse("Infinity");
+  multipleOfTwo.parse("2");
+  multipleOfPi.parse("2");
+  multipleOfPi.parse("3.14");
+  zeroButInADumbWay.parse("0");
+  zeroButInADumbWay.parse("00000");
+  finiteButInADumbWay.parse("5");
+  finiteButInADumbWay.parse("10");
+  finiteButInADumbWay.parse("6.66");
   bool.parse("true");
   bool.parse("false");
   bigone.parse("1");
@@ -313,6 +373,15 @@ test("template literal parsing", () => {
   nullableString.parse("null");
   optionalYeah.parse("yeah");
   optionalYeah.parse("");
+  optionalString.parse("abc");
+  optionalString.parse("");
+  optionalNumber.parse("123");
+  optionalNumber.parse("1.23");
+  optionalNumber.parse("0");
+  optionalNumber.parse("-1.23");
+  optionalNumber.parse("-123");
+  optionalNumber.parse("Infinity");
+  optionalNumber.parse("-Infinity");
   nullishBruh.parse("bruh");
   nullishBruh.parse("null");
   nullishBruh.parse("");
@@ -321,7 +390,17 @@ test("template literal parsing", () => {
   datetime.parse(new Date().toISOString());
   email.parse("info@example.com");
   uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
+  stringAToZ.parse("asudgaskhdgashd");
+  stringStartsWith.parse("hello world");
+  stringEndsWith.parse("hello world");
+  stringMax5.parse("hello");
+  stringMin5.parse("hello");
+  stringLen5.parse("hello");
+  stringMin5Max10.parse("hello worl");
+  stringStartsWithMax5.parse("hello");
+});
 
+test("template literal parsing - failure - basic cases", () => {
   expect(() => empty.parse("a")).toThrow();
   expect(() => hello.parse("hello!")).toThrow();
   expect(() => hello.parse("!hello")).toThrow();
@@ -371,6 +450,14 @@ test("template literal parsing", () => {
   expect(() => anyPositiveNumber.parse("0")).toThrow();
   expect(() => anyPositiveNumber.parse("-1")).toThrow();
   expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
+  expect(() => multipleOfTwo.parse("3.14")).toThrow();
+  expect(() => zeroButInADumbWay.parse("1")).toThrow();
+  expect(() => zeroButInADumbWay.parse("-1")).toThrow();
+  expect(() => finiteButInADumbWay.parse("Infinity")).toThrow();
+  expect(() => finiteButInADumbWay.parse("-Infinity")).toThrow();
+  expect(() => finiteButInADumbWay.parse("-5")).toThrow();
+  expect(() => finiteButInADumbWay.parse("10a")).toThrow();
+  expect(() => finiteButInADumbWay.parse("a10")).toThrow();
   expect(() => bool.parse("123")).toThrow();
   expect(() => bigone.parse("2")).toThrow();
   expect(() => bigone.parse("c1")).toThrow();
@@ -384,6 +471,10 @@ test("template literal parsing", () => {
   expect(() => optionalYeah.parse("yeah1")).toThrow();
   expect(() => optionalYeah.parse("1yeah")).toThrow();
   expect(() => optionalYeah.parse("undefined")).toThrow();
+  expect(() => optionalNumber.parse("123a")).toThrow();
+  expect(() => optionalNumber.parse("a123")).toThrow();
+  expect(() => optionalNumber.parse("Infinitya")).toThrow();
+  expect(() => optionalNumber.parse("aInfinity")).toThrow();
   expect(() => nullishBruh.parse("bruh1")).toThrow();
   expect(() => nullishBruh.parse("1bruh")).toThrow();
   expect(() => nullishBruh.parse("null1")).toThrow();
@@ -402,16 +493,24 @@ test("template literal parsing", () => {
   ).toThrow();
   expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z"));
   expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6"));
+  expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
+  expect(() => stringAToZ.parse("1asdasdasd")).toThrow();
+  expect(() => stringStartsWith.parse("ahello")).toThrow();
+  expect(() => stringEndsWith.parse("worlda")).toThrow();
+  expect(() => stringMax5.parse("123456")).toThrow();
+  expect(() => stringMin5.parse("1234")).toThrow();
+  expect(() => stringLen5.parse("123456")).toThrow();
+  expect(() => stringLen5.parse("1234")).toThrow();
+  expect(() => stringMin5Max10.parse("1234")).toThrow();
+  expect(() => stringMin5Max10.parse("12345678901")).toThrow();
+  expect(() => stringStartsWithMax5.parse("hello1")).toThrow();
+  expect(() => stringStartsWithMax5.parse("1hell")).toThrow();
+});
 
+test("template literal parsing - success - complex cases", () => {
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
-  expect(() => url.parse("http://example.com")).toThrow();
-  expect(() => url.parse("https://.com")).toThrow();
-  expect(() => url.parse("https://examplecom")).toThrow();
-  expect(() => url.parse("https://example.org")).toThrow();
-  expect(() => url.parse("https://example.net.il")).toThrow();
-
   connectionString.parse("mongodb://host:1234");
   connectionString.parse("mongodb://host:1234/");
   connectionString.parse("mongodb://host:1234/defaultauthdb");
@@ -438,6 +537,14 @@ test("template literal parsing", () => {
   connectionString.parse(
     "mongodb://username:password@host:1234/?authSource=admin&connectTimeoutMS=300000"
   );
+});
+
+test("template literal parsing - failure - complex cases", () => {
+  expect(() => url.parse("http://example.com")).toThrow();
+  expect(() => url.parse("https://.com")).toThrow();
+  expect(() => url.parse("https://examplecom")).toThrow();
+  expect(() => url.parse("https://example.org")).toThrow();
+  expect(() => url.parse("https://example.net.il")).toThrow();
 
   expect(() => connectionString.parse("mongod://host:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://:1234")).toThrow();
diff --git a/src/types.ts b/src/types.ts
index 0bef6f3d3..d1ac36789 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4522,31 +4522,46 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       : Infinity;
 
     if (
-      constrainedMinLength > constrainedMaxLength ||
-      constrainedMaxLength === 0
+      constrainedMaxLength === 0 ||
+      constrainedMinLength > constrainedMaxLength
     ) {
       return `${startsWith}${endsWith}`;
     }
 
-    const wildcardLength =
-      constrainedMinLength === constrainedMaxLength
-        ? constrainedMinLength === 1
-          ? ""
-          : `{${constrainedMinLength}}`
-        : !Number.isFinite(constrainedMaxLength)
-        ? constrainedMinLength === 0
-          ? "*"
-          : constrainedMinLength === 1
-          ? "+"
-          : `{${constrainedMinLength},}`
-        : `{${constrainedMinLength},${constrainedMinLength}}`;
+    return `${startsWith}.${this._resolveRegexWildcardLength(
+      constrainedMinLength,
+      constrainedMaxLength
+    )}${endsWith}`;
+  }
+
+  protected _resolveRegexWildcardLength(
+    minLength: number,
+    maxLength: number
+  ): string {
+    if (minLength === maxLength) {
+      return minLength === 1 ? "" : `{${minLength}}`;
+    }
+
+    if (maxLength !== Infinity) {
+      return `{${minLength},${maxLength}}`;
+    }
+
+    if (minLength === 0) {
+      return "*";
+    }
+
+    if (minLength === 1) {
+      return "+";
+    }
 
-    return `${startsWith}.${wildcardLength}${endsWith}`;
+    return `{${minLength},}`;
   }
 
   protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
     let isNegative = true,
       isPositive = true,
+      min = -Infinity,
+      max = Infinity,
       isZero = true,
       isFinite = false,
       isInt = false,
@@ -4558,18 +4573,22 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       } else if (ch.kind === "int") {
         isInt = true;
       } else if (ch.kind === "max") {
-        if (ch.value < 0 || (ch.value === 0 && !ch.inclusive)) {
+        max = Math.min(max, ch.value);
+
+        if (ch.value <= 0) {
           isPositive = false;
 
-          if (ch.value === 0) {
+          if (ch.value === 0 && !ch.inclusive) {
             isZero = false;
           }
         }
       } else if (ch.kind === "min") {
-        if (ch.value > 0 || (ch.value === 0 && !ch.inclusive)) {
+        min = Math.max(min, ch.value);
+
+        if (ch.value >= 0) {
           isNegative = false;
 
-          if (ch.value === 0) {
+          if (ch.value === 0 && !ch.inclusive) {
             isZero = false;
           }
         }
@@ -4580,6 +4599,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }
     }
 
+    if (Number.isFinite(min) && Number.isFinite(max)) {
+      isFinite = true;
+    }
+
     if (isNegative) {
       acc = `${acc}\\-`;
 

From 3e95eeed492ff5d3588235a883d80347eb8f0327 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 13 Jan 2023 19:11:19 +0200
Subject: [PATCH 13/40] add `ZodTemplateLiteral` README.md section.

---
 README.md          | 85 ++++++++++++++++++++++++++++++++++++++++++++++
 deno/lib/README.md | 82 +++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 166 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 55a24a12f..5152cc148 100644
--- a/README.md
+++ b/README.md
@@ -91,6 +91,7 @@
 - [Promises](#promises)
 - [Instanceof](#instanceof)
 - [Functions](#functions)
+- [Template Literals](#template-literals)
 - [Preprocess](#preprocess)
 - [Custom](#custom-schemas)
 - [Schema methods](#schema-methods)
@@ -1637,6 +1638,90 @@ myFunction.returnType();
 * `args: ZodTuple` The first argument is a tuple (created with `z.tuple([...])` and defines the schema of the arguments to your function. If the function doesn't accept arguments, you can pass an empty tuple (`z.tuple([])`).
 * `returnType: any Zod schema` The second argument is the function's return type. This can be any Zod schema. -->
 
+## Template Literals
+
+Building on the knowledge above, Zod supports creating typescript [template literal types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html) with runtime validation. These types allow for stricter type checking of string inputs, as an alternative to `z.string()` which infers to a string.
+
+A template literal type consists of [string literal types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) and interpolated positions (typescript types inside `${}` slots, e.g. `${number}`).
+
+To create a template literal builder:
+
+```ts
+const templateLiteral = z.templateLiteral(); // infers to ``.
+```
+
+- To add string literal types to an existing template literal:
+
+  ```ts
+  templateLiteral.addLiteral('Hello'); // infers to `Hello`.
+  templateLiteral.addLiteral(3.14); // infers to `3.14`.
+  ```
+
+  This method accepts strings, numbers, booleans, nulls and undefined.
+
+- To add interpolated positions to an existing template literal:
+
+  ```ts
+  templateLiteral.addInterpolatedPosition(z.string()); // infers to string.
+  templateLiteral.addInterpolatedPosition(z.number()); // infers to `${number}`.
+  templateLiteral.addInterpolatedPosition(z.boolean()); // infers to `true` | `false`.
+  templateLiteral.addInterpolatedPosition(z.literal('foo')); // infers to `foo`.
+  templateLiteral.addInterpolatedPosition(z.null()); // infers to `null`.
+  templateLiteral.addInterpolatedPosition(z.undefined()); // infers to `undefined`.
+  templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
+  ```
+
+  Any Zod type (or union) with an underlying type of string, number, boolean, null, undefined or bigint can be used as an interpolated position (template literals included!). You can use additional built-in runtime validations (refinements excluded) in each of these types and the template literal builder will do its best to
+  support them when parsing.
+
+### Examples
+
+MongoDB connection string:
+
+```ts
+const connectionString = z
+  .templateLiteral()
+  .addLiteral("mongodb://")
+  .addInterpolatedPosition(
+    z
+      .templateLiteral()
+      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addLiteral(":")
+      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addLiteral("@")
+      .optional()
+  )
+  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addLiteral(":")
+  .addInterpolatedPosition(
+    z.number().finite().int().positive().describe("port")
+  )
+  .addInterpolatedPosition(
+    z
+      .templateLiteral()
+      .addLiteral("/")
+      .addInterpolatedPosition(
+        z.string().min(1).optional().describe("defaultauthdb")
+      )
+      .addInterpolatedPosition(
+        z
+          .templateLiteral()
+          .addLiteral("?")
+          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .optional()
+          .describe("options")
+      )
+      .optional()
+  );
+  // infers to:
+  // | `mongodb://${string}:${number}`
+  // | `mongodb://${string}:${number}/${string}`
+  // | `mongodb://${string}:${number}/${string}?${string}`
+  // | `mongodb://${string}:${string}@${string}:${number}`
+  // | `mongodb://${string}:${string}@${string}:${number}/${string}`
+  // | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
+```
+
 ## Preprocess
 
 > Zod now supports primitive coercion without the need for `.preprocess()`. See the [coercion docs](#coercion-for-primitives) for more information.
diff --git a/deno/lib/README.md b/deno/lib/README.md
index 78d4b3089..5152cc148 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1640,7 +1640,87 @@ myFunction.returnType();
 
 ## Template Literals
 
-Building on the knowledge above, Zod supports building typescript template literal types with runtime validation.
+Building on the knowledge above, Zod supports creating typescript [template literal types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html) with runtime validation. These types allow for stricter type checking of string inputs, as an alternative to `z.string()` which infers to a string.
+
+A template literal type consists of [string literal types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) and interpolated positions (typescript types inside `${}` slots, e.g. `${number}`).
+
+To create a template literal builder:
+
+```ts
+const templateLiteral = z.templateLiteral(); // infers to ``.
+```
+
+- To add string literal types to an existing template literal:
+
+  ```ts
+  templateLiteral.addLiteral('Hello'); // infers to `Hello`.
+  templateLiteral.addLiteral(3.14); // infers to `3.14`.
+  ```
+
+  This method accepts strings, numbers, booleans, nulls and undefined.
+
+- To add interpolated positions to an existing template literal:
+
+  ```ts
+  templateLiteral.addInterpolatedPosition(z.string()); // infers to string.
+  templateLiteral.addInterpolatedPosition(z.number()); // infers to `${number}`.
+  templateLiteral.addInterpolatedPosition(z.boolean()); // infers to `true` | `false`.
+  templateLiteral.addInterpolatedPosition(z.literal('foo')); // infers to `foo`.
+  templateLiteral.addInterpolatedPosition(z.null()); // infers to `null`.
+  templateLiteral.addInterpolatedPosition(z.undefined()); // infers to `undefined`.
+  templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
+  ```
+
+  Any Zod type (or union) with an underlying type of string, number, boolean, null, undefined or bigint can be used as an interpolated position (template literals included!). You can use additional built-in runtime validations (refinements excluded) in each of these types and the template literal builder will do its best to
+  support them when parsing.
+
+### Examples
+
+MongoDB connection string:
+
+```ts
+const connectionString = z
+  .templateLiteral()
+  .addLiteral("mongodb://")
+  .addInterpolatedPosition(
+    z
+      .templateLiteral()
+      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addLiteral(":")
+      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addLiteral("@")
+      .optional()
+  )
+  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addLiteral(":")
+  .addInterpolatedPosition(
+    z.number().finite().int().positive().describe("port")
+  )
+  .addInterpolatedPosition(
+    z
+      .templateLiteral()
+      .addLiteral("/")
+      .addInterpolatedPosition(
+        z.string().min(1).optional().describe("defaultauthdb")
+      )
+      .addInterpolatedPosition(
+        z
+          .templateLiteral()
+          .addLiteral("?")
+          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .optional()
+          .describe("options")
+      )
+      .optional()
+  );
+  // infers to:
+  // | `mongodb://${string}:${number}`
+  // | `mongodb://${string}:${number}/${string}`
+  // | `mongodb://${string}:${number}/${string}?${string}`
+  // | `mongodb://${string}:${string}@${string}:${number}`
+  // | `mongodb://${string}:${string}@${string}:${number}/${string}`
+  // | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
+```
 
 ## Preprocess
 

From b601918b96222a8607fc8fb4518ee20670f5bf10 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 13 Jan 2023 19:25:49 +0200
Subject: [PATCH 14/40] add a simpler example @ ZodTemplateLiteral docs.

---
 README.md          | 27 +++++++++++++++++++++++++--
 deno/lib/README.md | 27 +++++++++++++++++++++++++--
 2 files changed, 50 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 5152cc148..168384c4d 100644
--- a/README.md
+++ b/README.md
@@ -1671,11 +1671,34 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
   templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
   ```
 
-  Any Zod type (or union) with an underlying type of string, number, boolean, null, undefined or bigint can be used as an interpolated position (template literals included!). You can use additional built-in runtime validations (refinements excluded) in each of these types and the template literal builder will do its best to
-  support them when parsing.
+  Any Zod type (or union) with an underlying type of string, number, boolean, null, 
+  undefined or bigint can be used as an interpolated position (template literals 
+  included!). You can use additional built-in runtime validations (refinements 
+  excluded) in each of these types and the template literal builder will do its 
+  best to support them when parsing.
 
 ### Examples
 
+URL:
+
+```ts
+const url = z
+  .templateLiteral()
+  .addLiteral("https://")
+  .addInterpolatedPosition(z.string().min(1))
+  .addLiteral(".")
+  .addInterpolatedPosition(z.enum(["com", "net"]));
+// infers to `https://${string}.com` | `https://${string}.net`.
+
+url.parse("https://google.com"); // passes
+url.parse("https://google.net"); // passes
+url.parse('http://google.com'); // throws
+url.parse('https://.com'); // throws
+url.parse('https://google'); // throws
+url.parse('https://google.'); // throws
+url.parse('https://google.gov'); // throws
+```
+
 MongoDB connection string:
 
 ```ts
diff --git a/deno/lib/README.md b/deno/lib/README.md
index 5152cc148..168384c4d 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1671,11 +1671,34 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
   templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
   ```
 
-  Any Zod type (or union) with an underlying type of string, number, boolean, null, undefined or bigint can be used as an interpolated position (template literals included!). You can use additional built-in runtime validations (refinements excluded) in each of these types and the template literal builder will do its best to
-  support them when parsing.
+  Any Zod type (or union) with an underlying type of string, number, boolean, null, 
+  undefined or bigint can be used as an interpolated position (template literals 
+  included!). You can use additional built-in runtime validations (refinements 
+  excluded) in each of these types and the template literal builder will do its 
+  best to support them when parsing.
 
 ### Examples
 
+URL:
+
+```ts
+const url = z
+  .templateLiteral()
+  .addLiteral("https://")
+  .addInterpolatedPosition(z.string().min(1))
+  .addLiteral(".")
+  .addInterpolatedPosition(z.enum(["com", "net"]));
+// infers to `https://${string}.com` | `https://${string}.net`.
+
+url.parse("https://google.com"); // passes
+url.parse("https://google.net"); // passes
+url.parse('http://google.com'); // throws
+url.parse('https://.com'); // throws
+url.parse('https://google'); // throws
+url.parse('https://google.'); // throws
+url.parse('https://google.gov'); // throws
+```
+
 MongoDB connection string:
 
 ```ts

From 48242c0ee557691f8ad04116af5762cf187f1018 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 13 Jan 2023 19:30:53 +0200
Subject: [PATCH 15/40] add regex limitations remark.

---
 README.md          | 2 +-
 deno/lib/README.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 168384c4d..8009f6b90 100644
--- a/README.md
+++ b/README.md
@@ -1675,7 +1675,7 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
   undefined or bigint can be used as an interpolated position (template literals 
   included!). You can use additional built-in runtime validations (refinements 
   excluded) in each of these types and the template literal builder will do its 
-  best to support them when parsing.
+  best (within the limitations of regular expressions) to support them when parsing.
 
 ### Examples
 
diff --git a/deno/lib/README.md b/deno/lib/README.md
index 168384c4d..8009f6b90 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1675,7 +1675,7 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
   undefined or bigint can be used as an interpolated position (template literals 
   included!). You can use additional built-in runtime validations (refinements 
   excluded) in each of these types and the template literal builder will do its 
-  best to support them when parsing.
+  best (within the limitations of regular expressions) to support them when parsing.
 
 ### Examples
 

From 6c5e1b02bf00613d8733797ea0c9dbf5cb9fcbfc Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 19:29:13 +0200
Subject: [PATCH 16/40] allow coercion to ZodTemplateLiteral.

---
 deno/lib/types.ts | 54 +++++++++++++++++++++++------------------------
 src/types.ts      | 15 ++++++++++++-
 2 files changed, 40 insertions(+), 29 deletions(-)

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 686ea4314..0cc1d84c8 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4318,6 +4318,7 @@ type appendToTemplateLiteral<
   : never;
 
 export interface ZodTemplateLiteralDef extends ZodTypeDef {
+  coerce: boolean;
   parts: readonly (
     | TemplateLiteralPrimitive
     | TemplateLiteralInterpolatedPosition
@@ -4343,6 +4344,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   }
 
   _parse(input: ParseInput): ParseReturnType<Template> {
+    if (this._def.coerce) {
+      input.data = String(input.data);
+    }
+
     const parsedType = this._getType(input);
 
     if (parsedType !== ZodParsedType.string) {
@@ -4558,38 +4563,35 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   }
 
   protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
-    let isNegative = true,
-      isPositive = true,
+    let canBeNegative = true,
+      canBePositive = true,
       min = -Infinity,
       max = Infinity,
-      isZero = true,
-      isFinite = false,
+      canBeZero = true,
       isInt = false,
       acc = "";
 
     for (const ch of part._def.checks) {
-      if (ch.kind === "finite") {
-        isFinite = true;
-      } else if (ch.kind === "int") {
+      if (ch.kind === "int") {
         isInt = true;
       } else if (ch.kind === "max") {
         max = Math.min(max, ch.value);
 
         if (ch.value <= 0) {
-          isPositive = false;
+          canBePositive = false;
 
           if (ch.value === 0 && !ch.inclusive) {
-            isZero = false;
+            canBeZero = false;
           }
         }
       } else if (ch.kind === "min") {
         min = Math.max(min, ch.value);
 
         if (ch.value >= 0) {
-          isNegative = false;
+          canBeNegative = false;
 
           if (ch.value === 0 && !ch.inclusive) {
-            isZero = false;
+            canBeZero = false;
           }
         }
       } else if (ch.kind === "multipleOf") {
@@ -4599,25 +4601,17 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }
     }
 
-    if (Number.isFinite(min) && Number.isFinite(max)) {
-      isFinite = true;
-    }
-
-    if (isNegative) {
+    if (canBeNegative) {
       acc = `${acc}\\-`;
 
-      if (isPositive) {
+      if (canBePositive) {
         acc = `${acc}?`;
       }
-    } else if (!isPositive) {
+    } else if (!canBePositive) {
       return "0+";
     }
 
-    if (!isFinite) {
-      acc = `${acc}(Infinity|(`;
-    }
-
-    if (!isZero) {
+    if (!canBeZero) {
       if (!isInt) {
         acc = `${acc}((\\d*[1-9]\\d*(\\.\\d+)?)|(\\d+\\.\\d*[1-9]\\d*))`;
       } else {
@@ -4629,10 +4623,6 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       acc = `${acc}\\d+(\\.\\d+)?`;
     }
 
-    if (!isFinite) {
-      acc = `${acc}))`;
-    }
-
     return acc;
   }
 
@@ -4651,9 +4641,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     );
   }
 
-  static create = (params?: RawCreateParams): ZodTemplateLiteral => {
+  static create = (
+    params?: RawCreateParams & { coerce?: true }
+  ): ZodTemplateLiteral => {
     return new ZodTemplateLiteral({
       ...processCreateParams(params),
+      coerce: params?.coerce ?? false,
       parts: [],
       regexString: "^$",
       typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral,
@@ -4821,6 +4814,11 @@ export const coerce = {
     ZodBigInt.create({ ...arg, coerce: true })) as typeof ZodBigInt["create"],
   date: ((arg) =>
     ZodDate.create({ ...arg, coerce: true })) as typeof ZodDate["create"],
+  templateLiteral: ((arg) =>
+    ZodTemplateLiteral.create({
+      ...arg,
+      coerce: true,
+    })) as typeof ZodTemplateLiteral["create"],
 };
 
 export {
diff --git a/src/types.ts b/src/types.ts
index d1ac36789..d42b0a1b9 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4318,6 +4318,7 @@ type appendToTemplateLiteral<
   : never;
 
 export interface ZodTemplateLiteralDef extends ZodTypeDef {
+  coerce: boolean;
   parts: readonly (
     | TemplateLiteralPrimitive
     | TemplateLiteralInterpolatedPosition
@@ -4343,6 +4344,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   }
 
   _parse(input: ParseInput): ParseReturnType<Template> {
+    if (this._def.coerce) {
+      input.data = String(input.data);
+    }
+
     const parsedType = this._getType(input);
 
     if (parsedType !== ZodParsedType.string) {
@@ -4651,9 +4656,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     );
   }
 
-  static create = (params?: RawCreateParams): ZodTemplateLiteral => {
+  static create = (
+    params?: RawCreateParams & { coerce?: true }
+  ): ZodTemplateLiteral => {
     return new ZodTemplateLiteral({
       ...processCreateParams(params),
+      coerce: params?.coerce ?? false,
       parts: [],
       regexString: "^$",
       typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral,
@@ -4821,6 +4829,11 @@ export const coerce = {
     ZodBigInt.create({ ...arg, coerce: true })) as typeof ZodBigInt["create"],
   date: ((arg) =>
     ZodDate.create({ ...arg, coerce: true })) as typeof ZodDate["create"],
+  templateLiteral: ((arg) =>
+    ZodTemplateLiteral.create({
+      ...arg,
+      coerce: true,
+    })) as typeof ZodTemplateLiteral["create"],
 };
 
 export {

From 588922958c93986bd6708a0b2f7c7431e374d000 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 20:17:47 +0200
Subject: [PATCH 17/40] minor readability pass on number stuff @
 ZodTemplateLiteral.

---
 deno/lib/__tests__/template-literal.test.ts | 24 ++++++++++++++++++--
 deno/lib/types.ts                           | 25 +++++++++++++++++++--
 src/types.ts                                | 22 +++++++++---------
 3 files changed, 56 insertions(+), 15 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 6a7bda58a..82e7012e8 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -108,6 +108,10 @@ const stringMin5Max10 = z
 const stringStartsWithMax5 = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().startsWith("hello").max(5));
+const brandedString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().min(1).brand("myBrand"));
+const anything = z.templateLiteral().addInterpolatedPosition(z.any());
 
 const url = z
   .templateLiteral()
@@ -198,6 +202,8 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof stringLen5>, string>(true);
   util.assertEqual<z.infer<typeof stringMin5Max10>, string>(true);
   util.assertEqual<z.infer<typeof stringStartsWithMax5>, string>(true);
+  util.assertEqual<z.infer<typeof brandedString>, string>(true);
+  util.assertEqual<z.infer<typeof anything>, `${any}`>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -230,8 +236,6 @@ test("template literal unsupported args", () => {
       z.union([z.object({}), z.string()])
     )
   ).toThrow();
-  // @ts-expect-error
-  expect(() => z.templateLiteral().addInterpolatedPosition(z.any())).toThrow();
   expect(() =>
     // @ts-expect-error
     z.templateLiteral().addInterpolatedPosition(z.never())
@@ -314,6 +318,20 @@ test("template literal unsupported args", () => {
     // @ts-expect-error
     z.templateLiteral().addInterpolatedPosition(z.unknown())
   ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.void())
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.lazy(() => z.string()))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.object({}).brand("brand")
+    )
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
@@ -399,6 +417,8 @@ test("template literal parsing - success - basic cases", () => {
   stringLen5.parse("hello");
   stringMin5Max10.parse("hello worl");
   stringStartsWithMax5.parse("hello");
+  anything.parse("");
+  anything.parse("everything");
 });
 
 test("template literal parsing - failure - basic cases", () => {
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 0cc1d84c8..44208f1d7 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4311,6 +4311,8 @@ type appendToTemplateLiteral<
   ? `${Template}${Suffix}`
   : Suffix extends ZodOptional<infer UnderlyingType>
   ? Template | appendToTemplateLiteral<Template, UnderlyingType>
+  : Suffix extends ZodBranded<infer UnderlyingType, any>
+  ? appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
   ? Output extends TemplateLiteralPrimitive | bigint
     ? `${Template}${Output}`
@@ -4332,7 +4334,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   ZodTemplateLiteralDef
 > {
   addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
-    type: Exclude<I, ZodNever | ZodAny | ZodNaN | ZodPipeline<any, any>>
+    type: Exclude<I, ZodNever | ZodNaN | ZodPipeline<any, any> | ZodLazy<any>>
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
     return this._addPart(type) as any;
   }
@@ -4456,6 +4458,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }`;
     }
 
+    if (part instanceof ZodBranded) {
+      return this._transformPartToRegexString(part.unwrap());
+    }
+
     if (part instanceof ZodNull) {
       return "null";
     }
@@ -4568,11 +4574,14 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       min = -Infinity,
       max = Infinity,
       canBeZero = true,
+      isFinite = false,
       isInt = false,
       acc = "";
 
     for (const ch of part._def.checks) {
-      if (ch.kind === "int") {
+      if (ch.kind === "finite") {
+        isFinite = true;
+      } else if (ch.kind === "int") {
         isInt = true;
       } else if (ch.kind === "max") {
         max = Math.min(max, ch.value);
@@ -4601,6 +4610,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }
     }
 
+    if (Number.isFinite(min) && Number.isFinite(max)) {
+      isFinite = true;
+    }
+
     if (canBeNegative) {
       acc = `${acc}\\-`;
 
@@ -4611,6 +4624,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return "0+";
     }
 
+    if (!isFinite) {
+      acc = `${acc}(Infinity|(`;
+    }
+
     if (!canBeZero) {
       if (!isInt) {
         acc = `${acc}((\\d*[1-9]\\d*(\\.\\d+)?)|(\\d+\\.\\d*[1-9]\\d*))`;
@@ -4623,6 +4640,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       acc = `${acc}\\d+(\\.\\d+)?`;
     }
 
+    if (!isFinite) {
+      acc = `${acc}))`;
+    }
+
     return acc;
   }
 
diff --git a/src/types.ts b/src/types.ts
index d42b0a1b9..16d37ac2f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4563,11 +4563,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   }
 
   protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
-    let isNegative = true,
-      isPositive = true,
+    let canBeNegative = true,
+      canBePositive = true,
       min = -Infinity,
       max = Infinity,
-      isZero = true,
+      canBeZero = true,
       isFinite = false,
       isInt = false,
       acc = "";
@@ -4581,20 +4581,20 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         max = Math.min(max, ch.value);
 
         if (ch.value <= 0) {
-          isPositive = false;
+          canBePositive = false;
 
           if (ch.value === 0 && !ch.inclusive) {
-            isZero = false;
+            canBeZero = false;
           }
         }
       } else if (ch.kind === "min") {
         min = Math.max(min, ch.value);
 
         if (ch.value >= 0) {
-          isNegative = false;
+          canBeNegative = false;
 
           if (ch.value === 0 && !ch.inclusive) {
-            isZero = false;
+            canBeZero = false;
           }
         }
       } else if (ch.kind === "multipleOf") {
@@ -4608,13 +4608,13 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       isFinite = true;
     }
 
-    if (isNegative) {
+    if (canBeNegative) {
       acc = `${acc}\\-`;
 
-      if (isPositive) {
+      if (canBePositive) {
         acc = `${acc}?`;
       }
-    } else if (!isPositive) {
+    } else if (!canBePositive) {
       return "0+";
     }
 
@@ -4622,7 +4622,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       acc = `${acc}(Infinity|(`;
     }
 
-    if (!isZero) {
+    if (!canBeZero) {
       if (!isInt) {
         acc = `${acc}((\\d*[1-9]\\d*(\\.\\d+)?)|(\\d+\\.\\d*[1-9]\\d*))`;
       } else {

From 5b3b825beb982cca3a2740d2e8dc711ec439d84d Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 20:20:39 +0200
Subject: [PATCH 18/40] add ZodBranded support @ ZodTemplateLiteral.

---
 deno/lib/__tests__/template-literal.test.ts |  2 ++
 src/__tests__/template-literal.test.ts      | 12 ++++++++++++
 src/types.ts                                |  6 ++++++
 3 files changed, 20 insertions(+)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 82e7012e8..618b0d44b 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -417,6 +417,7 @@ test("template literal parsing - success - basic cases", () => {
   stringLen5.parse("hello");
   stringMin5Max10.parse("hello worl");
   stringStartsWithMax5.parse("hello");
+  brandedString.parse("branded string");
   anything.parse("");
   anything.parse("everything");
 });
@@ -526,6 +527,7 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => stringMin5Max10.parse("12345678901")).toThrow();
   expect(() => stringStartsWithMax5.parse("hello1")).toThrow();
   expect(() => stringStartsWithMax5.parse("1hell")).toThrow();
+  expect(() => brandedString.parse("")).toThrow();
 });
 
 test("template literal parsing - success - complex cases", () => {
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index 12e182915..f51aaaf64 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -107,6 +107,9 @@ const stringMin5Max10 = z
 const stringStartsWithMax5 = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().startsWith("hello").max(5));
+const brandedString = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().min(1).brand("myBrand"));
 
 const url = z
   .templateLiteral()
@@ -197,6 +200,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof stringLen5>, string>(true);
   util.assertEqual<z.infer<typeof stringMin5Max10>, string>(true);
   util.assertEqual<z.infer<typeof stringStartsWithMax5>, string>(true);
+  util.assertEqual<z.infer<typeof brandedString>, string>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -313,6 +317,12 @@ test("template literal unsupported args", () => {
     // @ts-expect-error
     z.templateLiteral().addInterpolatedPosition(z.unknown())
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(
+      // @ts-expect-error
+      z.object({}).brand("brand")
+    )
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
@@ -398,6 +408,7 @@ test("template literal parsing - success - basic cases", () => {
   stringLen5.parse("hello");
   stringMin5Max10.parse("hello worl");
   stringStartsWithMax5.parse("hello");
+  brandedString.parse("branded string");
 });
 
 test("template literal parsing - failure - basic cases", () => {
@@ -505,6 +516,7 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => stringMin5Max10.parse("12345678901")).toThrow();
   expect(() => stringStartsWithMax5.parse("hello1")).toThrow();
   expect(() => stringStartsWithMax5.parse("1hell")).toThrow();
+  expect(() => brandedString.parse("")).toThrow();
 });
 
 test("template literal parsing - success - complex cases", () => {
diff --git a/src/types.ts b/src/types.ts
index 16d37ac2f..4da977ee0 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4311,6 +4311,8 @@ type appendToTemplateLiteral<
   ? `${Template}${Suffix}`
   : Suffix extends ZodOptional<infer UnderlyingType>
   ? Template | appendToTemplateLiteral<Template, UnderlyingType>
+  : Suffix extends ZodBranded<infer UnderlyingType, any>
+  ? appendToTemplateLiteral<Template, UnderlyingType>
   : Suffix extends ZodType<infer Output, any, any>
   ? Output extends TemplateLiteralPrimitive | bigint
     ? `${Template}${Output}`
@@ -4456,6 +4458,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       }`;
     }
 
+    if (part instanceof ZodBranded) {
+      return this._transformPartToRegexString(part.unwrap());
+    }
+
     if (part instanceof ZodNull) {
       return "null";
     }

From c5ff237c340b7c5e9ab37d28fc8942fafcf56923 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 20:50:02 +0200
Subject: [PATCH 19/40] support ZodAny @ ZodTemplateLiteral.

---
 src/__tests__/template-literal.test.ts | 14 ++++++++++++--
 src/types.ts                           |  2 +-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index f51aaaf64..add4aca65 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -110,6 +110,7 @@ const stringStartsWithMax5 = z
 const brandedString = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().min(1).brand("myBrand"));
+const anything = z.templateLiteral().addInterpolatedPosition(z.any());
 
 const url = z
   .templateLiteral()
@@ -201,6 +202,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof stringMin5Max10>, string>(true);
   util.assertEqual<z.infer<typeof stringStartsWithMax5>, string>(true);
   util.assertEqual<z.infer<typeof brandedString>, string>(true);
+  util.assertEqual<z.infer<typeof anything>, `${any}`>(true);
 
   util.assertEqual<
     z.infer<typeof url>,
@@ -233,8 +235,6 @@ test("template literal unsupported args", () => {
       z.union([z.object({}), z.string()])
     )
   ).toThrow();
-  // @ts-expect-error
-  expect(() => z.templateLiteral().addInterpolatedPosition(z.any())).toThrow();
   expect(() =>
     // @ts-expect-error
     z.templateLiteral().addInterpolatedPosition(z.never())
@@ -317,6 +317,14 @@ test("template literal unsupported args", () => {
     // @ts-expect-error
     z.templateLiteral().addInterpolatedPosition(z.unknown())
   ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.void())
+  ).toThrow();
+  expect(() =>
+    // @ts-expect-error
+    z.templateLiteral().addInterpolatedPosition(z.lazy(() => z.string()))
+  ).toThrow();
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(
       // @ts-expect-error
@@ -409,6 +417,8 @@ test("template literal parsing - success - basic cases", () => {
   stringMin5Max10.parse("hello worl");
   stringStartsWithMax5.parse("hello");
   brandedString.parse("branded string");
+  anything.parse("");
+  anything.parse("everything");
 });
 
 test("template literal parsing - failure - basic cases", () => {
diff --git a/src/types.ts b/src/types.ts
index 4da977ee0..a778de0cf 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4334,7 +4334,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   ZodTemplateLiteralDef
 > {
   addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
-    type: Exclude<I, ZodNever | ZodAny | ZodNaN | ZodPipeline<any, any>>
+    type: Exclude<I, ZodNever | ZodNaN | ZodPipeline<any, any> | ZodLazy<any>>
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
     return this._addPart(type) as any;
   }

From cc0b366e9e1f3778412df479a569e2756b517514 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 21:25:08 +0200
Subject: [PATCH 20/40] support ZodAny @ ZodTemplateLiteral.

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

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 44208f1d7..f6e5d7383 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4462,6 +4462,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return this._transformPartToRegexString(part.unwrap());
     }
 
+    if (part instanceof ZodAny) {
+      return ".*";
+    }
+
     if (part instanceof ZodNull) {
       return "null";
     }
diff --git a/src/types.ts b/src/types.ts
index a778de0cf..e2173a58b 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4462,6 +4462,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return this._transformPartToRegexString(part.unwrap());
     }
 
+    if (part instanceof ZodAny) {
+      return ".*";
+    }
+
     if (part instanceof ZodNull) {
       return "null";
     }

From 762d5b68f92c1fa8f55932daf61afb5899924f4f Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 21:27:46 +0200
Subject: [PATCH 21/40] minor README.md changes.

---
 README.md          | 3 ++-
 deno/lib/README.md | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 8009f6b90..ec9633998 100644
--- a/README.md
+++ b/README.md
@@ -1662,13 +1662,14 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add interpolated positions to an existing template literal:
 
   ```ts
-  templateLiteral.addInterpolatedPosition(z.string()); // infers to string.
+  templateLiteral.addInterpolatedPosition(z.string()); // infers to `${string}`.
   templateLiteral.addInterpolatedPosition(z.number()); // infers to `${number}`.
   templateLiteral.addInterpolatedPosition(z.boolean()); // infers to `true` | `false`.
   templateLiteral.addInterpolatedPosition(z.literal('foo')); // infers to `foo`.
   templateLiteral.addInterpolatedPosition(z.null()); // infers to `null`.
   templateLiteral.addInterpolatedPosition(z.undefined()); // infers to `undefined`.
   templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
+  templateLiteral.addInterpolatedPosition(z.any()); // infers to `${any}`.
   ```
 
   Any Zod type (or union) with an underlying type of string, number, boolean, null, 
diff --git a/deno/lib/README.md b/deno/lib/README.md
index 8009f6b90..ec9633998 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1662,13 +1662,14 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add interpolated positions to an existing template literal:
 
   ```ts
-  templateLiteral.addInterpolatedPosition(z.string()); // infers to string.
+  templateLiteral.addInterpolatedPosition(z.string()); // infers to `${string}`.
   templateLiteral.addInterpolatedPosition(z.number()); // infers to `${number}`.
   templateLiteral.addInterpolatedPosition(z.boolean()); // infers to `true` | `false`.
   templateLiteral.addInterpolatedPosition(z.literal('foo')); // infers to `foo`.
   templateLiteral.addInterpolatedPosition(z.null()); // infers to `null`.
   templateLiteral.addInterpolatedPosition(z.undefined()); // infers to `undefined`.
   templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
+  templateLiteral.addInterpolatedPosition(z.any()); // infers to `${any}`.
   ```
 
   Any Zod type (or union) with an underlying type of string, number, boolean, null, 

From 7b831176583544a93ead4de9538d3bd7576ab174 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Sat, 14 Jan 2023 23:40:32 +0200
Subject: [PATCH 22/40] add ZodTemplateLiteral coerce test.

---
 README.md                         | 12 ++++++++++++
 deno/lib/README.md                | 12 ++++++++++++
 deno/lib/__tests__/coerce.test.ts | 20 ++++++++++++++++++++
 src/__tests__/coerce.test.ts      | 20 ++++++++++++++++++++
 4 files changed, 64 insertions(+)

diff --git a/README.md b/README.md
index ec9633998..20047b7ce 100644
--- a/README.md
+++ b/README.md
@@ -1700,6 +1700,18 @@ url.parse('https://google.'); // throws
 url.parse('https://google.gov'); // throws
 ```
 
+Measurement:
+
+```ts
+const schema = z.coerce
+    .templateLiteral()
+    .addInterpolatedPosition(z.number().finite())
+    .addInterpolatedPosition(
+      z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+    );
+// infers to `${number}` | `${number}px` | `${number}em` | `${number}rem` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax
+```
+
 MongoDB connection string:
 
 ```ts
diff --git a/deno/lib/README.md b/deno/lib/README.md
index ec9633998..20047b7ce 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1700,6 +1700,18 @@ url.parse('https://google.'); // throws
 url.parse('https://google.gov'); // throws
 ```
 
+Measurement:
+
+```ts
+const schema = z.coerce
+    .templateLiteral()
+    .addInterpolatedPosition(z.number().finite())
+    .addInterpolatedPosition(
+      z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+    );
+// infers to `${number}` | `${number}px` | `${number}em` | `${number}rem` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax
+```
+
 MongoDB connection string:
 
 ```ts
diff --git a/deno/lib/__tests__/coerce.test.ts b/deno/lib/__tests__/coerce.test.ts
index 6acc5249b..6d6a9bb2f 100644
--- a/deno/lib/__tests__/coerce.test.ts
+++ b/deno/lib/__tests__/coerce.test.ts
@@ -133,3 +133,23 @@ test("date coercion", () => {
   expect(() => schema.parse([])).toThrow; // z.ZodError
   expect(schema.parse(new Date())).toBeInstanceOf(Date);
 });
+
+test("template literal coercion", () => {
+  const schema = z.coerce
+    .templateLiteral()
+    .addInterpolatedPosition(z.number().finite())
+    .addInterpolatedPosition(
+      z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+    );
+  expect(schema.parse(300)).toEqual("300");
+  expect(schema.parse(BigInt(300))).toEqual("300");
+  expect(schema.parse("300")).toEqual("300");
+  expect(schema.parse("300px")).toEqual("300px");
+  expect(schema.parse("300em")).toEqual("300em");
+  expect(schema.parse("300rem")).toEqual("300rem");
+  expect(schema.parse("300vh")).toEqual("300vh");
+  expect(schema.parse("300vw")).toEqual("300vw");
+  expect(schema.parse("300vmin")).toEqual("300vmin");
+  expect(schema.parse("300vmax")).toEqual("300vmax");
+  expect(schema.parse(["300px"])).toEqual("300px");
+});
diff --git a/src/__tests__/coerce.test.ts b/src/__tests__/coerce.test.ts
index 79d91d1fc..addba645b 100644
--- a/src/__tests__/coerce.test.ts
+++ b/src/__tests__/coerce.test.ts
@@ -132,3 +132,23 @@ test("date coercion", () => {
   expect(() => schema.parse([])).toThrow; // z.ZodError
   expect(schema.parse(new Date())).toBeInstanceOf(Date);
 });
+
+test("template literal coercion", () => {
+  const schema = z.coerce
+    .templateLiteral()
+    .addInterpolatedPosition(z.number().finite())
+    .addInterpolatedPosition(
+      z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+    );
+  expect(schema.parse(300)).toEqual("300");
+  expect(schema.parse(BigInt(300))).toEqual("300");
+  expect(schema.parse("300")).toEqual("300");
+  expect(schema.parse("300px")).toEqual("300px");
+  expect(schema.parse("300em")).toEqual("300em");
+  expect(schema.parse("300rem")).toEqual("300rem");
+  expect(schema.parse("300vh")).toEqual("300vh");
+  expect(schema.parse("300vw")).toEqual("300vw");
+  expect(schema.parse("300vmin")).toEqual("300vmin");
+  expect(schema.parse("300vmax")).toEqual("300vmax");
+  expect(schema.parse(["300px"])).toEqual("300px");
+});

From 153157acd3cb11964a90543af8a132572074d45c Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Thu, 19 Jan 2023 23:01:51 +0200
Subject: [PATCH 23/40] add ZodTemplateLiteral custom errors for unsupported
 stuff.

---
 deno/lib/types.ts | 57 +++++++++++++++++++++++++++++++++++------------
 src/types.ts      | 32 ++++++++++++++++++++++++++
 2 files changed, 75 insertions(+), 14 deletions(-)

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index f6e5d7383..4018a5071 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4329,6 +4329,38 @@ export interface ZodTemplateLiteralDef extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
 
+export class ZodTemplateLiteralUnsupportedTypeError extends Error {
+  constructor() {
+    super("Unsupported zod type!");
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedTypeError";
+  }
+}
+
+export class ZodTemplateLiteralUnsupportedCheckError extends Error {
+  constructor(typeKind: ZodFirstPartyTypeKind, check: string) {
+    super(
+      `${typeKind}'s ${check} check is not supported in template literals!`
+    );
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedCheckError";
+  }
+}
+
 export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef
@@ -4474,9 +4506,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return "undefined";
     }
 
-    throw new Error(
-      "Zod error: Unsupported ZodTemplateLiteral argument! Please submit an issue at https://github.com/colinhacks/zod/issues"
-    );
+    throw new ZodTemplateLiteralUnsupportedTypeError();
   }
 
   protected _transformZodStringPartToRegexString(part: ZodString): string {
@@ -4504,13 +4534,6 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         return this._unwrapRegexString(ch.regex.source);
       }
 
-      if (ch.kind === "url") {
-        // FIXME: we use native URL for validation, so cannot regex test in such cases.
-        throw new Error(
-          "Zod error: ZodTemplateLiteral does not support use of ZodString with url check!"
-        );
-      }
-
       if (ch.kind === "uuid") {
         return this._unwrapRegexString(uuidRegex.source);
       }
@@ -4525,6 +4548,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         minLength = Math.max(minLength, ch.value);
       } else if (ch.kind === "startsWith") {
         startsWith = ch.value;
+      } else {
+        throw new ZodTemplateLiteralUnsupportedCheckError(
+          ZodFirstPartyTypeKind.ZodString,
+          ch.kind
+        );
       }
     }
 
@@ -4607,10 +4635,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
             canBeZero = false;
           }
         }
-      } else if (ch.kind === "multipleOf") {
-        if (util.isInteger(ch.value)) {
-          isInt = true;
-        }
+      } else {
+        throw new ZodTemplateLiteralUnsupportedCheckError(
+          ZodFirstPartyTypeKind.ZodNumber,
+          ch.kind
+        );
       }
     }
 
diff --git a/src/types.ts b/src/types.ts
index e2173a58b..9ce020a99 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4329,6 +4329,38 @@ export interface ZodTemplateLiteralDef extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
 
+export class ZodTemplateLiteralUnsupportedTypeError extends Error {
+  constructor() {
+    super("Unsupported zod type!");
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedTypeError";
+  }
+}
+
+export class ZodTemplateLiteralUnsupportedCheckError extends Error {
+  constructor(typeKind: ZodFirstPartyTypeKind, check: string) {
+    super(
+      `${typeKind}'s ${check} check is not supported in template literals!`
+    );
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedCheckError";
+  }
+}
+
 export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef

From e869080f2677b0a9df12dd75e646705fecb65aa4 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Thu, 19 Jan 2023 23:04:14 +0200
Subject: [PATCH 24/40] add ZodTemplateLiteral custom errors for unsupported
 stuff. pt. 2.

---
 src/types.ts | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/types.ts b/src/types.ts
index 9ce020a99..ff3ab4646 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4506,9 +4506,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       return "undefined";
     }
 
-    throw new Error(
-      "Zod error: Unsupported ZodTemplateLiteral argument! Please submit an issue at https://github.com/colinhacks/zod/issues"
-    );
+    throw new ZodTemplateLiteralUnsupportedTypeError();
   }
 
   protected _transformZodStringPartToRegexString(part: ZodString): string {
@@ -4536,13 +4534,6 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         return this._unwrapRegexString(ch.regex.source);
       }
 
-      if (ch.kind === "url") {
-        // FIXME: we use native URL for validation, so cannot regex test in such cases.
-        throw new Error(
-          "Zod error: ZodTemplateLiteral does not support use of ZodString with url check!"
-        );
-      }
-
       if (ch.kind === "uuid") {
         return this._unwrapRegexString(uuidRegex.source);
       }
@@ -4557,6 +4548,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         minLength = Math.max(minLength, ch.value);
       } else if (ch.kind === "startsWith") {
         startsWith = ch.value;
+      } else {
+        throw new ZodTemplateLiteralUnsupportedCheckError(
+          ZodFirstPartyTypeKind.ZodString,
+          ch.kind
+        );
       }
     }
 

From 859b6231304082bc79e8da5ef4ada931aa2acf87 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Thu, 19 Jan 2023 23:16:42 +0200
Subject: [PATCH 25/40] add ZodTemplateLiteral custom errors for unsupported
 stuff pt. 3.

Co-authored-by: Max Arturo <5713763+maxArturo@users.noreply.github.com>
---
 deno/lib/__tests__/template-literal.test.ts | 15 +++------------
 src/__tests__/template-literal.test.ts      | 15 +++------------
 src/types.ts                                |  9 +++++----
 3 files changed, 11 insertions(+), 28 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 618b0d44b..7ff4aec27 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -36,12 +36,6 @@ const anyNegativeNumber = z
 const anyPositiveNumber = z
   .templateLiteral()
   .addInterpolatedPosition(z.number().positive());
-const multipleOfTwo = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().multipleOf(2));
-const multipleOfPi = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().multipleOf(Math.PI));
 const zeroButInADumbWay = z
   .templateLiteral()
   .addInterpolatedPosition(z.number().nonnegative().nonpositive());
@@ -175,8 +169,6 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyNegativeNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyPositiveNumber>, `${number}`>(true);
-  util.assertEqual<z.infer<typeof multipleOfTwo>, `${number}`>(true);
-  util.assertEqual<z.infer<typeof multipleOfPi>, `${number}`>(true);
   util.assertEqual<z.infer<typeof zeroButInADumbWay>, `${number}`>(true);
   util.assertEqual<z.infer<typeof finiteButInADumbWay>, `${number}`>(true);
   util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
@@ -332,6 +324,9 @@ test("template literal unsupported args", () => {
       z.object({}).brand("brand")
     )
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
@@ -372,9 +367,6 @@ test("template literal parsing - success - basic cases", () => {
   anyPositiveNumber.parse("123");
   anyPositiveNumber.parse("1.23");
   anyPositiveNumber.parse("Infinity");
-  multipleOfTwo.parse("2");
-  multipleOfPi.parse("2");
-  multipleOfPi.parse("3.14");
   zeroButInADumbWay.parse("0");
   zeroButInADumbWay.parse("00000");
   finiteButInADumbWay.parse("5");
@@ -472,7 +464,6 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => anyPositiveNumber.parse("0")).toThrow();
   expect(() => anyPositiveNumber.parse("-1")).toThrow();
   expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
-  expect(() => multipleOfTwo.parse("3.14")).toThrow();
   expect(() => zeroButInADumbWay.parse("1")).toThrow();
   expect(() => zeroButInADumbWay.parse("-1")).toThrow();
   expect(() => finiteButInADumbWay.parse("Infinity")).toThrow();
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index add4aca65..c1ed922d4 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -35,12 +35,6 @@ const anyNegativeNumber = z
 const anyPositiveNumber = z
   .templateLiteral()
   .addInterpolatedPosition(z.number().positive());
-const multipleOfTwo = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().multipleOf(2));
-const multipleOfPi = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().multipleOf(Math.PI));
 const zeroButInADumbWay = z
   .templateLiteral()
   .addInterpolatedPosition(z.number().nonnegative().nonpositive());
@@ -174,8 +168,6 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof anyInt>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyNegativeNumber>, `${number}`>(true);
   util.assertEqual<z.infer<typeof anyPositiveNumber>, `${number}`>(true);
-  util.assertEqual<z.infer<typeof multipleOfTwo>, `${number}`>(true);
-  util.assertEqual<z.infer<typeof multipleOfPi>, `${number}`>(true);
   util.assertEqual<z.infer<typeof zeroButInADumbWay>, `${number}`>(true);
   util.assertEqual<z.infer<typeof finiteButInADumbWay>, `${number}`>(true);
   util.assertEqual<z.infer<typeof bool>, `true` | `false`>(true);
@@ -331,6 +323,9 @@ test("template literal unsupported args", () => {
       z.object({}).brand("brand")
     )
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
@@ -371,9 +366,6 @@ test("template literal parsing - success - basic cases", () => {
   anyPositiveNumber.parse("123");
   anyPositiveNumber.parse("1.23");
   anyPositiveNumber.parse("Infinity");
-  multipleOfTwo.parse("2");
-  multipleOfPi.parse("2");
-  multipleOfPi.parse("3.14");
   zeroButInADumbWay.parse("0");
   zeroButInADumbWay.parse("00000");
   finiteButInADumbWay.parse("5");
@@ -471,7 +463,6 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => anyPositiveNumber.parse("0")).toThrow();
   expect(() => anyPositiveNumber.parse("-1")).toThrow();
   expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
-  expect(() => multipleOfTwo.parse("3.14")).toThrow();
   expect(() => zeroButInADumbWay.parse("1")).toThrow();
   expect(() => zeroButInADumbWay.parse("-1")).toThrow();
   expect(() => finiteButInADumbWay.parse("Infinity")).toThrow();
diff --git a/src/types.ts b/src/types.ts
index ff3ab4646..1696b2bf8 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4635,10 +4635,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
             canBeZero = false;
           }
         }
-      } else if (ch.kind === "multipleOf") {
-        if (util.isInteger(ch.value)) {
-          isInt = true;
-        }
+      } else {
+        throw new ZodTemplateLiteralUnsupportedCheckError(
+          ZodFirstPartyTypeKind.ZodNumber,
+          ch.kind
+        );
       }
     }
 

From a58e4acbcd130deba966ac4f17f0b948cf5b3f32 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Thu, 19 Jan 2023 23:40:39 +0200
Subject: [PATCH 26/40] use official MDN way of escaping for regex.

Co-authored-by: Max Arturo <5713763+maxArturo@users.noreply.github.com>
---
 deno/lib/types.ts | 13 +++++--------
 src/types.ts      | 13 +++++--------
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 4018a5071..6ff89b184 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4433,11 +4433,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
     if (!(part instanceof ZodType)) {
-      return this._getEscapedStringForRegex(part);
+      return this._escapeRegExp(part);
     }
 
     if (part instanceof ZodLiteral) {
-      return this._getEscapedStringForRegex(part._def.value);
+      return this._escapeRegExp(part._def.value);
     }
 
     if (part instanceof ZodString) {
@@ -4450,7 +4450,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
           ? part._def.values
           : util.getValidEnumValues(part._def.values);
 
-      return `(${values.map(this._getEscapedStringForRegex).join("|")})`;
+      return `(${values.map(this._escapeRegExp).join("|")})`;
     }
 
     if (part instanceof ZodUnion) {
@@ -4684,15 +4684,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return regexString.replace(/(^\^)|(\$$)/g, "");
   }
 
-  protected _getEscapedStringForRegex(str: unknown): string {
+  protected _escapeRegExp(str: unknown): string {
     if (typeof str !== "string") {
       str = `${str}`;
     }
 
-    return (str as string).replace(
-      /(\(|\)|\[|\]|\{|\}|\.|\\|\/|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/g,
-      "\\$1"
-    );
+    return (str as string).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
 
   static create = (
diff --git a/src/types.ts b/src/types.ts
index 1696b2bf8..3a3b1f3c5 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4433,11 +4433,11 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
     if (!(part instanceof ZodType)) {
-      return this._getEscapedStringForRegex(part);
+      return this._escapeRegExp(part);
     }
 
     if (part instanceof ZodLiteral) {
-      return this._getEscapedStringForRegex(part._def.value);
+      return this._escapeRegExp(part._def.value);
     }
 
     if (part instanceof ZodString) {
@@ -4450,7 +4450,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
           ? part._def.values
           : util.getValidEnumValues(part._def.values);
 
-      return `(${values.map(this._getEscapedStringForRegex).join("|")})`;
+      return `(${values.map(this._escapeRegExp).join("|")})`;
     }
 
     if (part instanceof ZodUnion) {
@@ -4684,15 +4684,12 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return regexString.replace(/(^\^)|(\$$)/g, "");
   }
 
-  protected _getEscapedStringForRegex(str: unknown): string {
+  protected _escapeRegExp(str: unknown): string {
     if (typeof str !== "string") {
       str = `${str}`;
     }
 
-    return (str as string).replace(
-      /(\(|\)|\[|\]|\{|\}|\.|\\|\/|\^|\-|\$|\?|\:|\=|\!|\*|\+|\,|\|)/g,
-      "\\$1"
-    );
+    return (str as string).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
 
   static create = (

From 703b8acff8ac3502497baddf832829b56bf7da9a Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 20 Jan 2023 01:14:19 +0200
Subject: [PATCH 27/40] explicitly state exponent notation is not supported @
 ZodTemplateLiteral

Co-authored-by: Max Arturo <5713763+maxArturo@users.noreply.github.com>
---
 deno/lib/__tests__/template-literal.test.ts | 22 +++++++++++++++++++++
 deno/lib/types.ts                           |  1 +
 src/__tests__/template-literal.test.ts      | 22 +++++++++++++++++++++
 src/types.ts                                |  1 +
 4 files changed, 46 insertions(+)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 7ff4aec27..b62fde81b 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -450,6 +450,28 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => anotherUndefined.parse("123")).toThrow();
   expect(() => anotherUndefined.parse("undefined1")).toThrow();
   expect(() => anotherUndefined.parse("1undefined")).toThrow();
+  expect(() => anyNumber.parse("2a")).toThrow();
+  expect(() => anyNumber.parse("a2")).toThrow();
+  expect(() => anyNumber.parse("-2a")).toThrow();
+  expect(() => anyNumber.parse("a-2")).toThrow();
+  expect(() => anyNumber.parse("2.5a")).toThrow();
+  expect(() => anyNumber.parse("a2.5")).toThrow();
+  expect(() => anyNumber.parse("Infinitya")).toThrow();
+  expect(() => anyNumber.parse("aInfinity")).toThrow();
+  expect(() => anyNumber.parse("-Infinitya")).toThrow();
+  expect(() => anyNumber.parse("a-Infinity")).toThrow();
+  expect(() => anyNumber.parse("2e5")).toThrow();
+  expect(() => anyNumber.parse("2e-5")).toThrow();
+  expect(() => anyNumber.parse("2e+5")).toThrow();
+  expect(() => anyNumber.parse("-2e5")).toThrow();
+  expect(() => anyNumber.parse("-2e-5")).toThrow();
+  expect(() => anyNumber.parse("-2e+5")).toThrow();
+  expect(() => anyNumber.parse("2.1e5")).toThrow();
+  expect(() => anyNumber.parse("2.1e-5")).toThrow();
+  expect(() => anyNumber.parse("2.1e+5")).toThrow();
+  expect(() => anyNumber.parse("-2.1e5")).toThrow();
+  expect(() => anyNumber.parse("-2.1e-5")).toThrow();
+  expect(() => anyNumber.parse("-2.1e+5")).toThrow();
   expect(() => anyFiniteNumber.parse("Infinity")).toThrow();
   expect(() => anyFiniteNumber.parse("-Infinity")).toThrow();
   expect(() => anyFiniteNumber.parse("123a")).toThrow();
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 6ff89b184..27d3a8ba1 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4600,6 +4600,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return `{${minLength},}`;
   }
 
+  // FIXME: we do not support exponent notation (e.g. 2e5) since it conflicts with `.int()`.
   protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
     let canBeNegative = true,
       canBePositive = true,
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index c1ed922d4..9d7159213 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -449,6 +449,28 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => anotherUndefined.parse("123")).toThrow();
   expect(() => anotherUndefined.parse("undefined1")).toThrow();
   expect(() => anotherUndefined.parse("1undefined")).toThrow();
+  expect(() => anyNumber.parse("2a")).toThrow();
+  expect(() => anyNumber.parse("a2")).toThrow();
+  expect(() => anyNumber.parse("-2a")).toThrow();
+  expect(() => anyNumber.parse("a-2")).toThrow();
+  expect(() => anyNumber.parse("2.5a")).toThrow();
+  expect(() => anyNumber.parse("a2.5")).toThrow();
+  expect(() => anyNumber.parse("Infinitya")).toThrow();
+  expect(() => anyNumber.parse("aInfinity")).toThrow();
+  expect(() => anyNumber.parse("-Infinitya")).toThrow();
+  expect(() => anyNumber.parse("a-Infinity")).toThrow();
+  expect(() => anyNumber.parse("2e5")).toThrow();
+  expect(() => anyNumber.parse("2e-5")).toThrow();
+  expect(() => anyNumber.parse("2e+5")).toThrow();
+  expect(() => anyNumber.parse("-2e5")).toThrow();
+  expect(() => anyNumber.parse("-2e-5")).toThrow();
+  expect(() => anyNumber.parse("-2e+5")).toThrow();
+  expect(() => anyNumber.parse("2.1e5")).toThrow();
+  expect(() => anyNumber.parse("2.1e-5")).toThrow();
+  expect(() => anyNumber.parse("2.1e+5")).toThrow();
+  expect(() => anyNumber.parse("-2.1e5")).toThrow();
+  expect(() => anyNumber.parse("-2.1e-5")).toThrow();
+  expect(() => anyNumber.parse("-2.1e+5")).toThrow();
   expect(() => anyFiniteNumber.parse("Infinity")).toThrow();
   expect(() => anyFiniteNumber.parse("-Infinity")).toThrow();
   expect(() => anyFiniteNumber.parse("123a")).toThrow();
diff --git a/src/types.ts b/src/types.ts
index 3a3b1f3c5..6db0e7f42 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4600,6 +4600,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return `{${minLength},}`;
   }
 
+  // FIXME: we do not support exponent notation (e.g. 2e5) since it conflicts with `.int()`.
   protected _transformZodNumberPartToRegexString(part: ZodNumber): string {
     let canBeNegative = true,
       canBePositive = true,

From 95d25d9b5032a793bf8114dbb5703e0ce32ceb15 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 20 Jan 2023 01:27:14 +0200
Subject: [PATCH 28/40] add missing `.toThrow()` @ ZodTemplateLiteral tests.

Co-authored-by: Max Arturo <5713763+maxArturo@users.noreply.github.com>
---
 deno/lib/__tests__/template-literal.test.ts | 23 ++++++++++++---------
 src/__tests__/template-literal.test.ts      | 23 ++++++++++++---------
 2 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index b62fde81b..18281b595 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -515,19 +515,22 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => nullishBruh.parse("null1")).toThrow();
   expect(() => nullishBruh.parse("1null")).toThrow();
   expect(() => nullishBruh.parse("undefined")).toThrow();
-  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy1"));
-  expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy"));
-  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy"));
-  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY"));
-  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1"));
-  expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ"));
-  expect(() => datetime.parse("2022-01-01 00:00:00"));
-  expect(() => email.parse("info@example.com@"));
+  expect(() => cuid.parse("bjld2cyuq0000t3rmniod1foy")).toThrow();
+  expect(() => cuid.parse("cjld2cyu")).toThrow();
+  expect(() => cuid.parse("cjld2 cyu")).toThrow();
+  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy ")).toThrow();
+  expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy")).toThrow();
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy")).toThrow();
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY")).toThrow();
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1")).toThrow();
+  expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ")).toThrow();
+  expect(() => datetime.parse("2022-01-01 00:00:00")).toThrow();
+  expect(() => email.parse("info@example.com@")).toThrow();
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.string().url())
   ).toThrow();
-  expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z"));
-  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6"));
+  expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z")).toThrow();
+  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6")).toThrow();
   expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
   expect(() => stringAToZ.parse("1asdasdasd")).toThrow();
   expect(() => stringStartsWith.parse("ahello")).toThrow();
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index 9d7159213..64134cde2 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -514,19 +514,22 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => nullishBruh.parse("null1")).toThrow();
   expect(() => nullishBruh.parse("1null")).toThrow();
   expect(() => nullishBruh.parse("undefined")).toThrow();
-  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy1"));
-  expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy"));
-  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy"));
-  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY"));
-  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1"));
-  expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ"));
-  expect(() => datetime.parse("2022-01-01 00:00:00"));
-  expect(() => email.parse("info@example.com@"));
+  expect(() => cuid.parse("bjld2cyuq0000t3rmniod1foy")).toThrow();
+  expect(() => cuid.parse("cjld2cyu")).toThrow();
+  expect(() => cuid.parse("cjld2 cyu")).toThrow();
+  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy ")).toThrow();
+  expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy")).toThrow();
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy")).toThrow();
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY")).toThrow();
+  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1")).toThrow();
+  expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ")).toThrow();
+  expect(() => datetime.parse("2022-01-01 00:00:00")).toThrow();
+  expect(() => email.parse("info@example.com@")).toThrow();
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.string().url())
   ).toThrow();
-  expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z"));
-  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6"));
+  expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z")).toThrow();
+  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6")).toThrow();
   expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
   expect(() => stringAToZ.parse("1asdasdasd")).toThrow();
   expect(() => stringStartsWith.parse("ahello")).toThrow();

From ed18f17ebf4a4ded59ccd1545cd0f550cf349bdd Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 20 Jan 2023 01:36:32 +0200
Subject: [PATCH 29/40] explicitly state `.trim()` is not supported @
 ZodTemplateLiteral.

Co-authored-by: Max Arturo <5713763+maxArturo@users.noreply.github.com>
---
 deno/lib/__tests__/template-literal.test.ts | 3 +++
 deno/lib/types.ts                           | 1 +
 src/__tests__/template-literal.test.ts      | 3 +++
 src/types.ts                                | 1 +
 4 files changed, 8 insertions(+)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 18281b595..83ec94379 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -327,6 +327,9 @@ test("template literal unsupported args", () => {
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().trim())
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 27d3a8ba1..520103b29 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4509,6 +4509,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     throw new ZodTemplateLiteralUnsupportedTypeError();
   }
 
+  // FIXME: we don't support transformations, so `.trim()` is not supported.
   protected _transformZodStringPartToRegexString(part: ZodString): string {
     let maxLength = Infinity,
       minLength = 0,
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index 64134cde2..d47fe3e55 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -326,6 +326,9 @@ test("template literal unsupported args", () => {
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().trim())
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
diff --git a/src/types.ts b/src/types.ts
index 6db0e7f42..89b76c3f7 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4509,6 +4509,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     throw new ZodTemplateLiteralUnsupportedTypeError();
   }
 
+  // FIXME: we don't support transformations, so `.trim()` is not supported.
   protected _transformZodStringPartToRegexString(part: ZodString): string {
     let maxLength = Infinity,
       minLength = 0,

From 5fad40153e55f3e8908ba2a41f15c56610ce4596 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 20 Jan 2023 02:12:00 +0200
Subject: [PATCH 30/40] fix mongodb connection string example and tests.

---
 README.md                                   |  8 ++---
 deno/lib/README.md                          |  8 ++---
 deno/lib/__tests__/template-literal.test.ts | 34 +++++++++++++--------
 src/__tests__/template-literal.test.ts      | 34 +++++++++++++--------
 4 files changed, 50 insertions(+), 34 deletions(-)

diff --git a/README.md b/README.md
index 20047b7ce..c613bb891 100644
--- a/README.md
+++ b/README.md
@@ -1721,13 +1721,13 @@ const connectionString = z
   .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
       .addLiteral(":")
-      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
       .addLiteral("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
   .addLiteral(":")
   .addInterpolatedPosition(
     z.number().finite().int().positive().describe("port")
@@ -1737,7 +1737,7 @@ const connectionString = z
       .templateLiteral()
       .addLiteral("/")
       .addInterpolatedPosition(
-        z.string().min(1).optional().describe("defaultauthdb")
+        z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
       .addInterpolatedPosition(
         z
diff --git a/deno/lib/README.md b/deno/lib/README.md
index 20047b7ce..c613bb891 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1721,13 +1721,13 @@ const connectionString = z
   .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
       .addLiteral(":")
-      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
       .addLiteral("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
   .addLiteral(":")
   .addInterpolatedPosition(
     z.number().finite().int().positive().describe("port")
@@ -1737,7 +1737,7 @@ const connectionString = z
       .templateLiteral()
       .addLiteral("/")
       .addInterpolatedPosition(
-        z.string().min(1).optional().describe("defaultauthdb")
+        z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
       .addInterpolatedPosition(
         z
diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 83ec94379..215365ba2 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -110,7 +110,7 @@ const anything = z.templateLiteral().addInterpolatedPosition(z.any());
 const url = z
   .templateLiteral()
   .addLiteral("https://")
-  .addInterpolatedPosition(z.string().min(1))
+  .addInterpolatedPosition(z.string().regex(/\w+/))
   .addLiteral(".")
   .addInterpolatedPosition(z.enum(["com", "net"]));
 
@@ -120,13 +120,13 @@ const connectionString = z
   .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
       .addLiteral(":")
-      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
       .addLiteral("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
   .addLiteral(":")
   .addInterpolatedPosition(
     z.number().finite().int().positive().describe("port")
@@ -136,7 +136,7 @@ const connectionString = z
       .templateLiteral()
       .addLiteral("/")
       .addInterpolatedPosition(
-        z.string().min(1).optional().describe("defaultauthdb")
+        z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
       .addInterpolatedPosition(
         z
@@ -596,20 +596,28 @@ test("template literal parsing - failure - complex cases", () => {
   expect(() => connectionString.parse("mongodb://host:-1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host:-12.34")).toThrow();
   expect(() => connectionString.parse("mongodb://host:")).toThrow();
-  expect(() => connectionString.parse("mongodb://:password@host:1234"));
-  expect(() => connectionString.parse("mongodb://usernamepassword@host:1234"));
-  expect(() => connectionString.parse("mongodb://username:@host:1234"));
-  expect(() => connectionString.parse("mongodb://@host:1234"));
+  expect(() =>
+    connectionString.parse("mongodb://:password@host:1234")
+  ).toThrow();
+  expect(() =>
+    connectionString.parse("mongodb://usernamepassword@host:1234")
+  ).toThrow();
+  expect(() =>
+    connectionString.parse("mongodb://username:@host:1234")
+  ).toThrow();
+  expect(() => connectionString.parse("mongodb://@host:1234")).toThrow();
   expect(() =>
     connectionString.parse("mongodb://host:1234/defaultauthdb?authSourceadmin")
-  );
-  expect(() => connectionString.parse("mongodb://host:1234/?authSourceadmin"));
+  ).toThrow();
+  expect(() =>
+    connectionString.parse("mongodb://host:1234/?authSourceadmin")
+  ).toThrow();
   expect(() =>
     connectionString.parse(
       "mongodb://host:1234/defaultauthdb?&authSource=admin"
     )
-  );
+  ).toThrow();
   expect(() =>
     connectionString.parse("mongodb://host:1234/?&authSource=admin")
-  );
+  ).toThrow();
 });
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index d47fe3e55..aa2b333b5 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -109,7 +109,7 @@ const anything = z.templateLiteral().addInterpolatedPosition(z.any());
 const url = z
   .templateLiteral()
   .addLiteral("https://")
-  .addInterpolatedPosition(z.string().min(1))
+  .addInterpolatedPosition(z.string().regex(/\w+/))
   .addLiteral(".")
   .addInterpolatedPosition(z.enum(["com", "net"]));
 
@@ -119,13 +119,13 @@ const connectionString = z
   .addInterpolatedPosition(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().min(1).describe("username"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
       .addLiteral(":")
-      .addInterpolatedPosition(z.string().min(1).describe("password"))
+      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
       .addLiteral("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().min(1).describe("host"))
+  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
   .addLiteral(":")
   .addInterpolatedPosition(
     z.number().finite().int().positive().describe("port")
@@ -135,7 +135,7 @@ const connectionString = z
       .templateLiteral()
       .addLiteral("/")
       .addInterpolatedPosition(
-        z.string().min(1).optional().describe("defaultauthdb")
+        z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
       .addInterpolatedPosition(
         z
@@ -595,20 +595,28 @@ test("template literal parsing - failure - complex cases", () => {
   expect(() => connectionString.parse("mongodb://host:-1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host:-12.34")).toThrow();
   expect(() => connectionString.parse("mongodb://host:")).toThrow();
-  expect(() => connectionString.parse("mongodb://:password@host:1234"));
-  expect(() => connectionString.parse("mongodb://usernamepassword@host:1234"));
-  expect(() => connectionString.parse("mongodb://username:@host:1234"));
-  expect(() => connectionString.parse("mongodb://@host:1234"));
+  expect(() =>
+    connectionString.parse("mongodb://:password@host:1234")
+  ).toThrow();
+  expect(() =>
+    connectionString.parse("mongodb://usernamepassword@host:1234")
+  ).toThrow();
+  expect(() =>
+    connectionString.parse("mongodb://username:@host:1234")
+  ).toThrow();
+  expect(() => connectionString.parse("mongodb://@host:1234")).toThrow();
   expect(() =>
     connectionString.parse("mongodb://host:1234/defaultauthdb?authSourceadmin")
-  );
-  expect(() => connectionString.parse("mongodb://host:1234/?authSourceadmin"));
+  ).toThrow();
+  expect(() =>
+    connectionString.parse("mongodb://host:1234/?authSourceadmin")
+  ).toThrow();
   expect(() =>
     connectionString.parse(
       "mongodb://host:1234/defaultauthdb?&authSource=admin"
     )
-  );
+  ).toThrow();
   expect(() =>
     connectionString.parse("mongodb://host:1234/?&authSource=admin")
-  );
+  ).toThrow();
 });

From 70913d38d94f48f0a1d006c2b8fb1b7435ce80dc Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 20 Jan 2023 02:24:35 +0200
Subject: [PATCH 31/40] add measurment example from README to
 ZodTemplateLiteral tests.

---
 README.md                                   |  2 +-
 deno/lib/README.md                          |  2 +-
 deno/lib/__tests__/template-literal.test.ts | 71 +++++++++++++++++++++
 src/__tests__/template-literal.test.ts      | 71 +++++++++++++++++++++
 4 files changed, 144 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index c613bb891..4bba5c5fa 100644
--- a/README.md
+++ b/README.md
@@ -1703,7 +1703,7 @@ url.parse('https://google.gov'); // throws
 Measurement:
 
 ```ts
-const schema = z.coerce
+const measurement = z.coerce
     .templateLiteral()
     .addInterpolatedPosition(z.number().finite())
     .addInterpolatedPosition(
diff --git a/deno/lib/README.md b/deno/lib/README.md
index c613bb891..4bba5c5fa 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1703,7 +1703,7 @@ url.parse('https://google.gov'); // throws
 Measurement:
 
 ```ts
-const schema = z.coerce
+const measurement = z.coerce
     .templateLiteral()
     .addInterpolatedPosition(z.number().finite())
     .addInterpolatedPosition(
diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index 215365ba2..ec6cb2ed1 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -114,6 +114,13 @@ const url = z
   .addLiteral(".")
   .addInterpolatedPosition(z.enum(["com", "net"]));
 
+const measurement = z.coerce
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().finite())
+  .addInterpolatedPosition(
+    z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+  );
+
 const connectionString = z
   .templateLiteral()
   .addLiteral("mongodb://")
@@ -202,6 +209,18 @@ test("template literal type inference", () => {
     `https://${string}.com` | `https://${string}.net`
   >(true);
 
+  util.assertEqual<
+    z.infer<typeof measurement>,
+    | `${number}`
+    | `${number}px`
+    | `${number}em`
+    | `${number}rem`
+    | `${number}vh`
+    | `${number}vw`
+    | `${number}vmin`
+    | `${number}vmax`
+  >(true);
+
   util.assertEqual<
     z.infer<typeof connectionString>,
     | `mongodb://${string}:${number}`
@@ -553,6 +572,52 @@ test("template literal parsing - success - complex cases", () => {
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
+  measurement.parse(1);
+  measurement.parse(1.1);
+  measurement.parse(0);
+  measurement.parse(-1.1);
+  measurement.parse(-1);
+  measurement.parse("1");
+  measurement.parse("1.1");
+  measurement.parse("0");
+  measurement.parse("-1");
+  measurement.parse("-1.1");
+  measurement.parse("1px");
+  measurement.parse("1.1px");
+  measurement.parse("0px");
+  measurement.parse("-1px");
+  measurement.parse("-1.1px");
+  measurement.parse("1em");
+  measurement.parse("1.1em");
+  measurement.parse("0em");
+  measurement.parse("-1em");
+  measurement.parse("-1.1em");
+  measurement.parse("1rem");
+  measurement.parse("1.1rem");
+  measurement.parse("0rem");
+  measurement.parse("-1rem");
+  measurement.parse("-1.1rem");
+  measurement.parse("1vh");
+  measurement.parse("1.1vh");
+  measurement.parse("0vh");
+  measurement.parse("-1vh");
+  measurement.parse("-1.1vh");
+  measurement.parse("1vw");
+  measurement.parse("1.1vw");
+  measurement.parse("0vw");
+  measurement.parse("-1vw");
+  measurement.parse("-1.1vw");
+  measurement.parse("1vmin");
+  measurement.parse("1.1vmin");
+  measurement.parse("0vmin");
+  measurement.parse("-1vmin");
+  measurement.parse("-1.1vmin");
+  measurement.parse("1vmax");
+  measurement.parse("1.1vmax");
+  measurement.parse("0vmax");
+  measurement.parse("-1vmax");
+  measurement.parse("-1.1vmax");
+
   connectionString.parse("mongodb://host:1234");
   connectionString.parse("mongodb://host:1234/");
   connectionString.parse("mongodb://host:1234/defaultauthdb");
@@ -588,6 +653,12 @@ test("template literal parsing - failure - complex cases", () => {
   expect(() => url.parse("https://example.org")).toThrow();
   expect(() => url.parse("https://example.net.il")).toThrow();
 
+  expect(() => measurement.parse("1.1.1")).toThrow();
+  expect(() => measurement.parse("Infinity")).toThrow();
+  expect(() => measurement.parse("-Infinity")).toThrow();
+  expect(() => measurement.parse("NaN")).toThrow();
+  expect(() => measurement.parse("1%")).toThrow();
+
   expect(() => connectionString.parse("mongod://host:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host1234")).toThrow();
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index aa2b333b5..b3d800de9 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -113,6 +113,13 @@ const url = z
   .addLiteral(".")
   .addInterpolatedPosition(z.enum(["com", "net"]));
 
+const measurement = z.coerce
+  .templateLiteral()
+  .addInterpolatedPosition(z.number().finite())
+  .addInterpolatedPosition(
+    z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+  );
+
 const connectionString = z
   .templateLiteral()
   .addLiteral("mongodb://")
@@ -201,6 +208,18 @@ test("template literal type inference", () => {
     `https://${string}.com` | `https://${string}.net`
   >(true);
 
+  util.assertEqual<
+    z.infer<typeof measurement>,
+    | `${number}`
+    | `${number}px`
+    | `${number}em`
+    | `${number}rem`
+    | `${number}vh`
+    | `${number}vw`
+    | `${number}vmin`
+    | `${number}vmax`
+  >(true);
+
   util.assertEqual<
     z.infer<typeof connectionString>,
     | `mongodb://${string}:${number}`
@@ -552,6 +571,52 @@ test("template literal parsing - success - complex cases", () => {
   url.parse("https://example.com");
   url.parse("https://speedtest.net");
 
+  measurement.parse(1);
+  measurement.parse(1.1);
+  measurement.parse(0);
+  measurement.parse(-1.1);
+  measurement.parse(-1);
+  measurement.parse("1");
+  measurement.parse("1.1");
+  measurement.parse("0");
+  measurement.parse("-1");
+  measurement.parse("-1.1");
+  measurement.parse("1px");
+  measurement.parse("1.1px");
+  measurement.parse("0px");
+  measurement.parse("-1px");
+  measurement.parse("-1.1px");
+  measurement.parse("1em");
+  measurement.parse("1.1em");
+  measurement.parse("0em");
+  measurement.parse("-1em");
+  measurement.parse("-1.1em");
+  measurement.parse("1rem");
+  measurement.parse("1.1rem");
+  measurement.parse("0rem");
+  measurement.parse("-1rem");
+  measurement.parse("-1.1rem");
+  measurement.parse("1vh");
+  measurement.parse("1.1vh");
+  measurement.parse("0vh");
+  measurement.parse("-1vh");
+  measurement.parse("-1.1vh");
+  measurement.parse("1vw");
+  measurement.parse("1.1vw");
+  measurement.parse("0vw");
+  measurement.parse("-1vw");
+  measurement.parse("-1.1vw");
+  measurement.parse("1vmin");
+  measurement.parse("1.1vmin");
+  measurement.parse("0vmin");
+  measurement.parse("-1vmin");
+  measurement.parse("-1.1vmin");
+  measurement.parse("1vmax");
+  measurement.parse("1.1vmax");
+  measurement.parse("0vmax");
+  measurement.parse("-1vmax");
+  measurement.parse("-1.1vmax");
+
   connectionString.parse("mongodb://host:1234");
   connectionString.parse("mongodb://host:1234/");
   connectionString.parse("mongodb://host:1234/defaultauthdb");
@@ -587,6 +652,12 @@ test("template literal parsing - failure - complex cases", () => {
   expect(() => url.parse("https://example.org")).toThrow();
   expect(() => url.parse("https://example.net.il")).toThrow();
 
+  expect(() => measurement.parse("1.1.1")).toThrow();
+  expect(() => measurement.parse("Infinity")).toThrow();
+  expect(() => measurement.parse("-Infinity")).toThrow();
+  expect(() => measurement.parse("NaN")).toThrow();
+  expect(() => measurement.parse("1%")).toThrow();
+
   expect(() => connectionString.parse("mongod://host:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://:1234")).toThrow();
   expect(() => connectionString.parse("mongodb://host1234")).toThrow();

From ff298a119f419d837d2452c031e0536ca09dae0d Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 20 Jan 2023 14:20:14 +0200
Subject: [PATCH 32/40] extract ZodTemplateLiteral errors to ZodError.ts

Co-authored-by: Max Arturo <5713763+maxArturo@users.noreply.github.com>
---
 deno/lib/ZodError.ts | 34 +++++++++++++++++++++++++++++++++-
 deno/lib/types.ts    | 34 ++--------------------------------
 src/ZodError.ts      | 34 +++++++++++++++++++++++++++++++++-
 src/types.ts         | 34 ++--------------------------------
 4 files changed, 70 insertions(+), 66 deletions(-)

diff --git a/deno/lib/ZodError.ts b/deno/lib/ZodError.ts
index 936fc7573..eb63903a8 100644
--- a/deno/lib/ZodError.ts
+++ b/deno/lib/ZodError.ts
@@ -1,4 +1,4 @@
-import type { TypeOf, ZodType } from "./index.ts";
+import type { TypeOf, ZodFirstPartyTypeKind, ZodType } from "./index.ts";
 import { Primitive } from "./helpers/typeAliases.ts";
 import { util, ZodParsedType } from "./helpers/util.ts";
 
@@ -319,3 +319,35 @@ export type ZodErrorMap = (
   issue: ZodIssueOptionalMessage,
   _ctx: ErrorMapCtx
 ) => { message: string };
+
+export class ZodTemplateLiteralUnsupportedTypeError extends Error {
+  constructor() {
+    super("Unsupported zod type!");
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedTypeError";
+  }
+}
+
+export class ZodTemplateLiteralUnsupportedCheckError extends Error {
+  constructor(typeKind: ZodFirstPartyTypeKind, check: string) {
+    super(
+      `${typeKind}'s "${check}" check is not supported in template literals!`
+    );
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedCheckError";
+  }
+}
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 520103b29..0df248364 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -31,6 +31,8 @@ import {
   ZodErrorMap,
   ZodIssue,
   ZodIssueCode,
+  ZodTemplateLiteralUnsupportedCheckError,
+  ZodTemplateLiteralUnsupportedTypeError,
 } from "./ZodError.ts";
 
 ///////////////////////////////////////
@@ -4329,38 +4331,6 @@ export interface ZodTemplateLiteralDef extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
 
-export class ZodTemplateLiteralUnsupportedTypeError extends Error {
-  constructor() {
-    super("Unsupported zod type!");
-
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      // eslint-disable-next-line ban/ban
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      (this as any).__proto__ = actualProto;
-    }
-    this.name = "ZodTemplateLiteralUnsupportedTypeError";
-  }
-}
-
-export class ZodTemplateLiteralUnsupportedCheckError extends Error {
-  constructor(typeKind: ZodFirstPartyTypeKind, check: string) {
-    super(
-      `${typeKind}'s ${check} check is not supported in template literals!`
-    );
-
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      // eslint-disable-next-line ban/ban
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      (this as any).__proto__ = actualProto;
-    }
-    this.name = "ZodTemplateLiteralUnsupportedCheckError";
-  }
-}
-
 export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef
diff --git a/src/ZodError.ts b/src/ZodError.ts
index 0886951cc..49d30292b 100644
--- a/src/ZodError.ts
+++ b/src/ZodError.ts
@@ -1,4 +1,4 @@
-import type { TypeOf, ZodType } from ".";
+import type { TypeOf, ZodFirstPartyTypeKind, ZodType } from ".";
 import { Primitive } from "./helpers/typeAliases";
 import { util, ZodParsedType } from "./helpers/util";
 
@@ -319,3 +319,35 @@ export type ZodErrorMap = (
   issue: ZodIssueOptionalMessage,
   _ctx: ErrorMapCtx
 ) => { message: string };
+
+export class ZodTemplateLiteralUnsupportedTypeError extends Error {
+  constructor() {
+    super("Unsupported zod type!");
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedTypeError";
+  }
+}
+
+export class ZodTemplateLiteralUnsupportedCheckError extends Error {
+  constructor(typeKind: ZodFirstPartyTypeKind, check: string) {
+    super(
+      `${typeKind}'s "${check}" check is not supported in template literals!`
+    );
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "ZodTemplateLiteralUnsupportedCheckError";
+  }
+}
diff --git a/src/types.ts b/src/types.ts
index 89b76c3f7..e62ca137e 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -31,6 +31,8 @@ import {
   ZodErrorMap,
   ZodIssue,
   ZodIssueCode,
+  ZodTemplateLiteralUnsupportedCheckError,
+  ZodTemplateLiteralUnsupportedTypeError,
 } from "./ZodError";
 
 ///////////////////////////////////////
@@ -4329,38 +4331,6 @@ export interface ZodTemplateLiteralDef extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodTemplateLiteral;
 }
 
-export class ZodTemplateLiteralUnsupportedTypeError extends Error {
-  constructor() {
-    super("Unsupported zod type!");
-
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      // eslint-disable-next-line ban/ban
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      (this as any).__proto__ = actualProto;
-    }
-    this.name = "ZodTemplateLiteralUnsupportedTypeError";
-  }
-}
-
-export class ZodTemplateLiteralUnsupportedCheckError extends Error {
-  constructor(typeKind: ZodFirstPartyTypeKind, check: string) {
-    super(
-      `${typeKind}'s ${check} check is not supported in template literals!`
-    );
-
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      // eslint-disable-next-line ban/ban
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      (this as any).__proto__ = actualProto;
-    }
-    this.name = "ZodTemplateLiteralUnsupportedCheckError";
-  }
-}
-
 export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef

From 094dccbece4500ec47ca045fba3c31f1b744a0e1 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 8 Feb 2023 01:25:20 +0200
Subject: [PATCH 33/40] add `z.string().cuid2()` support.

---
 deno/lib/__tests__/template-literal.test.ts | 5 +++++
 deno/lib/types.ts                           | 6 +++++-
 src/__tests__/template-literal.test.ts      | 5 +++++
 src/types.ts                                | 4 ++++
 4 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index ec6cb2ed1..d28b51026 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -73,6 +73,7 @@ const cuidZZZ = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().cuid())
   .addLiteral("ZZZ");
+const cuid2 = z.templateLiteral().addInterpolatedPosition(z.string().cuid2());
 const datetime = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().datetime());
@@ -190,6 +191,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof nullishString>, string>(true);
   util.assertEqual<z.infer<typeof cuid>, string>(true);
   util.assertEqual<z.infer<typeof cuidZZZ>, `${string}ZZZ`>(true);
+  util.assertEqual<z.infer<typeof cuid2>, string>(true);
   util.assertEqual<z.infer<typeof datetime>, string>(true);
   util.assertEqual<z.infer<typeof email>, string>(true);
   util.assertEqual<z.infer<typeof uuid>, string>(true);
@@ -420,6 +422,7 @@ test("template literal parsing - success - basic cases", () => {
   nullishBruh.parse("");
   cuid.parse("cjld2cyuq0000t3rmniod1foy");
   cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ");
+  cuid2.parse("tz4a98xxat96iws9zmbrgj3a");
   datetime.parse(new Date().toISOString());
   email.parse("info@example.com");
   uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
@@ -546,6 +549,8 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY")).toThrow();
   expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1")).toThrow();
   expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ")).toThrow();
+  expect(() => cuid2.parse("9z4a98xxat96iws9zmbrgj3a")).toThrow();
+  expect(() => cuid2.parse("tz4a98xxat96iws9zmbrgj3!")).toThrow();
   expect(() => datetime.parse("2022-01-01 00:00:00")).toThrow();
   expect(() => email.parse("info@example.com@")).toThrow();
   expect(() =>
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index c7e0f62b4..6ec264e40 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -522,7 +522,7 @@ const uuidRegex =
 // old version: too slow, didn't support unicode
 // const emailRegex = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
 // eslint-disable-next-line
-const emailRegex =
+export const emailRegex =
   /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@((?!-)([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{1,})[^-<>()[\].,;:\s@"]$/i;
 
 // interface IsDateStringOptions extends StringDateOptions {
@@ -4524,6 +4524,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         return this._unwrapRegexString(cuidRegex.source);
       }
 
+      if (ch.kind === "cuid2") {
+        return this._unwrapRegexString(cuid2Regex.source);
+      }
+
       if (ch.kind === "datetime") {
         return this._unwrapRegexString(datetimeRegex(ch).source);
       }
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index b3d800de9..afa0788e1 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -72,6 +72,7 @@ const cuidZZZ = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().cuid())
   .addLiteral("ZZZ");
+const cuid2 = z.templateLiteral().addInterpolatedPosition(z.string().cuid2());
 const datetime = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().datetime());
@@ -189,6 +190,7 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof nullishString>, string>(true);
   util.assertEqual<z.infer<typeof cuid>, string>(true);
   util.assertEqual<z.infer<typeof cuidZZZ>, `${string}ZZZ`>(true);
+  util.assertEqual<z.infer<typeof cuid2>, string>(true);
   util.assertEqual<z.infer<typeof datetime>, string>(true);
   util.assertEqual<z.infer<typeof email>, string>(true);
   util.assertEqual<z.infer<typeof uuid>, string>(true);
@@ -419,6 +421,7 @@ test("template literal parsing - success - basic cases", () => {
   nullishBruh.parse("");
   cuid.parse("cjld2cyuq0000t3rmniod1foy");
   cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ");
+  cuid2.parse("tz4a98xxat96iws9zmbrgj3a");
   datetime.parse(new Date().toISOString());
   email.parse("info@example.com");
   uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
@@ -545,6 +548,8 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY")).toThrow();
   expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1")).toThrow();
   expect(() => cuidZZZ.parse("1cjld2cyuq0000t3rmniod1foyZZZ")).toThrow();
+  expect(() => cuid2.parse("9z4a98xxat96iws9zmbrgj3a")).toThrow();
+  expect(() => cuid2.parse("tz4a98xxat96iws9zmbrgj3!")).toThrow();
   expect(() => datetime.parse("2022-01-01 00:00:00")).toThrow();
   expect(() => email.parse("info@example.com@")).toThrow();
   expect(() =>
diff --git a/src/types.ts b/src/types.ts
index 7edde08b8..87861a83a 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4524,6 +4524,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         return this._unwrapRegexString(cuidRegex.source);
       }
 
+      if (ch.kind === "cuid2") {
+        return this._unwrapRegexString(cuid2Regex.source);
+      }
+
       if (ch.kind === "datetime") {
         return this._unwrapRegexString(datetimeRegex(ch).source);
       }

From 72c112b3f438b2562a39eafadf91d5a93fcdcf3a Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 8 Feb 2023 01:33:52 +0200
Subject: [PATCH 34/40] fix prettier error @ benchmarks primitives.

---
 deno/lib/benchmarks/primitives.ts | 16 +++++++++++++---
 src/benchmarks/primitives.ts      | 16 +++++++++++++---
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/deno/lib/benchmarks/primitives.ts b/deno/lib/benchmarks/primitives.ts
index 734dfe2bb..c91b50114 100644
--- a/deno/lib/benchmarks/primitives.ts
+++ b/deno/lib/benchmarks/primitives.ts
@@ -79,7 +79,10 @@ numberSuite
 const dateSuite = new Benchmark.Suite("z.date");
 
 const plainDate = z.date();
-const minMaxDate = z.date().min(new Date("2021-01-01")).max(new Date("2030-01-01"));
+const minMaxDate = z
+  .date()
+  .min(new Date("2021-01-01"))
+  .max(new Date("2030-01-01"));
 
 dateSuite
   .add("valid", () => {
@@ -112,7 +115,7 @@ const symbolSchema = z.symbol();
 
 symbolSuite
   .add("valid", () => {
-    symbolSchema.parse(val.symbol)
+    symbolSchema.parse(val.symbol);
   })
   .add("invalid", () => {
     try {
@@ -124,5 +127,12 @@ symbolSuite
   });
 
 export default {
-  suites: [enumSuite, undefinedSuite, literalSuite, numberSuite, dateSuite, symbolSuite],
+  suites: [
+    enumSuite,
+    undefinedSuite,
+    literalSuite,
+    numberSuite,
+    dateSuite,
+    symbolSuite,
+  ],
 };
diff --git a/src/benchmarks/primitives.ts b/src/benchmarks/primitives.ts
index 62809e275..5b0034f1d 100644
--- a/src/benchmarks/primitives.ts
+++ b/src/benchmarks/primitives.ts
@@ -79,7 +79,10 @@ numberSuite
 const dateSuite = new Benchmark.Suite("z.date");
 
 const plainDate = z.date();
-const minMaxDate = z.date().min(new Date("2021-01-01")).max(new Date("2030-01-01"));
+const minMaxDate = z
+  .date()
+  .min(new Date("2021-01-01"))
+  .max(new Date("2030-01-01"));
 
 dateSuite
   .add("valid", () => {
@@ -112,7 +115,7 @@ const symbolSchema = z.symbol();
 
 symbolSuite
   .add("valid", () => {
-    symbolSchema.parse(val.symbol)
+    symbolSchema.parse(val.symbol);
   })
   .add("invalid", () => {
     try {
@@ -124,5 +127,12 @@ symbolSuite
   });
 
 export default {
-  suites: [enumSuite, undefinedSuite, literalSuite, numberSuite, dateSuite, symbolSuite],
+  suites: [
+    enumSuite,
+    undefinedSuite,
+    literalSuite,
+    numberSuite,
+    dateSuite,
+    symbolSuite,
+  ],
 };

From 588f7dda5c2723cbdb05608b6310af9d2e003b12 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 22 Mar 2023 03:28:44 +0200
Subject: [PATCH 35/40] add support for new regex based string checks.

---
 deno/lib/README.md                          |  2 +-
 deno/lib/__tests__/template-literal.test.ts | 40 ++++++++++++-
 deno/lib/types.ts                           | 65 +++++++++++----------
 src/__tests__/template-literal.test.ts      | 40 ++++++++++++-
 src/types.ts                                | 51 ++++++++--------
 5 files changed, 142 insertions(+), 56 deletions(-)

diff --git a/deno/lib/README.md b/deno/lib/README.md
index 2ec39f61e..ed1e5efd4 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -624,7 +624,7 @@ z.coerce.boolean().parse(null); // => false
 
 ## Literals
 
-Literal schemas represent a [literal type](https://www.typescriptlang.org/docs/handbook/literal-types.html), like `"hello world"` or `5`.
+Literal schemas represent a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types), like `"hello world"` or `5`.
 
 ```ts
 const tuna = z.literal("tuna");
diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index d28b51026..d6d835193 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -78,6 +78,14 @@ const datetime = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().datetime());
 const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
+const ip = z.templateLiteral().addInterpolatedPosition(z.string().ip());
+const ipv4 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().ip({ version: "v4" }));
+const ipv6 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().ip({ version: "v6" }));
+const ulid = z.templateLiteral().addInterpolatedPosition(z.string().ulid());
 const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
 const stringAToZ = z
   .templateLiteral()
@@ -194,6 +202,10 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof cuid2>, string>(true);
   util.assertEqual<z.infer<typeof datetime>, string>(true);
   util.assertEqual<z.infer<typeof email>, string>(true);
+  util.assertEqual<z.infer<typeof ip>, string>(true);
+  util.assertEqual<z.infer<typeof ipv4>, string>(true);
+  util.assertEqual<z.infer<typeof ipv6>, string>(true);
+  util.assertEqual<z.infer<typeof ulid>, string>(true);
   util.assertEqual<z.infer<typeof uuid>, string>(true);
   util.assertEqual<z.infer<typeof stringAToZ>, string>(true);
   util.assertEqual<z.infer<typeof stringStartsWith>, string>(true);
@@ -348,9 +360,24 @@ test("template literal unsupported args", () => {
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().emoji())
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().url())
+  ).toThrow();
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.string().trim())
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().includes("train"))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().toLowerCase())
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().toUpperCase())
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
@@ -425,6 +452,11 @@ test("template literal parsing - success - basic cases", () => {
   cuid2.parse("tz4a98xxat96iws9zmbrgj3a");
   datetime.parse(new Date().toISOString());
   email.parse("info@example.com");
+  ip.parse("213.174.246.205");
+  ip.parse("c359:f57c:21e5:39eb:1187:e501:f936:b452");
+  ipv4.parse("213.174.246.205");
+  ipv6.parse("c359:f57c:21e5:39eb:1187:e501:f936:b452");
+  ulid.parse("01GW3D2QZJBYB6P1Z1AE997VPW");
   uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
   stringAToZ.parse("asudgaskhdgashd");
   stringStartsWith.parse("hello world");
@@ -553,9 +585,15 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => cuid2.parse("tz4a98xxat96iws9zmbrgj3!")).toThrow();
   expect(() => datetime.parse("2022-01-01 00:00:00")).toThrow();
   expect(() => email.parse("info@example.com@")).toThrow();
+  expect(() => ip.parse("213.174.246:205")).toThrow();
+  expect(() => ip.parse("c359.f57c:21e5:39eb:1187:e501:f936:b452")).toThrow();
+  expect(() => ipv4.parse("1213.174.246.205")).toThrow();
+  expect(() => ipv4.parse("c359:f57c:21e5:39eb:1187:e501:f936:b452")).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().url())
+    ipv6.parse("c359:f57c:21e5:39eb:1187:e501:f936:b4521")
   ).toThrow();
+  expect(() => ipv6.parse("213.174.246.205")).toThrow();
+  expect(() => ulid.parse("01GW3D2QZJBYB6P1Z1AE997VPW!")).toThrow();
   expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z")).toThrow();
   expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6")).toThrow();
   expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index 8c142d009..f39cd472b 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -3761,7 +3761,7 @@ export class ZodFunction<
     return this._def.returns;
   }
 
-  args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(
+  args<Items extends Parameters<typeof ZodTuple["create"]>[0]>(
     ...items: Items
   ): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns> {
     return new ZodFunction({
@@ -4937,30 +4937,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       startsWith = "";
 
     for (const ch of part._def.checks) {
-      if (ch.kind === "cuid") {
-        return this._unwrapRegexString(cuidRegex.source);
-      }
-
-      if (ch.kind === "cuid2") {
-        return this._unwrapRegexString(cuid2Regex.source);
-      }
-
-      if (ch.kind === "datetime") {
-        return this._unwrapRegexString(datetimeRegex(ch).source);
-      }
-
-      if (ch.kind === "email") {
-        return this._unwrapRegexString(emailRegex.source);
-      }
-
-      if (ch.kind === "regex") {
-        // FIXME: maybe allow combinations of endsWith, startsWith, min/max length with a regex,
-        // if it doesn't lock both ends with `^` & `$` ?
-        return this._unwrapRegexString(ch.regex.source);
-      }
+      const regex = this._resolveRegexForStringCheck(ch);
 
-      if (ch.kind === "uuid") {
-        return this._unwrapRegexString(uuidRegex.source);
+      if (regex) {
+        return this._unwrapRegexString(regex.source);
       }
 
       if (ch.kind === "endsWith") {
@@ -5002,6 +4982,31 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     )}${endsWith}`;
   }
 
+  protected _resolveRegexForStringCheck(check: ZodStringCheck): RegExp | null {
+    return {
+      [check.kind]: null,
+      cuid: cuidRegex,
+      cuid2: cuid2Regex,
+      datetime: check.kind === "datetime" ? datetimeRegex(check) : null,
+      email: emailRegex,
+      ip:
+        check.kind === "ip"
+          ? {
+              any: new RegExp(
+                `^(${this._unwrapRegexString(
+                  ipv4Regex.source
+                )})|(${this._unwrapRegexString(ipv6Regex.source)})$`
+              ),
+              v4: ipv4Regex,
+              v6: ipv6Regex,
+            }[check.version || "any"]
+          : null,
+      regex: check.kind === "regex" ? check.regex : null,
+      ulid: ulidRegex,
+      uuid: uuidRegex,
+    }[check.kind];
+  }
+
   protected _resolveRegexWildcardLength(
     minLength: number,
     maxLength: number
@@ -5298,23 +5303,23 @@ const oboolean = () => booleanType().optional();
 
 export const coerce = {
   string: ((arg) =>
-    ZodString.create({ ...arg, coerce: true })) as (typeof ZodString)["create"],
+    ZodString.create({ ...arg, coerce: true })) as typeof ZodString["create"],
   number: ((arg) =>
-    ZodNumber.create({ ...arg, coerce: true })) as (typeof ZodNumber)["create"],
+    ZodNumber.create({ ...arg, coerce: true })) as typeof ZodNumber["create"],
   boolean: ((arg) =>
     ZodBoolean.create({
       ...arg,
       coerce: true,
-    })) as (typeof ZodBoolean)["create"],
+    })) as typeof ZodBoolean["create"],
   bigint: ((arg) =>
-    ZodBigInt.create({ ...arg, coerce: true })) as (typeof ZodBigInt)["create"],
+    ZodBigInt.create({ ...arg, coerce: true })) as typeof ZodBigInt["create"],
   date: ((arg) =>
-    ZodDate.create({ ...arg, coerce: true })) as (typeof ZodDate)["create"],
+    ZodDate.create({ ...arg, coerce: true })) as typeof ZodDate["create"],
   templateLiteral: ((arg) =>
     ZodTemplateLiteral.create({
       ...arg,
       coerce: true,
-    })) as (typeof ZodTemplateLiteral)["create"],
+    })) as typeof ZodTemplateLiteral["create"],
 };
 
 export {
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index afa0788e1..e4b81d498 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -77,6 +77,14 @@ const datetime = z
   .templateLiteral()
   .addInterpolatedPosition(z.string().datetime());
 const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
+const ip = z.templateLiteral().addInterpolatedPosition(z.string().ip());
+const ipv4 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().ip({ version: "v4" }));
+const ipv6 = z
+  .templateLiteral()
+  .addInterpolatedPosition(z.string().ip({ version: "v6" }));
+const ulid = z.templateLiteral().addInterpolatedPosition(z.string().ulid());
 const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
 const stringAToZ = z
   .templateLiteral()
@@ -193,6 +201,10 @@ test("template literal type inference", () => {
   util.assertEqual<z.infer<typeof cuid2>, string>(true);
   util.assertEqual<z.infer<typeof datetime>, string>(true);
   util.assertEqual<z.infer<typeof email>, string>(true);
+  util.assertEqual<z.infer<typeof ip>, string>(true);
+  util.assertEqual<z.infer<typeof ipv4>, string>(true);
+  util.assertEqual<z.infer<typeof ipv6>, string>(true);
+  util.assertEqual<z.infer<typeof ulid>, string>(true);
   util.assertEqual<z.infer<typeof uuid>, string>(true);
   util.assertEqual<z.infer<typeof stringAToZ>, string>(true);
   util.assertEqual<z.infer<typeof stringStartsWith>, string>(true);
@@ -347,9 +359,24 @@ test("template literal unsupported args", () => {
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().emoji())
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().url())
+  ).toThrow();
   expect(() =>
     z.templateLiteral().addInterpolatedPosition(z.string().trim())
   ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().includes("train"))
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().toLowerCase())
+  ).toThrow();
+  expect(() =>
+    z.templateLiteral().addInterpolatedPosition(z.string().toUpperCase())
+  ).toThrow();
 });
 
 test("template literal parsing - success - basic cases", () => {
@@ -424,6 +451,11 @@ test("template literal parsing - success - basic cases", () => {
   cuid2.parse("tz4a98xxat96iws9zmbrgj3a");
   datetime.parse(new Date().toISOString());
   email.parse("info@example.com");
+  ip.parse("213.174.246.205");
+  ip.parse("c359:f57c:21e5:39eb:1187:e501:f936:b452");
+  ipv4.parse("213.174.246.205");
+  ipv6.parse("c359:f57c:21e5:39eb:1187:e501:f936:b452");
+  ulid.parse("01GW3D2QZJBYB6P1Z1AE997VPW");
   uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6");
   stringAToZ.parse("asudgaskhdgashd");
   stringStartsWith.parse("hello world");
@@ -552,9 +584,15 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => cuid2.parse("tz4a98xxat96iws9zmbrgj3!")).toThrow();
   expect(() => datetime.parse("2022-01-01 00:00:00")).toThrow();
   expect(() => email.parse("info@example.com@")).toThrow();
+  expect(() => ip.parse("213.174.246:205")).toThrow();
+  expect(() => ip.parse("c359.f57c:21e5:39eb:1187:e501:f936:b452")).toThrow();
+  expect(() => ipv4.parse("1213.174.246.205")).toThrow();
+  expect(() => ipv4.parse("c359:f57c:21e5:39eb:1187:e501:f936:b452")).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().url())
+    ipv6.parse("c359:f57c:21e5:39eb:1187:e501:f936:b4521")
   ).toThrow();
+  expect(() => ipv6.parse("213.174.246.205")).toThrow();
+  expect(() => ulid.parse("01GW3D2QZJBYB6P1Z1AE997VPW!")).toThrow();
   expect(() => uuid.parse("808989fd-3a6e-4af2-b607-737323a176f6Z")).toThrow();
   expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6")).toThrow();
   expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
diff --git a/src/types.ts b/src/types.ts
index b1b227ddd..6f01ef901 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4937,30 +4937,10 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       startsWith = "";
 
     for (const ch of part._def.checks) {
-      if (ch.kind === "cuid") {
-        return this._unwrapRegexString(cuidRegex.source);
-      }
-
-      if (ch.kind === "cuid2") {
-        return this._unwrapRegexString(cuid2Regex.source);
-      }
-
-      if (ch.kind === "datetime") {
-        return this._unwrapRegexString(datetimeRegex(ch).source);
-      }
-
-      if (ch.kind === "email") {
-        return this._unwrapRegexString(emailRegex.source);
-      }
-
-      if (ch.kind === "regex") {
-        // FIXME: maybe allow combinations of endsWith, startsWith, min/max length with a regex,
-        // if it doesn't lock both ends with `^` & `$` ?
-        return this._unwrapRegexString(ch.regex.source);
-      }
+      const regex = this._resolveRegexForStringCheck(ch);
 
-      if (ch.kind === "uuid") {
-        return this._unwrapRegexString(uuidRegex.source);
+      if (regex) {
+        return this._unwrapRegexString(regex.source);
       }
 
       if (ch.kind === "endsWith") {
@@ -5002,6 +4982,31 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     )}${endsWith}`;
   }
 
+  protected _resolveRegexForStringCheck(check: ZodStringCheck): RegExp | null {
+    return {
+      [check.kind]: null,
+      cuid: cuidRegex,
+      cuid2: cuid2Regex,
+      datetime: check.kind === "datetime" ? datetimeRegex(check) : null,
+      email: emailRegex,
+      ip:
+        check.kind === "ip"
+          ? {
+              any: new RegExp(
+                `^(${this._unwrapRegexString(
+                  ipv4Regex.source
+                )})|(${this._unwrapRegexString(ipv6Regex.source)})$`
+              ),
+              v4: ipv4Regex,
+              v6: ipv6Regex,
+            }[check.version || "any"]
+          : null,
+      regex: check.kind === "regex" ? check.regex : null,
+      ulid: ulidRegex,
+      uuid: uuidRegex,
+    }[check.kind];
+  }
+
   protected _resolveRegexWildcardLength(
     minLength: number,
     maxLength: number

From b959cf76909bb7d2231b2bb8b92ade69877ee411 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 22 Mar 2023 20:39:13 +0200
Subject: [PATCH 36/40] rename to `.interpolated` & `.literal`.

---
 README.md                                   |  62 ++---
 deno/lib/README.md                          |  62 ++---
 deno/lib/__tests__/template-literal.test.ts | 246 +++++++++-----------
 deno/lib/types.ts                           |  18 +-
 src/__tests__/template-literal.test.ts      | 246 +++++++++-----------
 src/types.ts                                |   4 +-
 6 files changed, 281 insertions(+), 357 deletions(-)

diff --git a/README.md b/README.md
index ed1e5efd4..ddfccd536 100644
--- a/README.md
+++ b/README.md
@@ -1820,8 +1820,8 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add string literal types to an existing template literal:
 
   ```ts
-  templateLiteral.addLiteral('Hello'); // infers to `Hello`.
-  templateLiteral.addLiteral(3.14); // infers to `3.14`.
+  templateLiteral.literal('Hello'); // infers to `Hello`.
+  templateLiteral.literal(3.14); // infers to `3.14`.
   ```
 
   This method accepts strings, numbers, booleans, nulls and undefined.
@@ -1829,14 +1829,14 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add interpolated positions to an existing template literal:
 
   ```ts
-  templateLiteral.addInterpolatedPosition(z.string()); // infers to `${string}`.
-  templateLiteral.addInterpolatedPosition(z.number()); // infers to `${number}`.
-  templateLiteral.addInterpolatedPosition(z.boolean()); // infers to `true` | `false`.
-  templateLiteral.addInterpolatedPosition(z.literal('foo')); // infers to `foo`.
-  templateLiteral.addInterpolatedPosition(z.null()); // infers to `null`.
-  templateLiteral.addInterpolatedPosition(z.undefined()); // infers to `undefined`.
-  templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
-  templateLiteral.addInterpolatedPosition(z.any()); // infers to `${any}`.
+  templateLiteral.interpolated(z.string()); // infers to `${string}`.
+  templateLiteral.interpolated(z.number()); // infers to `${number}`.
+  templateLiteral.interpolated(z.boolean()); // infers to `true` | `false`.
+  templateLiteral.interpolated(z.literal('foo')); // infers to `foo`.
+  templateLiteral.interpolated(z.null()); // infers to `null`.
+  templateLiteral.interpolated(z.undefined()); // infers to `undefined`.
+  templateLiteral.interpolated(z.bigint()); // infers to `${bigint}`.
+  templateLiteral.interpolated(z.any()); // infers to `${any}`.
   ```
 
   Any Zod type (or union) with an underlying type of string, number, boolean, null, 
@@ -1852,10 +1852,10 @@ URL:
 ```ts
 const url = z
   .templateLiteral()
-  .addLiteral("https://")
-  .addInterpolatedPosition(z.string().min(1))
-  .addLiteral(".")
-  .addInterpolatedPosition(z.enum(["com", "net"]));
+  .literal("https://")
+  .interpolated(z.string().min(1))
+  .literal(".")
+  .interpolated(z.enum(["com", "net"]));
 // infers to `https://${string}.com` | `https://${string}.net`.
 
 url.parse("https://google.com"); // passes
@@ -1872,8 +1872,8 @@ Measurement:
 ```ts
 const measurement = z.coerce
     .templateLiteral()
-    .addInterpolatedPosition(z.number().finite())
-    .addInterpolatedPosition(
+    .interpolated(z.number().finite())
+    .interpolated(
       z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
     );
 // infers to `${number}` | `${number}px` | `${number}em` | `${number}rem` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax
@@ -1884,33 +1884,33 @@ MongoDB connection string:
 ```ts
 const connectionString = z
   .templateLiteral()
-  .addLiteral("mongodb://")
-  .addInterpolatedPosition(
+  .literal("mongodb://")
+  .interpolated(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
-      .addLiteral(":")
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
-      .addLiteral("@")
+      .interpolated(z.string().regex(/\w+/).describe("username"))
+      .literal(":")
+      .interpolated(z.string().regex(/\w+/).describe("password"))
+      .literal("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
-  .addLiteral(":")
-  .addInterpolatedPosition(
+  .interpolated(z.string().regex(/\w+/).describe("host"))
+  .literal(":")
+  .interpolated(
     z.number().finite().int().positive().describe("port")
   )
-  .addInterpolatedPosition(
+  .interpolated(
     z
       .templateLiteral()
-      .addLiteral("/")
-      .addInterpolatedPosition(
+      .literal("/")
+      .interpolated(
         z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
-      .addInterpolatedPosition(
+      .interpolated(
         z
           .templateLiteral()
-          .addLiteral("?")
-          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .literal("?")
+          .interpolated(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
           .describe("options")
       )
diff --git a/deno/lib/README.md b/deno/lib/README.md
index ed1e5efd4..ddfccd536 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -1820,8 +1820,8 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add string literal types to an existing template literal:
 
   ```ts
-  templateLiteral.addLiteral('Hello'); // infers to `Hello`.
-  templateLiteral.addLiteral(3.14); // infers to `3.14`.
+  templateLiteral.literal('Hello'); // infers to `Hello`.
+  templateLiteral.literal(3.14); // infers to `3.14`.
   ```
 
   This method accepts strings, numbers, booleans, nulls and undefined.
@@ -1829,14 +1829,14 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add interpolated positions to an existing template literal:
 
   ```ts
-  templateLiteral.addInterpolatedPosition(z.string()); // infers to `${string}`.
-  templateLiteral.addInterpolatedPosition(z.number()); // infers to `${number}`.
-  templateLiteral.addInterpolatedPosition(z.boolean()); // infers to `true` | `false`.
-  templateLiteral.addInterpolatedPosition(z.literal('foo')); // infers to `foo`.
-  templateLiteral.addInterpolatedPosition(z.null()); // infers to `null`.
-  templateLiteral.addInterpolatedPosition(z.undefined()); // infers to `undefined`.
-  templateLiteral.addInterpolatedPosition(z.bigint()); // infers to `${bigint}`.
-  templateLiteral.addInterpolatedPosition(z.any()); // infers to `${any}`.
+  templateLiteral.interpolated(z.string()); // infers to `${string}`.
+  templateLiteral.interpolated(z.number()); // infers to `${number}`.
+  templateLiteral.interpolated(z.boolean()); // infers to `true` | `false`.
+  templateLiteral.interpolated(z.literal('foo')); // infers to `foo`.
+  templateLiteral.interpolated(z.null()); // infers to `null`.
+  templateLiteral.interpolated(z.undefined()); // infers to `undefined`.
+  templateLiteral.interpolated(z.bigint()); // infers to `${bigint}`.
+  templateLiteral.interpolated(z.any()); // infers to `${any}`.
   ```
 
   Any Zod type (or union) with an underlying type of string, number, boolean, null, 
@@ -1852,10 +1852,10 @@ URL:
 ```ts
 const url = z
   .templateLiteral()
-  .addLiteral("https://")
-  .addInterpolatedPosition(z.string().min(1))
-  .addLiteral(".")
-  .addInterpolatedPosition(z.enum(["com", "net"]));
+  .literal("https://")
+  .interpolated(z.string().min(1))
+  .literal(".")
+  .interpolated(z.enum(["com", "net"]));
 // infers to `https://${string}.com` | `https://${string}.net`.
 
 url.parse("https://google.com"); // passes
@@ -1872,8 +1872,8 @@ Measurement:
 ```ts
 const measurement = z.coerce
     .templateLiteral()
-    .addInterpolatedPosition(z.number().finite())
-    .addInterpolatedPosition(
+    .interpolated(z.number().finite())
+    .interpolated(
       z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
     );
 // infers to `${number}` | `${number}px` | `${number}em` | `${number}rem` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax
@@ -1884,33 +1884,33 @@ MongoDB connection string:
 ```ts
 const connectionString = z
   .templateLiteral()
-  .addLiteral("mongodb://")
-  .addInterpolatedPosition(
+  .literal("mongodb://")
+  .interpolated(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
-      .addLiteral(":")
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
-      .addLiteral("@")
+      .interpolated(z.string().regex(/\w+/).describe("username"))
+      .literal(":")
+      .interpolated(z.string().regex(/\w+/).describe("password"))
+      .literal("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
-  .addLiteral(":")
-  .addInterpolatedPosition(
+  .interpolated(z.string().regex(/\w+/).describe("host"))
+  .literal(":")
+  .interpolated(
     z.number().finite().int().positive().describe("port")
   )
-  .addInterpolatedPosition(
+  .interpolated(
     z
       .templateLiteral()
-      .addLiteral("/")
-      .addInterpolatedPosition(
+      .literal("/")
+      .interpolated(
         z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
-      .addInterpolatedPosition(
+      .interpolated(
         z
           .templateLiteral()
-          .addLiteral("?")
-          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .literal("?")
+          .interpolated(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
           .describe("options")
       )
diff --git a/deno/lib/__tests__/template-literal.test.ts b/deno/lib/__tests__/template-literal.test.ts
index d6d835193..a0932130a 100644
--- a/deno/lib/__tests__/template-literal.test.ts
+++ b/deno/lib/__tests__/template-literal.test.ts
@@ -6,159 +6,127 @@ import { util } from "../helpers/util.ts";
 import * as z from "../index.ts";
 
 const empty = z.templateLiteral();
-const hello = z.templateLiteral().addLiteral("hello");
-const world = z.templateLiteral().addInterpolatedPosition(z.literal("world"));
-const one = z.templateLiteral().addLiteral(1);
-const two = z.templateLiteral().addInterpolatedPosition(z.literal(2));
-const truee = z.templateLiteral().addLiteral(true);
-const anotherTrue = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.literal(true));
-const falsee = z.templateLiteral().addLiteral(false);
-const anotherFalse = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.literal(false));
-const nulll = z.templateLiteral().addLiteral(null);
-const anotherNull = z.templateLiteral().addInterpolatedPosition(z.null());
-const undefinedd = z.templateLiteral().addLiteral(undefined);
-const anotherUndefined = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.undefined());
-const anyString = z.templateLiteral().addInterpolatedPosition(z.string());
-const anyNumber = z.templateLiteral().addInterpolatedPosition(z.number());
-const anyFiniteNumber = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().finite());
-const anyInt = z.templateLiteral().addInterpolatedPosition(z.number().int());
+const hello = z.templateLiteral().literal("hello");
+const world = z.templateLiteral().interpolated(z.literal("world"));
+const one = z.templateLiteral().literal(1);
+const two = z.templateLiteral().interpolated(z.literal(2));
+const truee = z.templateLiteral().literal(true);
+const anotherTrue = z.templateLiteral().interpolated(z.literal(true));
+const falsee = z.templateLiteral().literal(false);
+const anotherFalse = z.templateLiteral().interpolated(z.literal(false));
+const nulll = z.templateLiteral().literal(null);
+const anotherNull = z.templateLiteral().interpolated(z.null());
+const undefinedd = z.templateLiteral().literal(undefined);
+const anotherUndefined = z.templateLiteral().interpolated(z.undefined());
+const anyString = z.templateLiteral().interpolated(z.string());
+const anyNumber = z.templateLiteral().interpolated(z.number());
+const anyFiniteNumber = z.templateLiteral().interpolated(z.number().finite());
+const anyInt = z.templateLiteral().interpolated(z.number().int());
 const anyNegativeNumber = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().negative());
+  .interpolated(z.number().negative());
 const anyPositiveNumber = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().positive());
+  .interpolated(z.number().positive());
 const zeroButInADumbWay = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().nonnegative().nonpositive());
+  .interpolated(z.number().nonnegative().nonpositive());
 const finiteButInADumbWay = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().min(5).max(10));
-const bool = z.templateLiteral().addInterpolatedPosition(z.boolean());
-const bigone = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.literal(BigInt(1)));
-const anyBigint = z.templateLiteral().addInterpolatedPosition(z.bigint());
+  .interpolated(z.number().min(5).max(10));
+const bool = z.templateLiteral().interpolated(z.boolean());
+const bigone = z.templateLiteral().interpolated(z.literal(BigInt(1)));
+const anyBigint = z.templateLiteral().interpolated(z.bigint());
 const nullableYo = z
   .templateLiteral()
-  .addInterpolatedPosition(z.nullable(z.literal("yo")));
-const nullableString = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.nullable(z.string()));
+  .interpolated(z.nullable(z.literal("yo")));
+const nullableString = z.templateLiteral().interpolated(z.nullable(z.string()));
 const optionalYeah = z
   .templateLiteral()
-  .addInterpolatedPosition(z.literal("yeah").optional());
-const optionalString = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().optional());
-const optionalNumber = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().optional());
+  .interpolated(z.literal("yeah").optional());
+const optionalString = z.templateLiteral().interpolated(z.string().optional());
+const optionalNumber = z.templateLiteral().interpolated(z.number().optional());
 const nullishBruh = z
   .templateLiteral()
-  .addInterpolatedPosition(z.literal("bruh").nullish());
-const nullishString = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().nullish());
-const cuid = z.templateLiteral().addInterpolatedPosition(z.string().cuid());
+  .interpolated(z.literal("bruh").nullish());
+const nullishString = z.templateLiteral().interpolated(z.string().nullish());
+const cuid = z.templateLiteral().interpolated(z.string().cuid());
 const cuidZZZ = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().cuid())
-  .addLiteral("ZZZ");
-const cuid2 = z.templateLiteral().addInterpolatedPosition(z.string().cuid2());
-const datetime = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().datetime());
-const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
-const ip = z.templateLiteral().addInterpolatedPosition(z.string().ip());
-const ipv4 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().ip({ version: "v4" }));
-const ipv6 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().ip({ version: "v6" }));
-const ulid = z.templateLiteral().addInterpolatedPosition(z.string().ulid());
-const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
+  .interpolated(z.string().cuid())
+  .literal("ZZZ");
+const cuid2 = z.templateLiteral().interpolated(z.string().cuid2());
+const datetime = z.templateLiteral().interpolated(z.string().datetime());
+const email = z.templateLiteral().interpolated(z.string().email());
+const ip = z.templateLiteral().interpolated(z.string().ip());
+const ipv4 = z.templateLiteral().interpolated(z.string().ip({ version: "v4" }));
+const ipv6 = z.templateLiteral().interpolated(z.string().ip({ version: "v6" }));
+const ulid = z.templateLiteral().interpolated(z.string().ulid());
+const uuid = z.templateLiteral().interpolated(z.string().uuid());
 const stringAToZ = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().regex(/^[a-z]+$/));
+  .interpolated(z.string().regex(/^[a-z]+$/));
 const stringStartsWith = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().startsWith("hello"));
+  .interpolated(z.string().startsWith("hello"));
 const stringEndsWith = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().endsWith("world"));
-const stringMax5 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().max(5));
-const stringMin5 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().min(5));
-const stringLen5 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().length(5));
+  .interpolated(z.string().endsWith("world"));
+const stringMax5 = z.templateLiteral().interpolated(z.string().max(5));
+const stringMin5 = z.templateLiteral().interpolated(z.string().min(5));
+const stringLen5 = z.templateLiteral().interpolated(z.string().length(5));
 const stringMin5Max10 = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().min(5).max(10));
+  .interpolated(z.string().min(5).max(10));
 const stringStartsWithMax5 = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().startsWith("hello").max(5));
+  .interpolated(z.string().startsWith("hello").max(5));
 const brandedString = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().min(1).brand("myBrand"));
-const anything = z.templateLiteral().addInterpolatedPosition(z.any());
+  .interpolated(z.string().min(1).brand("myBrand"));
+const anything = z.templateLiteral().interpolated(z.any());
 
 const url = z
   .templateLiteral()
-  .addLiteral("https://")
-  .addInterpolatedPosition(z.string().regex(/\w+/))
-  .addLiteral(".")
-  .addInterpolatedPosition(z.enum(["com", "net"]));
+  .literal("https://")
+  .interpolated(z.string().regex(/\w+/))
+  .literal(".")
+  .interpolated(z.enum(["com", "net"]));
 
 const measurement = z.coerce
   .templateLiteral()
-  .addInterpolatedPosition(z.number().finite())
-  .addInterpolatedPosition(
+  .interpolated(z.number().finite())
+  .interpolated(
     z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
   );
 
 const connectionString = z
   .templateLiteral()
-  .addLiteral("mongodb://")
-  .addInterpolatedPosition(
+  .literal("mongodb://")
+  .interpolated(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
-      .addLiteral(":")
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
-      .addLiteral("@")
+      .interpolated(z.string().regex(/\w+/).describe("username"))
+      .literal(":")
+      .interpolated(z.string().regex(/\w+/).describe("password"))
+      .literal("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
-  .addLiteral(":")
-  .addInterpolatedPosition(
-    z.number().finite().int().positive().describe("port")
-  )
-  .addInterpolatedPosition(
+  .interpolated(z.string().regex(/\w+/).describe("host"))
+  .literal(":")
+  .interpolated(z.number().finite().int().positive().describe("port"))
+  .interpolated(
     z
       .templateLiteral()
-      .addLiteral("/")
-      .addInterpolatedPosition(
+      .literal("/")
+      .interpolated(
         z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
-      .addInterpolatedPosition(
+      .interpolated(
         z
           .templateLiteral()
-          .addLiteral("?")
-          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .literal("?")
+          .interpolated(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
           .describe("options")
       )
@@ -249,134 +217,128 @@ test("template literal type inference", () => {
 test("template literal unsupported args", () => {
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.object({}))
+    z.templateLiteral().interpolated(z.object({}))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.array(z.object({})))
+    z.templateLiteral().interpolated(z.array(z.object({})))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.union([z.object({}), z.string()])
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.never())
+    z.templateLiteral().interpolated(z.never())
   ).toThrow();
   // @ts-expect-error
-  expect(() => z.templateLiteral().addInterpolatedPosition(z.date())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.date())).toThrow();
   expect(() =>
     z
       .templateLiteral()
       // @ts-expect-error
-      .addInterpolatedPosition(z.custom<object>((data) => true))
+      .interpolated(z.custom<object>((data) => true))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.function())
+    z.templateLiteral().interpolated(z.function())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}))
+    z.templateLiteral().interpolated(z.instanceof(class MyClass {}))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.intersection(z.object({}), z.object({}))
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()))
+    z.templateLiteral().interpolated(z.map(z.string(), z.string()))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})))
+    z.templateLiteral().interpolated(z.nullable(z.object({})))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})))
+    z.templateLiteral().interpolated(z.optional(z.object({})))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.preprocess(() => true, z.boolean())
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.promise())
+    z.templateLiteral().interpolated(z.promise())
   ).toThrow();
   // @ts-expect-error
-  expect(() => z.templateLiteral().addInterpolatedPosition(z.nan())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.nan())).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.pipeline(z.string(), z.string())
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()))
+    z.templateLiteral().interpolated(z.record(z.unknown()))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.set(z.string()))
+    z.templateLiteral().interpolated(z.set(z.string()))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.symbol())
+    z.templateLiteral().interpolated(z.symbol())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]))
+    z.templateLiteral().interpolated(z.tuple([z.string()]))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.unknown())
+    z.templateLiteral().interpolated(z.unknown())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.void())
+    z.templateLiteral().interpolated(z.void())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.lazy(() => z.string()))
+    z.templateLiteral().interpolated(z.lazy(() => z.string()))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.object({}).brand("brand")
     )
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
-  ).toThrow();
-  expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().emoji())
-  ).toThrow();
-  expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().url())
-  ).toThrow();
-  expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().trim())
+    z.templateLiteral().interpolated(z.number().multipleOf(2))
   ).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.string().emoji())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.string().url())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.string().trim())).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().includes("train"))
+    z.templateLiteral().interpolated(z.string().includes("train"))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().toLowerCase())
+    z.templateLiteral().interpolated(z.string().toLowerCase())
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().toUpperCase())
+    z.templateLiteral().interpolated(z.string().toUpperCase())
   ).toThrow();
 });
 
diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index f39cd472b..ece7aa1cf 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -3761,7 +3761,7 @@ export class ZodFunction<
     return this._def.returns;
   }
 
-  args<Items extends Parameters<typeof ZodTuple["create"]>[0]>(
+  args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(
     ...items: Items
   ): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns> {
     return new ZodFunction({
@@ -4785,13 +4785,13 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef
 > {
-  addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
+  interpolated<I extends TemplateLiteralInterpolatedPosition>(
     type: Exclude<I, ZodNever | ZodNaN | ZodPipeline<any, any> | ZodLazy<any>>
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
     return this._addPart(type) as any;
   }
 
-  addLiteral<L extends TemplateLiteralPrimitive>(
+  literal<L extends TemplateLiteralPrimitive>(
     literal: L
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, L>> {
     return this._addPart(literal) as any;
@@ -5303,23 +5303,23 @@ const oboolean = () => booleanType().optional();
 
 export const coerce = {
   string: ((arg) =>
-    ZodString.create({ ...arg, coerce: true })) as typeof ZodString["create"],
+    ZodString.create({ ...arg, coerce: true })) as (typeof ZodString)["create"],
   number: ((arg) =>
-    ZodNumber.create({ ...arg, coerce: true })) as typeof ZodNumber["create"],
+    ZodNumber.create({ ...arg, coerce: true })) as (typeof ZodNumber)["create"],
   boolean: ((arg) =>
     ZodBoolean.create({
       ...arg,
       coerce: true,
-    })) as typeof ZodBoolean["create"],
+    })) as (typeof ZodBoolean)["create"],
   bigint: ((arg) =>
-    ZodBigInt.create({ ...arg, coerce: true })) as typeof ZodBigInt["create"],
+    ZodBigInt.create({ ...arg, coerce: true })) as (typeof ZodBigInt)["create"],
   date: ((arg) =>
-    ZodDate.create({ ...arg, coerce: true })) as typeof ZodDate["create"],
+    ZodDate.create({ ...arg, coerce: true })) as (typeof ZodDate)["create"],
   templateLiteral: ((arg) =>
     ZodTemplateLiteral.create({
       ...arg,
       coerce: true,
-    })) as typeof ZodTemplateLiteral["create"],
+    })) as (typeof ZodTemplateLiteral)["create"],
 };
 
 export {
diff --git a/src/__tests__/template-literal.test.ts b/src/__tests__/template-literal.test.ts
index e4b81d498..b45eb1f5f 100644
--- a/src/__tests__/template-literal.test.ts
+++ b/src/__tests__/template-literal.test.ts
@@ -5,159 +5,127 @@ import { util } from "../helpers/util";
 import * as z from "../index";
 
 const empty = z.templateLiteral();
-const hello = z.templateLiteral().addLiteral("hello");
-const world = z.templateLiteral().addInterpolatedPosition(z.literal("world"));
-const one = z.templateLiteral().addLiteral(1);
-const two = z.templateLiteral().addInterpolatedPosition(z.literal(2));
-const truee = z.templateLiteral().addLiteral(true);
-const anotherTrue = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.literal(true));
-const falsee = z.templateLiteral().addLiteral(false);
-const anotherFalse = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.literal(false));
-const nulll = z.templateLiteral().addLiteral(null);
-const anotherNull = z.templateLiteral().addInterpolatedPosition(z.null());
-const undefinedd = z.templateLiteral().addLiteral(undefined);
-const anotherUndefined = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.undefined());
-const anyString = z.templateLiteral().addInterpolatedPosition(z.string());
-const anyNumber = z.templateLiteral().addInterpolatedPosition(z.number());
-const anyFiniteNumber = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().finite());
-const anyInt = z.templateLiteral().addInterpolatedPosition(z.number().int());
+const hello = z.templateLiteral().literal("hello");
+const world = z.templateLiteral().interpolated(z.literal("world"));
+const one = z.templateLiteral().literal(1);
+const two = z.templateLiteral().interpolated(z.literal(2));
+const truee = z.templateLiteral().literal(true);
+const anotherTrue = z.templateLiteral().interpolated(z.literal(true));
+const falsee = z.templateLiteral().literal(false);
+const anotherFalse = z.templateLiteral().interpolated(z.literal(false));
+const nulll = z.templateLiteral().literal(null);
+const anotherNull = z.templateLiteral().interpolated(z.null());
+const undefinedd = z.templateLiteral().literal(undefined);
+const anotherUndefined = z.templateLiteral().interpolated(z.undefined());
+const anyString = z.templateLiteral().interpolated(z.string());
+const anyNumber = z.templateLiteral().interpolated(z.number());
+const anyFiniteNumber = z.templateLiteral().interpolated(z.number().finite());
+const anyInt = z.templateLiteral().interpolated(z.number().int());
 const anyNegativeNumber = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().negative());
+  .interpolated(z.number().negative());
 const anyPositiveNumber = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().positive());
+  .interpolated(z.number().positive());
 const zeroButInADumbWay = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().nonnegative().nonpositive());
+  .interpolated(z.number().nonnegative().nonpositive());
 const finiteButInADumbWay = z
   .templateLiteral()
-  .addInterpolatedPosition(z.number().min(5).max(10));
-const bool = z.templateLiteral().addInterpolatedPosition(z.boolean());
-const bigone = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.literal(BigInt(1)));
-const anyBigint = z.templateLiteral().addInterpolatedPosition(z.bigint());
+  .interpolated(z.number().min(5).max(10));
+const bool = z.templateLiteral().interpolated(z.boolean());
+const bigone = z.templateLiteral().interpolated(z.literal(BigInt(1)));
+const anyBigint = z.templateLiteral().interpolated(z.bigint());
 const nullableYo = z
   .templateLiteral()
-  .addInterpolatedPosition(z.nullable(z.literal("yo")));
-const nullableString = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.nullable(z.string()));
+  .interpolated(z.nullable(z.literal("yo")));
+const nullableString = z.templateLiteral().interpolated(z.nullable(z.string()));
 const optionalYeah = z
   .templateLiteral()
-  .addInterpolatedPosition(z.literal("yeah").optional());
-const optionalString = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().optional());
-const optionalNumber = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.number().optional());
+  .interpolated(z.literal("yeah").optional());
+const optionalString = z.templateLiteral().interpolated(z.string().optional());
+const optionalNumber = z.templateLiteral().interpolated(z.number().optional());
 const nullishBruh = z
   .templateLiteral()
-  .addInterpolatedPosition(z.literal("bruh").nullish());
-const nullishString = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().nullish());
-const cuid = z.templateLiteral().addInterpolatedPosition(z.string().cuid());
+  .interpolated(z.literal("bruh").nullish());
+const nullishString = z.templateLiteral().interpolated(z.string().nullish());
+const cuid = z.templateLiteral().interpolated(z.string().cuid());
 const cuidZZZ = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().cuid())
-  .addLiteral("ZZZ");
-const cuid2 = z.templateLiteral().addInterpolatedPosition(z.string().cuid2());
-const datetime = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().datetime());
-const email = z.templateLiteral().addInterpolatedPosition(z.string().email());
-const ip = z.templateLiteral().addInterpolatedPosition(z.string().ip());
-const ipv4 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().ip({ version: "v4" }));
-const ipv6 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().ip({ version: "v6" }));
-const ulid = z.templateLiteral().addInterpolatedPosition(z.string().ulid());
-const uuid = z.templateLiteral().addInterpolatedPosition(z.string().uuid());
+  .interpolated(z.string().cuid())
+  .literal("ZZZ");
+const cuid2 = z.templateLiteral().interpolated(z.string().cuid2());
+const datetime = z.templateLiteral().interpolated(z.string().datetime());
+const email = z.templateLiteral().interpolated(z.string().email());
+const ip = z.templateLiteral().interpolated(z.string().ip());
+const ipv4 = z.templateLiteral().interpolated(z.string().ip({ version: "v4" }));
+const ipv6 = z.templateLiteral().interpolated(z.string().ip({ version: "v6" }));
+const ulid = z.templateLiteral().interpolated(z.string().ulid());
+const uuid = z.templateLiteral().interpolated(z.string().uuid());
 const stringAToZ = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().regex(/^[a-z]+$/));
+  .interpolated(z.string().regex(/^[a-z]+$/));
 const stringStartsWith = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().startsWith("hello"));
+  .interpolated(z.string().startsWith("hello"));
 const stringEndsWith = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().endsWith("world"));
-const stringMax5 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().max(5));
-const stringMin5 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().min(5));
-const stringLen5 = z
-  .templateLiteral()
-  .addInterpolatedPosition(z.string().length(5));
+  .interpolated(z.string().endsWith("world"));
+const stringMax5 = z.templateLiteral().interpolated(z.string().max(5));
+const stringMin5 = z.templateLiteral().interpolated(z.string().min(5));
+const stringLen5 = z.templateLiteral().interpolated(z.string().length(5));
 const stringMin5Max10 = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().min(5).max(10));
+  .interpolated(z.string().min(5).max(10));
 const stringStartsWithMax5 = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().startsWith("hello").max(5));
+  .interpolated(z.string().startsWith("hello").max(5));
 const brandedString = z
   .templateLiteral()
-  .addInterpolatedPosition(z.string().min(1).brand("myBrand"));
-const anything = z.templateLiteral().addInterpolatedPosition(z.any());
+  .interpolated(z.string().min(1).brand("myBrand"));
+const anything = z.templateLiteral().interpolated(z.any());
 
 const url = z
   .templateLiteral()
-  .addLiteral("https://")
-  .addInterpolatedPosition(z.string().regex(/\w+/))
-  .addLiteral(".")
-  .addInterpolatedPosition(z.enum(["com", "net"]));
+  .literal("https://")
+  .interpolated(z.string().regex(/\w+/))
+  .literal(".")
+  .interpolated(z.enum(["com", "net"]));
 
 const measurement = z.coerce
   .templateLiteral()
-  .addInterpolatedPosition(z.number().finite())
-  .addInterpolatedPosition(
+  .interpolated(z.number().finite())
+  .interpolated(
     z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
   );
 
 const connectionString = z
   .templateLiteral()
-  .addLiteral("mongodb://")
-  .addInterpolatedPosition(
+  .literal("mongodb://")
+  .interpolated(
     z
       .templateLiteral()
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("username"))
-      .addLiteral(":")
-      .addInterpolatedPosition(z.string().regex(/\w+/).describe("password"))
-      .addLiteral("@")
+      .interpolated(z.string().regex(/\w+/).describe("username"))
+      .literal(":")
+      .interpolated(z.string().regex(/\w+/).describe("password"))
+      .literal("@")
       .optional()
   )
-  .addInterpolatedPosition(z.string().regex(/\w+/).describe("host"))
-  .addLiteral(":")
-  .addInterpolatedPosition(
-    z.number().finite().int().positive().describe("port")
-  )
-  .addInterpolatedPosition(
+  .interpolated(z.string().regex(/\w+/).describe("host"))
+  .literal(":")
+  .interpolated(z.number().finite().int().positive().describe("port"))
+  .interpolated(
     z
       .templateLiteral()
-      .addLiteral("/")
-      .addInterpolatedPosition(
+      .literal("/")
+      .interpolated(
         z.string().regex(/\w+/).optional().describe("defaultauthdb")
       )
-      .addInterpolatedPosition(
+      .interpolated(
         z
           .templateLiteral()
-          .addLiteral("?")
-          .addInterpolatedPosition(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
+          .literal("?")
+          .interpolated(z.string().regex(/^\w+=\w+(&\w+=\w+)*$/))
           .optional()
           .describe("options")
       )
@@ -248,134 +216,128 @@ test("template literal type inference", () => {
 test("template literal unsupported args", () => {
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.object({}))
+    z.templateLiteral().interpolated(z.object({}))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.array(z.object({})))
+    z.templateLiteral().interpolated(z.array(z.object({})))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.union([z.object({}), z.string()])
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.never())
+    z.templateLiteral().interpolated(z.never())
   ).toThrow();
   // @ts-expect-error
-  expect(() => z.templateLiteral().addInterpolatedPosition(z.date())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.date())).toThrow();
   expect(() =>
     z
       .templateLiteral()
       // @ts-expect-error
-      .addInterpolatedPosition(z.custom<object>((data) => true))
+      .interpolated(z.custom<object>((data) => true))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.discriminatedUnion("discriminator", [z.object({}), z.object({})])
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.function())
+    z.templateLiteral().interpolated(z.function())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.instanceof(class MyClass {}))
+    z.templateLiteral().interpolated(z.instanceof(class MyClass {}))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.intersection(z.object({}), z.object({}))
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.map(z.string(), z.string()))
+    z.templateLiteral().interpolated(z.map(z.string(), z.string()))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.nullable(z.object({})))
+    z.templateLiteral().interpolated(z.nullable(z.object({})))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.optional(z.object({})))
+    z.templateLiteral().interpolated(z.optional(z.object({})))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.preprocess(() => true, z.boolean())
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.promise())
+    z.templateLiteral().interpolated(z.promise())
   ).toThrow();
   // @ts-expect-error
-  expect(() => z.templateLiteral().addInterpolatedPosition(z.nan())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.nan())).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.pipeline(z.string(), z.string())
     )
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.record(z.unknown()))
+    z.templateLiteral().interpolated(z.record(z.unknown()))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.set(z.string()))
+    z.templateLiteral().interpolated(z.set(z.string()))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.symbol())
+    z.templateLiteral().interpolated(z.symbol())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.tuple([z.string()]))
+    z.templateLiteral().interpolated(z.tuple([z.string()]))
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.unknown())
+    z.templateLiteral().interpolated(z.unknown())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.void())
+    z.templateLiteral().interpolated(z.void())
   ).toThrow();
   expect(() =>
     // @ts-expect-error
-    z.templateLiteral().addInterpolatedPosition(z.lazy(() => z.string()))
+    z.templateLiteral().interpolated(z.lazy(() => z.string()))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(
+    z.templateLiteral().interpolated(
       // @ts-expect-error
       z.object({}).brand("brand")
     )
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.number().multipleOf(2))
-  ).toThrow();
-  expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().emoji())
-  ).toThrow();
-  expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().url())
-  ).toThrow();
-  expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().trim())
+    z.templateLiteral().interpolated(z.number().multipleOf(2))
   ).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.string().emoji())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.string().url())).toThrow();
+  expect(() => z.templateLiteral().interpolated(z.string().trim())).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().includes("train"))
+    z.templateLiteral().interpolated(z.string().includes("train"))
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().toLowerCase())
+    z.templateLiteral().interpolated(z.string().toLowerCase())
   ).toThrow();
   expect(() =>
-    z.templateLiteral().addInterpolatedPosition(z.string().toUpperCase())
+    z.templateLiteral().interpolated(z.string().toUpperCase())
   ).toThrow();
 });
 
diff --git a/src/types.ts b/src/types.ts
index 6f01ef901..d5c7ceda4 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4785,13 +4785,13 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
   Template,
   ZodTemplateLiteralDef
 > {
-  addInterpolatedPosition<I extends TemplateLiteralInterpolatedPosition>(
+  interpolated<I extends TemplateLiteralInterpolatedPosition>(
     type: Exclude<I, ZodNever | ZodNaN | ZodPipeline<any, any> | ZodLazy<any>>
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, I>> {
     return this._addPart(type) as any;
   }
 
-  addLiteral<L extends TemplateLiteralPrimitive>(
+  literal<L extends TemplateLiteralPrimitive>(
     literal: L
   ): ZodTemplateLiteral<appendToTemplateLiteral<Template, L>> {
     return this._addPart(literal) as any;

From 30d6ca71eb0b8e289b9bc807a27bbb3648489794 Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Wed, 22 Mar 2023 20:40:48 +0200
Subject: [PATCH 37/40] rename to `.interpolated` & `.literal` pt. 2.

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

diff --git a/deno/lib/__tests__/coerce.test.ts b/deno/lib/__tests__/coerce.test.ts
index 6d6a9bb2f..67d58fdd6 100644
--- a/deno/lib/__tests__/coerce.test.ts
+++ b/deno/lib/__tests__/coerce.test.ts
@@ -137,8 +137,8 @@ test("date coercion", () => {
 test("template literal coercion", () => {
   const schema = z.coerce
     .templateLiteral()
-    .addInterpolatedPosition(z.number().finite())
-    .addInterpolatedPosition(
+    .interpolated(z.number().finite())
+    .interpolated(
       z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
     );
   expect(schema.parse(300)).toEqual("300");
diff --git a/src/__tests__/coerce.test.ts b/src/__tests__/coerce.test.ts
index addba645b..4cdeab76a 100644
--- a/src/__tests__/coerce.test.ts
+++ b/src/__tests__/coerce.test.ts
@@ -136,8 +136,8 @@ test("date coercion", () => {
 test("template literal coercion", () => {
   const schema = z.coerce
     .templateLiteral()
-    .addInterpolatedPosition(z.number().finite())
-    .addInterpolatedPosition(
+    .interpolated(z.number().finite())
+    .interpolated(
       z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
     );
   expect(schema.parse(300)).toEqual("300");

From b949f2a6f41d890eddf213b5d76039c8196f3f40 Mon Sep 17 00:00:00 2001
From: Igal Klebanov <igalklebanov@gmail.com>
Date: Tue, 23 May 2023 01:25:38 +0300
Subject: [PATCH 38/40] handle case insensitive regexes.

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

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
index c0d037855..865c89830 100644
--- a/deno/lib/types.ts
+++ b/deno/lib/types.ts
@@ -4872,7 +4872,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     regexString: string,
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
-    return `^${this._unwrapRegexString(
+    return `^${this._unwrapRegExp(
       regexString
     )}${this._transformPartToRegexString(part)}$`;
   }
@@ -4916,7 +4916,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     }
 
     if (part instanceof ZodTemplateLiteral) {
-      return this._unwrapRegexString(part._def.regexString);
+      return this._unwrapRegExp(part._def.regexString);
     }
 
     if (part instanceof ZodBigInt) {
@@ -4968,7 +4968,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       const regex = this._resolveRegexForStringCheck(ch);
 
       if (regex) {
-        return this._unwrapRegexString(regex.source);
+        return this._unwrapRegExp(regex);
       }
 
       if (ch.kind === "endsWith") {
@@ -5021,9 +5021,9 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         check.kind === "ip"
           ? {
               any: new RegExp(
-                `^(${this._unwrapRegexString(
+                `^(${this._unwrapRegExp(
                   ipv4Regex.source
-                )})|(${this._unwrapRegexString(ipv6Regex.source)})$`
+                )})|(${this._unwrapRegExp(ipv6Regex.source)})$`
               ),
               v4: ipv4Regex,
               v6: ipv6Regex,
@@ -5139,8 +5139,60 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return acc;
   }
 
-  protected _unwrapRegexString(regexString: string): string {
-    return regexString.replace(/(^\^)|(\$$)/g, "");
+  protected _unwrapRegExp(regex: RegExp | string): string {
+    const flags = typeof regex === "string" ? "" : regex.flags;
+    const source = typeof regex === "string" ? regex : regex.source;
+
+    if (flags.includes("i")) {
+      return this._unwrapRegExp(this._makeRegexStringCaseInsensitive(source));
+    }
+
+    return source.replace(/(^\^)|(\$$)/g, "");
+  }
+
+  protected _makeRegexStringCaseInsensitive(regexString: string): string {
+    const isAlphabetic = (char: string) => char.match(/[a-z]/i) != null;
+
+    let caseInsensitive = "";
+    let inCharacterSet = false;
+    for (let i = 0; i < regexString.length; i++) {
+      const char = regexString.charAt(i);
+      const nextChar = regexString.charAt(i + 1);
+
+      if (char === "\\") {
+        caseInsensitive += `${char}${nextChar}`;
+        i++;
+        continue;
+      }
+
+      if (char === "[") {
+        inCharacterSet = true;
+      } else if (inCharacterSet && char === "]") {
+        inCharacterSet = false;
+      }
+
+      if (!isAlphabetic(char)) {
+        caseInsensitive += char;
+        continue;
+      }
+
+      if (!inCharacterSet) {
+        caseInsensitive += `[${char.toLowerCase()}${char.toUpperCase()}]`;
+        continue;
+      }
+
+      const charAfterNext = regexString.charAt(i + 2);
+
+      if (nextChar !== "-" || !isAlphabetic(charAfterNext)) {
+        caseInsensitive += `${char.toLowerCase()}${char.toUpperCase()}`;
+        continue;
+      }
+
+      caseInsensitive += `${char.toLowerCase()}-${charAfterNext.toLowerCase()}${char.toUpperCase()}-${charAfterNext.toUpperCase()}`;
+      i += 2;
+    }
+
+    return caseInsensitive;
   }
 
   protected _escapeRegExp(str: unknown): string {
diff --git a/src/types.ts b/src/types.ts
index dfd1ffef3..5607644b5 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4872,7 +4872,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     regexString: string,
     part: TemplateLiteralPrimitive | TemplateLiteralInterpolatedPosition
   ): string {
-    return `^${this._unwrapRegexString(
+    return `^${this._unwrapRegExp(
       regexString
     )}${this._transformPartToRegexString(part)}$`;
   }
@@ -4916,7 +4916,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     }
 
     if (part instanceof ZodTemplateLiteral) {
-      return this._unwrapRegexString(part._def.regexString);
+      return this._unwrapRegExp(part._def.regexString);
     }
 
     if (part instanceof ZodBigInt) {
@@ -4968,7 +4968,7 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
       const regex = this._resolveRegexForStringCheck(ch);
 
       if (regex) {
-        return this._unwrapRegexString(regex.source);
+        return this._unwrapRegExp(regex);
       }
 
       if (ch.kind === "endsWith") {
@@ -5021,9 +5021,9 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
         check.kind === "ip"
           ? {
               any: new RegExp(
-                `^(${this._unwrapRegexString(
+                `^(${this._unwrapRegExp(
                   ipv4Regex.source
-                )})|(${this._unwrapRegexString(ipv6Regex.source)})$`
+                )})|(${this._unwrapRegExp(ipv6Regex.source)})$`
               ),
               v4: ipv4Regex,
               v6: ipv6Regex,
@@ -5139,8 +5139,60 @@ export class ZodTemplateLiteral<Template extends string = ""> extends ZodType<
     return acc;
   }
 
-  protected _unwrapRegexString(regexString: string): string {
-    return regexString.replace(/(^\^)|(\$$)/g, "");
+  protected _unwrapRegExp(regex: RegExp | string): string {
+    const flags = typeof regex === "string" ? "" : regex.flags;
+    const source = typeof regex === "string" ? regex : regex.source;
+
+    if (flags.includes("i")) {
+      return this._unwrapRegExp(this._makeRegexStringCaseInsensitive(source));
+    }
+
+    return source.replace(/(^\^)|(\$$)/g, "");
+  }
+
+  protected _makeRegexStringCaseInsensitive(regexString: string): string {
+    const isAlphabetic = (char: string) => char.match(/[a-z]/i) != null;
+
+    let caseInsensitive = "";
+    let inCharacterSet = false;
+    for (let i = 0; i < regexString.length; i++) {
+      const char = regexString.charAt(i);
+      const nextChar = regexString.charAt(i + 1);
+
+      if (char === "\\") {
+        caseInsensitive += `${char}${nextChar}`;
+        i++;
+        continue;
+      }
+
+      if (char === "[") {
+        inCharacterSet = true;
+      } else if (inCharacterSet && char === "]") {
+        inCharacterSet = false;
+      }
+
+      if (!isAlphabetic(char)) {
+        caseInsensitive += char;
+        continue;
+      }
+
+      if (!inCharacterSet) {
+        caseInsensitive += `[${char.toLowerCase()}${char.toUpperCase()}]`;
+        continue;
+      }
+
+      const charAfterNext = regexString.charAt(i + 2);
+
+      if (nextChar !== "-" || !isAlphabetic(charAfterNext)) {
+        caseInsensitive += `${char.toLowerCase()}${char.toUpperCase()}`;
+        continue;
+      }
+
+      caseInsensitive += `${char.toLowerCase()}-${charAfterNext.toLowerCase()}${char.toUpperCase()}-${charAfterNext.toUpperCase()}`;
+      i += 2;
+    }
+
+    return caseInsensitive;
   }
 
   protected _escapeRegExp(str: unknown): string {

From 0253718a0bbd75b60e3fa2decff5eab6ea41fbdb Mon Sep 17 00:00:00 2001
From: igalklebanov <igalklebanov@gmail.com>
Date: Fri, 1 Dec 2023 01:28:44 +0200
Subject: [PATCH 39/40] prettier the readme.

---
 README.md | 50 ++++++++++++++++++++++++--------------------------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/README.md b/README.md
index b8488f9e2..68ba566a5 100644
--- a/README.md
+++ b/README.md
@@ -1877,7 +1877,7 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add string literal types to an existing template literal:
 
   ```ts
-  templateLiteral.literal('Hello'); // infers to `Hello`.
+  templateLiteral.literal("Hello"); // infers to `Hello`.
   templateLiteral.literal(3.14); // infers to `3.14`.
   ```
 
@@ -1889,17 +1889,17 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
   templateLiteral.interpolated(z.string()); // infers to `${string}`.
   templateLiteral.interpolated(z.number()); // infers to `${number}`.
   templateLiteral.interpolated(z.boolean()); // infers to `true` | `false`.
-  templateLiteral.interpolated(z.literal('foo')); // infers to `foo`.
+  templateLiteral.interpolated(z.literal("foo")); // infers to `foo`.
   templateLiteral.interpolated(z.null()); // infers to `null`.
   templateLiteral.interpolated(z.undefined()); // infers to `undefined`.
   templateLiteral.interpolated(z.bigint()); // infers to `${bigint}`.
   templateLiteral.interpolated(z.any()); // infers to `${any}`.
   ```
 
-  Any Zod type (or union) with an underlying type of string, number, boolean, null, 
-  undefined or bigint can be used as an interpolated position (template literals 
-  included!). You can use additional built-in runtime validations (refinements 
-  excluded) in each of these types and the template literal builder will do its 
+  Any Zod type (or union) with an underlying type of string, number, boolean, null,
+  undefined or bigint can be used as an interpolated position (template literals
+  included!). You can use additional built-in runtime validations (refinements
+  excluded) in each of these types and the template literal builder will do its
   best (within the limitations of regular expressions) to support them when parsing.
 
 ### Examples
@@ -1917,22 +1917,22 @@ const url = z
 
 url.parse("https://google.com"); // passes
 url.parse("https://google.net"); // passes
-url.parse('http://google.com'); // throws
-url.parse('https://.com'); // throws
-url.parse('https://google'); // throws
-url.parse('https://google.'); // throws
-url.parse('https://google.gov'); // throws
+url.parse("http://google.com"); // throws
+url.parse("https://.com"); // throws
+url.parse("https://google"); // throws
+url.parse("https://google."); // throws
+url.parse("https://google.gov"); // throws
 ```
 
 Measurement:
 
 ```ts
 const measurement = z.coerce
-    .templateLiteral()
-    .interpolated(z.number().finite())
-    .interpolated(
-      z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
-    );
+  .templateLiteral()
+  .interpolated(z.number().finite())
+  .interpolated(
+    z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+  );
 // infers to `${number}` | `${number}px` | `${number}em` | `${number}rem` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax
 ```
 
@@ -1953,9 +1953,7 @@ const connectionString = z
   )
   .interpolated(z.string().regex(/\w+/).describe("host"))
   .literal(":")
-  .interpolated(
-    z.number().finite().int().positive().describe("port")
-  )
+  .interpolated(z.number().finite().int().positive().describe("port"))
   .interpolated(
     z
       .templateLiteral()
@@ -1973,13 +1971,13 @@ const connectionString = z
       )
       .optional()
   );
-  // infers to:
-  // | `mongodb://${string}:${number}`
-  // | `mongodb://${string}:${number}/${string}`
-  // | `mongodb://${string}:${number}/${string}?${string}`
-  // | `mongodb://${string}:${string}@${string}:${number}`
-  // | `mongodb://${string}:${string}@${string}:${number}/${string}`
-  // | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
+// infers to:
+// | `mongodb://${string}:${number}`
+// | `mongodb://${string}:${number}/${string}`
+// | `mongodb://${string}:${number}/${string}?${string}`
+// | `mongodb://${string}:${string}@${string}:${number}`
+// | `mongodb://${string}:${string}@${string}:${number}/${string}`
+// | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
 ```
 
 ## Preprocess

From 1ce249c5e6d122b152ca4bfea4287d39f3333e05 Mon Sep 17 00:00:00 2001
From: Charles Catta <charles.catta@botpress.com>
Date: Wed, 3 Apr 2024 15:30:32 -0400
Subject: [PATCH 40/40] fix dulicate case in merge

---
 deno/lib/README.md               | 50 +++++++++++++++-----------------
 src/__tests__/firstparty.test.ts |  2 --
 2 files changed, 24 insertions(+), 28 deletions(-)

diff --git a/deno/lib/README.md b/deno/lib/README.md
index 39cd76e73..d892d799c 100644
--- a/deno/lib/README.md
+++ b/deno/lib/README.md
@@ -2036,7 +2036,7 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
 - To add string literal types to an existing template literal:
 
   ```ts
-  templateLiteral.literal('Hello'); // infers to `Hello`.
+  templateLiteral.literal("Hello"); // infers to `Hello`.
   templateLiteral.literal(3.14); // infers to `3.14`.
   ```
 
@@ -2048,17 +2048,17 @@ const templateLiteral = z.templateLiteral(); // infers to ``.
   templateLiteral.interpolated(z.string()); // infers to `${string}`.
   templateLiteral.interpolated(z.number()); // infers to `${number}`.
   templateLiteral.interpolated(z.boolean()); // infers to `true` | `false`.
-  templateLiteral.interpolated(z.literal('foo')); // infers to `foo`.
+  templateLiteral.interpolated(z.literal("foo")); // infers to `foo`.
   templateLiteral.interpolated(z.null()); // infers to `null`.
   templateLiteral.interpolated(z.undefined()); // infers to `undefined`.
   templateLiteral.interpolated(z.bigint()); // infers to `${bigint}`.
   templateLiteral.interpolated(z.any()); // infers to `${any}`.
   ```
 
-  Any Zod type (or union) with an underlying type of string, number, boolean, null, 
-  undefined or bigint can be used as an interpolated position (template literals 
-  included!). You can use additional built-in runtime validations (refinements 
-  excluded) in each of these types and the template literal builder will do its 
+  Any Zod type (or union) with an underlying type of string, number, boolean, null,
+  undefined or bigint can be used as an interpolated position (template literals
+  included!). You can use additional built-in runtime validations (refinements
+  excluded) in each of these types and the template literal builder will do its
   best (within the limitations of regular expressions) to support them when parsing.
 
 ### Examples
@@ -2076,22 +2076,22 @@ const url = z
 
 url.parse("https://google.com"); // passes
 url.parse("https://google.net"); // passes
-url.parse('http://google.com'); // throws
-url.parse('https://.com'); // throws
-url.parse('https://google'); // throws
-url.parse('https://google.'); // throws
-url.parse('https://google.gov'); // throws
+url.parse("http://google.com"); // throws
+url.parse("https://.com"); // throws
+url.parse("https://google"); // throws
+url.parse("https://google."); // throws
+url.parse("https://google.gov"); // throws
 ```
 
 Measurement:
 
 ```ts
 const measurement = z.coerce
-    .templateLiteral()
-    .interpolated(z.number().finite())
-    .interpolated(
-      z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
-    );
+  .templateLiteral()
+  .interpolated(z.number().finite())
+  .interpolated(
+    z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
+  );
 // infers to `${number}` | `${number}px` | `${number}em` | `${number}rem` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax
 ```
 
@@ -2112,9 +2112,7 @@ const connectionString = z
   )
   .interpolated(z.string().regex(/\w+/).describe("host"))
   .literal(":")
-  .interpolated(
-    z.number().finite().int().positive().describe("port")
-  )
+  .interpolated(z.number().finite().int().positive().describe("port"))
   .interpolated(
     z
       .templateLiteral()
@@ -2132,13 +2130,13 @@ const connectionString = z
       )
       .optional()
   );
-  // infers to:
-  // | `mongodb://${string}:${number}`
-  // | `mongodb://${string}:${number}/${string}`
-  // | `mongodb://${string}:${number}/${string}?${string}`
-  // | `mongodb://${string}:${string}@${string}:${number}`
-  // | `mongodb://${string}:${string}@${string}:${number}/${string}`
-  // | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
+// infers to:
+// | `mongodb://${string}:${number}`
+// | `mongodb://${string}:${number}/${string}`
+// | `mongodb://${string}:${number}/${string}?${string}`
+// | `mongodb://${string}:${string}@${string}:${number}`
+// | `mongodb://${string}:${string}@${string}:${number}/${string}`
+// | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
 ```
 
 ## Preprocess
diff --git a/src/__tests__/firstparty.test.ts b/src/__tests__/firstparty.test.ts
index 3f7c71d3b..e47601cb0 100644
--- a/src/__tests__/firstparty.test.ts
+++ b/src/__tests__/firstparty.test.ts
@@ -83,8 +83,6 @@ test("first party switch", () => {
       break;
     case z.ZodFirstPartyTypeKind.ZodTemplateLiteral:
       break;
-    case z.ZodFirstPartyTypeKind.ZodReadonly:
-      break;
     default:
       util.assertNever(def);
   }