zod 4.0.0 → 4.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/package.json +1 -1
  2. package/src/v4/core/api.ts +79 -89
  3. package/src/v4/core/schemas.ts +2 -1
  4. package/v4/core/api.d.cts +72 -72
  5. package/v4/core/api.d.ts +72 -72
  6. package/v4/core/schemas.cjs +1 -1
  7. package/v4/core/schemas.d.cts +1 -0
  8. package/v4/core/schemas.d.ts +1 -0
  9. package/v4/core/schemas.js +1 -1
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "zod",
3
- "version": "4.0.0",
3
+ "version": "4.0.1",
4
4
  "type": "module",
5
5
  "author": "Colin McDonnell <zod@colinhacks.com>",
6
6
  "description": "TypeScript-first schema declaration and validation library with static type inference",
package/src/v4/core/api.ts CHANGED
@@ -79,13 +79,16 @@ export function _coercedString<T extends schemas.$ZodString>(
79
79
  });
80
80
  }
81
81
 
82
- export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce">;
82
+ export type $ZodStringFormatParams = CheckTypeParams<
83
+ schemas.$ZodStringFormat,
84
+ "format" | "coerce" | "when" | "pattern"
85
+ >;
83
86
  export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
84
87
  // custom format
85
88
 
86
89
  // Email
87
- export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail>;
88
- export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail>;
90
+ export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
91
+ export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
89
92
  export function _email<T extends schemas.$ZodEmail>(
90
93
  Class: util.SchemaClass<T>,
91
94
  params?: string | $ZodEmailParams | $ZodCheckEmailParams
@@ -100,8 +103,8 @@ export function _email<T extends schemas.$ZodEmail>(
100
103
  }
101
104
 
102
105
  // GUID
103
- export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern">;
104
- export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern">;
106
+ export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
107
+ export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
105
108
  export function _guid<T extends schemas.$ZodGUID>(
106
109
  Class: util.SchemaClass<T>,
107
110
  params?: string | $ZodGUIDParams | $ZodCheckGUIDParams
@@ -116,8 +119,8 @@ export function _guid<T extends schemas.$ZodGUID>(
116
119
  }
117
120
 
118
121
  // UUID
119
- export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern">;
120
- export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
122
+ export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
123
+ export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
121
124
  export function _uuid<T extends schemas.$ZodUUID>(
122
125
  Class: util.SchemaClass<T>,
123
126
  params?: string | $ZodUUIDParams | $ZodCheckUUIDParams
@@ -132,8 +135,8 @@ export function _uuid<T extends schemas.$ZodUUID>(
132
135
  }
133
136
 
134
137
  // UUIDv4
135
- export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
136
- export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
138
+ export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
139
+ export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
137
140
  export function _uuidv4<T extends schemas.$ZodUUID>(
138
141
  Class: util.SchemaClass<T>,
139
142
  params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params
@@ -149,8 +152,8 @@ export function _uuidv4<T extends schemas.$ZodUUID>(
149
152
  }
150
153
 
151
154
  // UUIDv6
152
- export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
153
- export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
155
+ export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
156
+ export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
154
157
  export function _uuidv6<T extends schemas.$ZodUUID>(
155
158
  Class: util.SchemaClass<T>,
156
159
  params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params
@@ -166,8 +169,8 @@ export function _uuidv6<T extends schemas.$ZodUUID>(
166
169
  }
167
170
 
168
171
  // UUIDv7
169
- export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
170
- export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
172
+ export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
173
+ export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
171
174
  export function _uuidv7<T extends schemas.$ZodUUID>(
172
175
  Class: util.SchemaClass<T>,
173
176
  params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params
@@ -183,8 +186,8 @@ export function _uuidv7<T extends schemas.$ZodUUID>(
183
186
  }
184
187
 
185
188
  // URL
186
- export type $ZodURLParams = StringFormatParams<schemas.$ZodURL>;
187
- export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL>;
189
+ export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
190
+ export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
188
191
  export function _url<T extends schemas.$ZodURL>(
189
192
  Class: util.SchemaClass<T>,
190
193
  params?: string | $ZodURLParams | $ZodCheckURLParams
@@ -199,8 +202,8 @@ export function _url<T extends schemas.$ZodURL>(
199
202
  }
200
203
 
201
204
  // Emoji
202
- export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji>;
203
- export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji>;
205
+ export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
206
+ export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
204
207
  export function _emoji<T extends schemas.$ZodEmoji>(
205
208
  Class: util.SchemaClass<T>,
206
209
  params?: string | $ZodEmojiParams | $ZodCheckEmojiParams
@@ -215,8 +218,8 @@ export function _emoji<T extends schemas.$ZodEmoji>(
215
218
  }
216
219
 
217
220
  // NanoID
218
- export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID>;
219
- export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID>;
221
+ export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
222
+ export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
220
223
  export function _nanoid<T extends schemas.$ZodNanoID>(
221
224
  Class: util.SchemaClass<T>,
222
225
  params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams
@@ -231,8 +234,8 @@ export function _nanoid<T extends schemas.$ZodNanoID>(
231
234
  }
232
235
 
233
236
  // CUID
234
- export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID>;
235
- export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID>;
237
+ export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
238
+ export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
236
239
  export function _cuid<T extends schemas.$ZodCUID>(
237
240
  Class: util.SchemaClass<T>,
238
241
  params?: string | $ZodCUIDParams | $ZodCheckCUIDParams
@@ -247,8 +250,8 @@ export function _cuid<T extends schemas.$ZodCUID>(
247
250
  }
248
251
 
249
252
  // CUID2
250
- export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2>;
251
- export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2>;
253
+ export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
254
+ export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
252
255
  export function _cuid2<T extends schemas.$ZodCUID2>(
253
256
  Class: util.SchemaClass<T>,
254
257
  params?: string | $ZodCUID2Params | $ZodCheckCUID2Params
@@ -263,8 +266,8 @@ export function _cuid2<T extends schemas.$ZodCUID2>(
263
266
  }
264
267
 
265
268
  // ULID
266
- export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID>;
267
- export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID>;
269
+ export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
270
+ export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
268
271
  export function _ulid<T extends schemas.$ZodULID>(
269
272
  Class: util.SchemaClass<T>,
270
273
  params?: string | $ZodULIDParams | $ZodCheckULIDParams
@@ -279,8 +282,8 @@ export function _ulid<T extends schemas.$ZodULID>(
279
282
  }
280
283
 
281
284
  // XID
282
- export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID>;
283
- export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID>;
285
+ export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
286
+ export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
284
287
  export function _xid<T extends schemas.$ZodXID>(
285
288
  Class: util.SchemaClass<T>,
286
289
  params?: string | $ZodXIDParams | $ZodCheckXIDParams
@@ -295,8 +298,8 @@ export function _xid<T extends schemas.$ZodXID>(
295
298
  }
296
299
 
297
300
  // KSUID
298
- export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID>;
299
- export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID>;
301
+ export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
302
+ export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
300
303
  export function _ksuid<T extends schemas.$ZodKSUID>(
301
304
  Class: util.SchemaClass<T>,
302
305
  params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams
@@ -310,25 +313,9 @@ export function _ksuid<T extends schemas.$ZodKSUID>(
310
313
  });
311
314
  }
312
315
 
313
- // IP
314
- // export type $ZodIPParams = StringFormatParams<schemas.$ZodIP, "pattern">;
315
- // export type $ZodCheckIPParams = CheckStringFormatParams<schemas.$ZodIP, "pattern">;
316
- // export function _ip<T extends schemas.$ZodIP>(
317
- // Class: util.SchemaClass<T>,
318
- // params?: string | $ZodIPParams | $ZodCheckIPParams
319
- // ): T {
320
- // return new Class({
321
- // type: "string",
322
- // format: "ip",
323
- // check: "string_format",
324
- // abort: false,
325
- // ...util.normalizeParams(params),
326
- // });
327
- // }
328
-
329
316
  // IPv4
330
- export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern">;
331
- export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern">;
317
+ export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
318
+ export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
332
319
  export function _ipv4<T extends schemas.$ZodIPv4>(
333
320
  Class: util.SchemaClass<T>,
334
321
  params?: string | $ZodIPv4Params | $ZodCheckIPv4Params
@@ -343,8 +330,8 @@ export function _ipv4<T extends schemas.$ZodIPv4>(
343
330
  }
344
331
 
345
332
  // IPv6
346
- export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern">;
347
- export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern">;
333
+ export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
334
+ export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
348
335
  export function _ipv6<T extends schemas.$ZodIPv6>(
349
336
  Class: util.SchemaClass<T>,
350
337
  params?: string | $ZodIPv6Params | $ZodCheckIPv6Params
@@ -359,8 +346,8 @@ export function _ipv6<T extends schemas.$ZodIPv6>(
359
346
  }
360
347
 
361
348
  // CIDRv4
362
- export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern">;
363
- export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern">;
349
+ export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
350
+ export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
364
351
  export function _cidrv4<T extends schemas.$ZodCIDRv4>(
365
352
  Class: util.SchemaClass<T>,
366
353
  params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params
@@ -375,8 +362,8 @@ export function _cidrv4<T extends schemas.$ZodCIDRv4>(
375
362
  }
376
363
 
377
364
  // CIDRv6
378
- export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern">;
379
- export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern">;
365
+ export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
366
+ export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
380
367
  export function _cidrv6<T extends schemas.$ZodCIDRv6>(
381
368
  Class: util.SchemaClass<T>,
382
369
  params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params
@@ -391,8 +378,8 @@ export function _cidrv6<T extends schemas.$ZodCIDRv6>(
391
378
  }
392
379
 
393
380
  // Base64
394
- export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern">;
395
- export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern">;
381
+ export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
382
+ export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
396
383
  export function _base64<T extends schemas.$ZodBase64>(
397
384
  Class: util.SchemaClass<T>,
398
385
  params?: string | $ZodBase64Params | $ZodCheckBase64Params
@@ -407,8 +394,8 @@ export function _base64<T extends schemas.$ZodBase64>(
407
394
  }
408
395
 
409
396
  // base64url
410
- export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern">;
411
- export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern">;
397
+ export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
398
+ export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
412
399
  export function _base64url<T extends schemas.$ZodBase64URL>(
413
400
  Class: util.SchemaClass<T>,
414
401
  params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams
@@ -423,8 +410,8 @@ export function _base64url<T extends schemas.$ZodBase64URL>(
423
410
  }
424
411
 
425
412
  // E164
426
- export type $ZodE164Params = StringFormatParams<schemas.$ZodE164>;
427
- export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164>;
413
+ export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
414
+ export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
428
415
  export function _e164<T extends schemas.$ZodE164>(
429
416
  Class: util.SchemaClass<T>,
430
417
  params?: string | $ZodE164Params | $ZodCheckE164Params
@@ -439,8 +426,8 @@ export function _e164<T extends schemas.$ZodE164>(
439
426
  }
440
427
 
441
428
  // JWT
442
- export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern">;
443
- export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern">;
429
+ export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
430
+ export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
444
431
  export function _jwt<T extends schemas.$ZodJWT>(
445
432
  Class: util.SchemaClass<T>,
446
433
  params?: string | $ZodJWTParams | $ZodCheckJWTParams
@@ -462,8 +449,8 @@ export const TimePrecision = {
462
449
  Microsecond: 6,
463
450
  } as const;
464
451
  // ISODateTime
465
- export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern">;
466
- export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern">;
452
+ export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
453
+ export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
467
454
  export function _isoDateTime<T extends schemas.$ZodISODateTime>(
468
455
  Class: util.SchemaClass<T>,
469
456
  params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams
@@ -480,8 +467,8 @@ export function _isoDateTime<T extends schemas.$ZodISODateTime>(
480
467
  }
481
468
 
482
469
  // ISODate
483
- export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern">;
484
- export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern">;
470
+ export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
471
+ export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
485
472
  export function _isoDate<T extends schemas.$ZodISODate>(
486
473
  Class: util.SchemaClass<T>,
487
474
  params?: string | $ZodISODateParams | $ZodCheckISODateParams
@@ -495,8 +482,8 @@ export function _isoDate<T extends schemas.$ZodISODate>(
495
482
  }
496
483
 
497
484
  // ISOTime
498
- export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern">;
499
- export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern">;
485
+ export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
486
+ export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
500
487
  export function _isoTime<T extends schemas.$ZodISOTime>(
501
488
  Class: util.SchemaClass<T>,
502
489
  params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams
@@ -511,8 +498,8 @@ export function _isoTime<T extends schemas.$ZodISOTime>(
511
498
  }
512
499
 
513
500
  // ISODuration
514
- export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration>;
515
- export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration>;
501
+ export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
502
+ export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
516
503
  export function _isoDuration<T extends schemas.$ZodISODuration>(
517
504
  Class: util.SchemaClass<T>,
518
505
  params?: string | $ZodISODurationParams | $ZodCheckISODurationParams
@@ -528,7 +515,7 @@ export function _isoDuration<T extends schemas.$ZodISODuration>(
528
515
  // Number
529
516
  export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
530
517
  export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
531
- export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format">;
518
+ export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
532
519
  export function _number<T extends schemas.$ZodNumber>(
533
520
  Class: util.SchemaClass<T>,
534
521
  params?: string | $ZodNumberParams
@@ -638,7 +625,7 @@ export function _coercedBoolean<T extends schemas.$ZodBoolean>(
638
625
  // BigInt
639
626
  export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
640
627
  export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
641
- export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format">;
628
+ export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
642
629
  export function _bigint<T extends schemas.$ZodBigInt>(
643
630
  Class: util.SchemaClass<T>,
644
631
  params?: string | $ZodBigIntParams
@@ -779,9 +766,9 @@ export function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, para
779
766
  });
780
767
  }
781
768
 
782
- // export type $ZodCheckParams = CheckParams<checks.$ZodCheck, "abort">;
769
+ // export type $ZodCheckParams = CheckParams<checks.$ZodCheck, "abort" | "when">;
783
770
 
784
- export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value">;
771
+ export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
785
772
  export function _lt(
786
773
  value: util.Numeric,
787
774
  params?: string | $ZodCheckLessThanParams
@@ -812,7 +799,7 @@ export {
812
799
  };
813
800
 
814
801
  // ZodCheckGreaterThan
815
- export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value">;
802
+ export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
816
803
  export function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
817
804
  return new checks.$ZodCheckGreaterThan({
818
805
  check: "greater_than",
@@ -856,7 +843,7 @@ export function _nonnegative(params?: string | $ZodCheckGreaterThanParams): chec
856
843
  return _gte(0, params);
857
844
  }
858
845
 
859
- export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value">;
846
+ export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
860
847
  export function _multipleOf(
861
848
  value: number | bigint,
862
849
  params?: string | $ZodCheckMultipleOfParams
@@ -868,7 +855,7 @@ export function _multipleOf(
868
855
  });
869
856
  }
870
857
 
871
- export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum">;
858
+ export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
872
859
  export function _maxSize(
873
860
  maximum: number,
874
861
  params?: string | $ZodCheckMaxSizeParams
@@ -880,7 +867,7 @@ export function _maxSize(
880
867
  });
881
868
  }
882
869
 
883
- export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum">;
870
+ export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
884
871
  export function _minSize(
885
872
  minimum: number,
886
873
  params?: string | $ZodCheckMinSizeParams
@@ -892,7 +879,7 @@ export function _minSize(
892
879
  });
893
880
  }
894
881
 
895
- export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size">;
882
+ export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
896
883
  export function _size(
897
884
  size: number,
898
885
  params?: string | $ZodCheckSizeEqualsParams
@@ -904,7 +891,7 @@ export function _size(
904
891
  });
905
892
  }
906
893
 
907
- export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum">;
894
+ export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
908
895
  export function _maxLength(
909
896
  maximum: number,
910
897
  params?: string | $ZodCheckMaxLengthParams
@@ -917,7 +904,7 @@ export function _maxLength(
917
904
  return ch;
918
905
  }
919
906
 
920
- export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum">;
907
+ export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
921
908
  export function _minLength(
922
909
  minimum: number,
923
910
  params?: string | $ZodCheckMinLengthParams
@@ -929,7 +916,7 @@ export function _minLength(
929
916
  });
930
917
  }
931
918
 
932
- export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length">;
919
+ export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
933
920
  export function _length(
934
921
  length: number,
935
922
  params?: string | $ZodCheckLengthEqualsParams
@@ -941,7 +928,7 @@ export function _length(
941
928
  });
942
929
  }
943
930
 
944
- export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern">;
931
+ export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
945
932
  export function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex {
946
933
  return new checks.$ZodCheckRegex({
947
934
  check: "string_format",
@@ -951,7 +938,7 @@ export function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams):
951
938
  });
952
939
  }
953
940
 
954
- export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format">;
941
+ export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
955
942
  export function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase {
956
943
  return new checks.$ZodCheckLowerCase({
957
944
  check: "string_format",
@@ -960,7 +947,7 @@ export function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$
960
947
  });
961
948
  }
962
949
 
963
- export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format">;
950
+ export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
964
951
 
965
952
  export function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase {
966
953
  return new checks.$ZodCheckUpperCase({
@@ -970,7 +957,7 @@ export function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$
970
957
  });
971
958
  }
972
959
 
973
- export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "pattern">;
960
+ export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
974
961
  export function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes {
975
962
  return new checks.$ZodCheckIncludes({
976
963
  check: "string_format",
@@ -979,7 +966,10 @@ export function _includes(includes: string, params?: string | $ZodCheckIncludesP
979
966
  includes,
980
967
  });
981
968
  }
982
- export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
969
+ export type $ZodCheckStartsWithParams = CheckParams<
970
+ checks.$ZodCheckStartsWith,
971
+ "prefix" | "format" | "when" | "pattern"
972
+ >;
983
973
  export function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith {
984
974
  return new checks.$ZodCheckStartsWith({
985
975
  check: "string_format",
@@ -989,7 +979,7 @@ export function _startsWith(prefix: string, params?: string | $ZodCheckStartsWit
989
979
  });
990
980
  }
991
981
 
992
- export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
982
+ export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
993
983
 
994
984
  export function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith {
995
985
  return new checks.$ZodCheckEndsWith({
@@ -1000,7 +990,7 @@ export function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithPar
1000
990
  });
1001
991
  }
1002
992
 
1003
- export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema">;
993
+ export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
1004
994
  export function _property<K extends string, T extends schemas.$ZodType>(
1005
995
  property: K,
1006
996
  schema: T,
@@ -1014,7 +1004,7 @@ export function _property<K extends string, T extends schemas.$ZodType>(
1014
1004
  });
1015
1005
  }
1016
1006
 
1017
- export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime">;
1007
+ export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
1018
1008
  export function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType {
1019
1009
  return new checks.$ZodCheckMimeType({
1020
1010
  check: "mime_type",
package/src/v4/core/schemas.ts CHANGED
@@ -3518,6 +3518,7 @@ function handleReadonlyResult(payload: ParsePayload): ParsePayload {
3518
3518
  export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
3519
3519
  type: "template_literal";
3520
3520
  parts: $ZodTemplateLiteralPart[];
3521
+ format?: string | undefined;
3521
3522
  }
3522
3523
  export interface $ZodTemplateLiteralInternals<Template extends string = string>
3523
3524
  extends $ZodTypeInternals<Template, Template> {
@@ -3624,7 +3625,7 @@ export const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral> = /*@__
3624
3625
  input: payload.value,
3625
3626
  inst,
3626
3627
  code: "invalid_format",
3627
- format: "template_literal",
3628
+ format: def.format ?? "template_literal",
3628
3629
  pattern: inst._zod.pattern.source,
3629
3630
  });
3630
3631
  return payload;
package/v4/core/api.d.cts CHANGED
@@ -19,73 +19,73 @@ export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = sche
19
19
  export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
20
20
  export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
21
21
  export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
22
- export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce">;
22
+ export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
23
23
  export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
24
- export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail>;
25
- export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail>;
24
+ export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
25
+ export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
26
26
  export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
27
- export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern">;
28
- export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern">;
27
+ export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
28
+ export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
29
29
  export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
30
- export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern">;
31
- export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
30
+ export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
31
+ export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
32
32
  export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
33
- export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
34
- export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
33
+ export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
34
+ export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
35
35
  export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
36
- export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
37
- export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
36
+ export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
37
+ export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
38
38
  export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
39
- export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
40
- export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
39
+ export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
40
+ export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
41
41
  export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
42
- export type $ZodURLParams = StringFormatParams<schemas.$ZodURL>;
43
- export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL>;
42
+ export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
43
+ export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
44
44
  export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
45
- export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji>;
46
- export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji>;
45
+ export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
46
+ export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
47
47
  export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
48
- export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID>;
49
- export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID>;
48
+ export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
49
+ export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
50
50
  export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
51
- export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID>;
52
- export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID>;
51
+ export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
52
+ export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
53
53
  export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
54
- export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2>;
55
- export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2>;
54
+ export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
55
+ export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
56
56
  export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
57
- export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID>;
58
- export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID>;
57
+ export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
58
+ export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
59
59
  export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
60
- export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID>;
61
- export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID>;
60
+ export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
61
+ export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
62
62
  export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
63
- export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID>;
64
- export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID>;
63
+ export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
64
+ export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
65
65
  export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
66
- export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern">;
67
- export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern">;
66
+ export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
67
+ export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
68
68
  export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
69
- export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern">;
70
- export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern">;
69
+ export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
70
+ export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
71
71
  export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
72
- export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern">;
73
- export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern">;
72
+ export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
73
+ export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
74
74
  export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
75
- export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern">;
76
- export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern">;
75
+ export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
76
+ export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
77
77
  export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
78
- export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern">;
79
- export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern">;
78
+ export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
79
+ export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
80
80
  export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
81
- export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern">;
82
- export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern">;
81
+ export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
82
+ export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
83
83
  export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
84
- export type $ZodE164Params = StringFormatParams<schemas.$ZodE164>;
85
- export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164>;
84
+ export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
85
+ export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
86
86
  export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
87
- export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern">;
88
- export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern">;
87
+ export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
88
+ export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
89
89
  export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
90
90
  export declare const TimePrecision: {
91
91
  readonly Any: null;
@@ -94,21 +94,21 @@ export declare const TimePrecision: {
94
94
  readonly Millisecond: 3;
95
95
  readonly Microsecond: 6;
96
96
  };
97
- export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern">;
98
- export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern">;
97
+ export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
98
+ export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
99
99
  export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
100
- export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern">;
101
- export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern">;
100
+ export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
101
+ export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
102
102
  export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
103
- export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern">;
104
- export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern">;
103
+ export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
104
+ export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
105
105
  export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
106
- export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration>;
107
- export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration>;
106
+ export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
107
+ export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
108
108
  export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
109
109
  export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
110
110
  export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
111
- export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format">;
111
+ export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
112
112
  export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
113
113
  export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
114
114
  export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
@@ -121,7 +121,7 @@ export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.Sche
121
121
  export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
122
122
  export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
123
123
  export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
124
- export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format">;
124
+ export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
125
125
  export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
126
126
  export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
127
127
  export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
@@ -145,13 +145,13 @@ export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClas
145
145
  export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
146
146
  export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
147
147
  export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
148
- export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value">;
148
+ export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
149
149
  export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
150
150
  export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
151
151
  export {
152
152
  /** @deprecated Use `z.lte()` instead. */
153
153
  _lte as _max, };
154
- export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value">;
154
+ export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
155
155
  export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
156
156
  export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
157
157
  export {
@@ -161,37 +161,37 @@ export declare function _positive(params?: string | $ZodCheckGreaterThanParams):
161
161
  export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
162
162
  export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
163
163
  export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
164
- export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value">;
164
+ export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
165
165
  export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
166
- export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum">;
166
+ export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
167
167
  export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
168
- export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum">;
168
+ export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
169
169
  export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
170
- export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size">;
170
+ export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
171
171
  export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
172
- export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum">;
172
+ export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
173
173
  export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
174
- export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum">;
174
+ export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
175
175
  export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
176
- export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length">;
176
+ export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
177
177
  export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
178
- export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern">;
178
+ export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
179
179
  export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
180
- export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format">;
180
+ export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
181
181
  export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
182
- export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format">;
182
+ export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
183
183
  export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
184
- export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "pattern">;
184
+ export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
185
185
  export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
186
- export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
186
+ export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
187
187
  export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
188
- export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
188
+ export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
189
189
  export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
190
- export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema">;
190
+ export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
191
191
  export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
192
192
  [k in K]: core.output<T>;
193
193
  }>;
194
- export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime">;
194
+ export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
195
195
  export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
196
196
  export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
197
197
  export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
package/v4/core/api.d.ts CHANGED
@@ -19,73 +19,73 @@ export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = sche
19
19
  export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
20
20
  export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
21
21
  export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
22
- export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce">;
22
+ export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
23
23
  export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
24
- export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail>;
25
- export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail>;
24
+ export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
25
+ export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
26
26
  export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
27
- export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern">;
28
- export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern">;
27
+ export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
28
+ export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
29
29
  export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
30
- export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern">;
31
- export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
30
+ export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
31
+ export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
32
32
  export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
33
- export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
34
- export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
33
+ export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
34
+ export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
35
35
  export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
36
- export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
37
- export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
36
+ export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
37
+ export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
38
38
  export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
39
- export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
40
- export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
39
+ export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
40
+ export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
41
41
  export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
42
- export type $ZodURLParams = StringFormatParams<schemas.$ZodURL>;
43
- export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL>;
42
+ export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
43
+ export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
44
44
  export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
45
- export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji>;
46
- export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji>;
45
+ export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
46
+ export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
47
47
  export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
48
- export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID>;
49
- export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID>;
48
+ export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
49
+ export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
50
50
  export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
51
- export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID>;
52
- export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID>;
51
+ export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
52
+ export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
53
53
  export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
54
- export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2>;
55
- export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2>;
54
+ export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
55
+ export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
56
56
  export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
57
- export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID>;
58
- export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID>;
57
+ export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
58
+ export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
59
59
  export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
60
- export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID>;
61
- export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID>;
60
+ export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
61
+ export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
62
62
  export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
63
- export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID>;
64
- export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID>;
63
+ export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
64
+ export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
65
65
  export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
66
- export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern">;
67
- export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern">;
66
+ export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
67
+ export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
68
68
  export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
69
- export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern">;
70
- export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern">;
69
+ export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
70
+ export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
71
71
  export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
72
- export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern">;
73
- export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern">;
72
+ export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
73
+ export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
74
74
  export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
75
- export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern">;
76
- export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern">;
75
+ export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
76
+ export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
77
77
  export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
78
- export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern">;
79
- export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern">;
78
+ export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
79
+ export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
80
80
  export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
81
- export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern">;
82
- export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern">;
81
+ export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
82
+ export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
83
83
  export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
84
- export type $ZodE164Params = StringFormatParams<schemas.$ZodE164>;
85
- export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164>;
84
+ export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
85
+ export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
86
86
  export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
87
- export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern">;
88
- export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern">;
87
+ export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
88
+ export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
89
89
  export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
90
90
  export declare const TimePrecision: {
91
91
  readonly Any: null;
@@ -94,21 +94,21 @@ export declare const TimePrecision: {
94
94
  readonly Millisecond: 3;
95
95
  readonly Microsecond: 6;
96
96
  };
97
- export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern">;
98
- export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern">;
97
+ export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
98
+ export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
99
99
  export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
100
- export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern">;
101
- export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern">;
100
+ export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
101
+ export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
102
102
  export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
103
- export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern">;
104
- export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern">;
103
+ export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
104
+ export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
105
105
  export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
106
- export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration>;
107
- export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration>;
106
+ export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
107
+ export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
108
108
  export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
109
109
  export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
110
110
  export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
111
- export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format">;
111
+ export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
112
112
  export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
113
113
  export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
114
114
  export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
@@ -121,7 +121,7 @@ export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.Sche
121
121
  export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
122
122
  export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
123
123
  export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
124
- export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format">;
124
+ export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
125
125
  export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
126
126
  export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
127
127
  export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
@@ -145,13 +145,13 @@ export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClas
145
145
  export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
146
146
  export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
147
147
  export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
148
- export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value">;
148
+ export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
149
149
  export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
150
150
  export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
151
151
  export {
152
152
  /** @deprecated Use `z.lte()` instead. */
153
153
  _lte as _max, };
154
- export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value">;
154
+ export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
155
155
  export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
156
156
  export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
157
157
  export {
@@ -161,37 +161,37 @@ export declare function _positive(params?: string | $ZodCheckGreaterThanParams):
161
161
  export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
162
162
  export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
163
163
  export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
164
- export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value">;
164
+ export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
165
165
  export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
166
- export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum">;
166
+ export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
167
167
  export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
168
- export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum">;
168
+ export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
169
169
  export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
170
- export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size">;
170
+ export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
171
171
  export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
172
- export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum">;
172
+ export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
173
173
  export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
174
- export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum">;
174
+ export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
175
175
  export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
176
- export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length">;
176
+ export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
177
177
  export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
178
- export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern">;
178
+ export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
179
179
  export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
180
- export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format">;
180
+ export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
181
181
  export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
182
- export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format">;
182
+ export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
183
183
  export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
184
- export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "pattern">;
184
+ export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
185
185
  export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
186
- export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
186
+ export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
187
187
  export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
188
- export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
188
+ export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
189
189
  export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
190
- export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema">;
190
+ export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
191
191
  export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
192
192
  [k in K]: core.output<T>;
193
193
  }>;
194
- export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime">;
194
+ export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
195
195
  export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
196
196
  export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
197
197
  export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
package/v4/core/schemas.cjs CHANGED
@@ -1689,7 +1689,7 @@ exports.$ZodTemplateLiteral = core.$constructor("$ZodTemplateLiteral", (inst, de
1689
1689
  input: payload.value,
1690
1690
  inst,
1691
1691
  code: "invalid_format",
1692
- format: "template_literal",
1692
+ format: def.format ?? "template_literal",
1693
1693
  pattern: inst._zod.pattern.source,
1694
1694
  });
1695
1695
  return payload;
package/v4/core/schemas.d.cts CHANGED
@@ -958,6 +958,7 @@ export declare const $ZodReadonly: core.$constructor<$ZodReadonly>;
958
958
  export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
959
959
  type: "template_literal";
960
960
  parts: $ZodTemplateLiteralPart[];
961
+ format?: string | undefined;
961
962
  }
962
963
  export interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
963
964
  pattern: RegExp;
package/v4/core/schemas.d.ts CHANGED
@@ -958,6 +958,7 @@ export declare const $ZodReadonly: core.$constructor<$ZodReadonly>;
958
958
  export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
959
959
  type: "template_literal";
960
960
  parts: $ZodTemplateLiteralPart[];
961
+ format?: string | undefined;
961
962
  }
962
963
  export interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
963
964
  pattern: RegExp;
package/v4/core/schemas.js CHANGED
@@ -1658,7 +1658,7 @@ export const $ZodTemplateLiteral = /*@__PURE__*/ core.$constructor("$ZodTemplate
1658
1658
  input: payload.value,
1659
1659
  inst,
1660
1660
  code: "invalid_format",
1661
- format: "template_literal",
1661
+ format: def.format ?? "template_literal",
1662
1662
  pattern: inst._zod.pattern.source,
1663
1663
  });
1664
1664
  return payload;