bupkis 0.11.1 → 0.12.0

package/dist/commonjs/index.d.ts

@@ -18,6 +18,18 @@ export * as assertions from './assertion/impl/index.js';
 export { expect, expectAsync } from './bootstrap.js';
 export * from './error.js';
 export * as schema from './schema.js';
+/**
+ * Re-export of Standard Schema v1 types for use in custom assertion
+ * implementations.
+ *
+ * @see {@link https://standardschema.dev | Standard Schema Specification}
+ */
+export type { StandardSchemaV1 } from './standard-schema.js';
+/**
+ * Re-export of {@link https://zod.dev Zod v4} for use in custom assertion
+ * implementations.
+ */
+export { z };
 /**
  * Re-export of most (all?) types defined within <span
  * class="bupkis">Bupkis</span>.
@@ -29,15 +41,10 @@ export * as schema from './schema.js';
  * ```
  */
 export type * as types from './types.js';
-/**
- * Re-export of {@link https://zod.dev Zod v4} for use in custom assertion
- * implementations.
- */
-export { z };
 /**
  * @primaryExport
  */
-export type { AssertionFailure, Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, ExpectIt, ExpectItAsync, FailFn, Keypath, UseFn, } from './types.js';
+export type { AssertionFailure, AssertionStandardSchemaAsync, AssertionStandardSchemaSync, Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, ExpectIt, ExpectItAsync, FailFn, Keypath, UseFn, } from './types.js';
 export { createAssertion, createAsyncAssertion, fail, use };
 declare const 
 /**
@@ -85,7 +92,7 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => z.ZodMap<z.ZodUnknown, z.ZodUnknown>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"]>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => z.ZodMap<z.ZodUnknown, z.ZodUnknown>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
     message: string;
     actual?: never;
     expected?: never;
@@ -93,9 +100,9 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodInt], (_subject: Set<unknown>, expectedSize: number) => z.ZodSet<z.ZodUnknown>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"]>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: unknown[], value: unknown) => {
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodInt], (_subject: Set<unknown>, expectedSize: number) => z.ZodSet<z.ZodUnknown>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], z.ZodCustom<Set<unknown>, Set<unknown>>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: unknown[], value: unknown) => {
     message: string;
-} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have length", "to have size"], z.ZodInt], (_subject: unknown[], expectedSize: number) => z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, z.ZodInt]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"]>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to have size", z.ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have length", "to have size"], z.ZodInt], (_subject: unknown[], expectedSize: number) => z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to have size", z.ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
     actual: number;
     expected: number;
     message: string;
@@ -141,7 +148,7 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     message: string;
 } | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size less than">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", z.ZodTuple<[z.ZodInt, z.ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
     message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size between">, z.ZodTuple<[z.ZodInt, z.ZodInt], null>]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be defined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size between">, z.ZodTuple<[z.ZodInt, z.ZodInt], null>]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], z.ZodArray<z.ZodUnknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], z.ZodBigInt, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], z.ZodBoolean, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], z.ZodDate, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be defined"], z.ZodNonOptional<z.ZodUnknown>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
 }, z.core.$loose>]>, "to be empty"], (subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
@@ -152,9 +159,9 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     message: string;
 } | undefined, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"]>, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodString, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be false"], import("./types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be falsy"], import("./types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be infinite"], import("./types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be NaN"], import("./types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [z.ZodString, "to be non-empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionSchemaSync<readonly ["to be null"], import("./types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an object"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a Set"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a string"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be true"], import("./types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be undefined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a", "to be an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to be a", "to be an", "to have type"], z.ZodEnum<{
+}, z.core.$loose>]>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be empty"], z.ZodString, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], z.ZodCustom<Error, Error>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be false"], z.ZodLiteral<false>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], z.ZodNullable<z.ZodAny>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a function"], z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], z.ZodUnion<[z.ZodLiteral<number>, z.ZodLiteral<number>]>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], z.ZodNaN, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], z.ZodLiteral<number>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be non-empty"], z.ZodString, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be null"], z.ZodNull, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be an object"], z.ZodNonOptional<z.ZodUnknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], z.ZodLiteral<number>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodBigInt, z.ZodSymbol, z.ZodNull, z.ZodUndefined]>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], z.ZodCustom<RegExp, RegExp>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], z.ZodCustom<Set<unknown>, Set<unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a string"], z.ZodString, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], z.ZodSymbol, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be true"], z.ZodLiteral<true>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], z.ZodNonOptional<z.ZodAny>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], z.ZodUndefined, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a", "to be an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to be a", "to be an", "to have type"], z.ZodEnum<{
     [x: string]: string;
-}>], (_: unknown, type: string) => z.ZodString | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodNumber | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodArray<z.ZodUnknown> | z.ZodSymbol | z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodCustom<Error, Error> | z.ZodNull | z.ZodUndefined | z.ZodCustom<RegExp, RegExp> | z.ZodObject<{}, z.core.$loose> | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
+}>], (_: unknown, type: string) => z.ZodString | z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodNumber | z.ZodSymbol | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodBoolean | z.ZodBigInt | z.ZodNull | z.ZodUndefined | z.ZodArray<z.ZodUnknown> | z.ZodCustom<RegExp, RegExp> | z.ZodDate | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodCustom<Error, Error> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>> | z.ZodObject<{}, z.core.$loose>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
     [x: string]: string;
 }>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be greater than", z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than", "to be lt"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be within", "to be between"], z.ZodNumber, z.ZodNumber], (subject: number, min: number, max: number) => {
     message: string;
@@ -236,7 +243,7 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     length: number;
 }, shape: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodUnknown]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
+}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodUnknown]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
     actual: boolean;
     expected: boolean;
     message: string;
@@ -244,7 +251,7 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: boolean;
     expected: boolean;
     message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>, "to be after", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], z.ZodUnknown, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], z.ZodUnknown, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>, "to be after", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
     message: string;
     schema?: never;
     subject?: never;
@@ -288,7 +295,7 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be the same date as">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be the same date as">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodNumber]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
     message: string;
 } | undefined, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
     message: string;

package/dist/commonjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,UAAU,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACrD,cAAc,YAAY,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,gBAAgB,EAChB,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,aAAa,EACb,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8TAEgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,UAAU,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACrD,cAAc,YAAY,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;;;;GAKG;AACH,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,YAAY,EACV,gBAAgB,EAChB,4BAA4B,EAC5B,2BAA2B,EAC3B,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,aAAa,EACb,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8TAEgB,CAAC"}

package/dist/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,+BAA2B;AAwBlB,kFAxBA,MAAC,OAwBA;AAtBV,iDAA6D;AAC7D,wEAAwD;AACxD,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAC5B,6CAA2B;AAC3B,sDAAsC;AAqCtC,MAAM;AACJ;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAzCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,+BAA2B;AAoBlB,kFApBA,MAAC,OAoBA;AAlBV,iDAA6D;AAC7D,wEAAwD;AACxD,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAC5B,6CAA2B;AAC3B,sDAAsC;AA+CtC,MAAM;AACJ;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAzCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}

package/dist/commonjs/internal-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal-schema.d.ts","sourceRoot":"","sources":["../../src/internal-schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAoB,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA+J1E;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,OAAO,KACb,KAAK,IAAI,qBAEX,CAAC"}
+{"version":3,"file":"internal-schema.d.ts","sourceRoot":"","sources":["../../src/internal-schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAoB,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAmL1E;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,OAAO,KACb,KAAK,IAAI,qBAEX,CAAC"}

package/dist/commonjs/internal-schema.js

@@ -38,6 +38,22 @@ const ZodTypeSchema = v4_1.z
     error: 'Must be a Zod schema',
 })
     .describe('A Zod schema within AssertionParts');
+/**
+ * @internal
+ */
+const StandardSchemaSchema = v4_1.z
+    .custom(guards_js_1.isStandardSchema, {
+    error: 'Must be a Standard Schema v1',
+})
+    .describe('A Standard Schema v1 within AssertionParts');
+/**
+ * Schema that accepts either Zod or Standard Schema validators.
+ *
+ * @internal
+ */
+const SchemaSchema = v4_1.z
+    .union([ZodTypeSchema, StandardSchemaSchema])
+    .describe('A Zod schema or Standard Schema v1');
 /** @internal */
 const BaseAssertionParseRequestSchema = v4_1.z.object({
     subject: v4_1.z.unknown().describe('The subject value to be validated'),
@@ -48,11 +64,11 @@ const BaseAssertionParseRequestSchema = v4_1.z.object({
 const AssertionParseRequestSchema = v4_1.z.union([
     v4_1.z.object({
         ...BaseAssertionParseRequestSchema.shape,
-        schema: ZodTypeSchema.describe('The sync Zod schema to validate against'),
+        schema: SchemaSchema.describe('The sync schema to validate against'),
     }),
     v4_1.z.object({
         ...BaseAssertionParseRequestSchema.shape,
-        asyncSchema: ZodTypeSchema.describe('The async Zod schema to validate against'),
+        asyncSchema: SchemaSchema.describe('The async schema to validate against'),
     }),
 ]);
 /**
@@ -76,13 +92,13 @@ const PhraseLiteralChoiceSchema = v4_1.z
  */
 const AssertionImplSchemaSync = v4_1.z
     .union([
-    ZodTypeSchema,
+    SchemaSchema,
     v4_1.z.function({
         input: v4_1.z.tuple([v4_1.z.unknown()], v4_1.z.unknown()),
         output: v4_1.z.union([
             v4_1.z.void(),
             v4_1.z.boolean(),
-            ZodTypeSchema,
+            SchemaSchema,
             AssertionFailureSchema,
             AssertionParseRequestSchema,
         ]),
@@ -91,18 +107,18 @@ const AssertionImplSchemaSync = v4_1.z
     .describe('A synchronous assertion implementation function');
 const AssertionImplSchemaAsync = v4_1.z
     .union([
-    ZodTypeSchema,
+    SchemaSchema,
     v4_1.z.function({
         input: v4_1.z.tuple([v4_1.z.unknown()], v4_1.z.unknown()),
         output: v4_1.z.union([
             v4_1.z.void(),
             v4_1.z.boolean(),
-            ZodTypeSchema,
+            SchemaSchema,
             AssertionFailureSchema,
             AssertionParseRequestSchema,
             v4_1.z.promise(v4_1.z.void()),
             v4_1.z.promise(v4_1.z.boolean()),
-            v4_1.z.promise(ZodTypeSchema),
+            v4_1.z.promise(SchemaSchema),
             v4_1.z.promise(AssertionFailureSchema),
             v4_1.z.promise(AssertionParseRequestSchema),
         ]),
@@ -113,20 +129,22 @@ const AssertionImplSchemaAsync = v4_1.z
  * @internal
  */
 const AssertionPartsSchema = v4_1.z
-    .array(v4_1.z.union([PhraseLiteralSchema, PhraseLiteralChoiceSchema, ZodTypeSchema]))
+    .array(v4_1.z.union([PhraseLiteralSchema, PhraseLiteralChoiceSchema, SchemaSchema]))
     .min(1, { error: 'At least one part is required for an assertion' })
     .refine((parts) => {
-    // Special validation for 'and': it can only appear if followed by a ZodType
+    // Special validation for 'and': it can only appear if followed by a schema
     for (let i = 0; i < parts.length; i++) {
         if (parts[i] === 'and') {
-            // 'and' must be followed by another part, and that part must be a ZodType
-            if (i === parts.length - 1 || !(0, guards_js_1.isZodType)(parts[i + 1])) {
+            // 'and' must be followed by another part, and that part must be a schema
+            const nextPart = parts[i + 1];
+            if (i === parts.length - 1 ||
+                !((0, guards_js_1.isZodType)(nextPart) || (0, guards_js_1.isStandardSchema)(nextPart))) {
                 return false;
             }
         }
     }
     return true;
-}, { error: '"and" can only appear when followed by a Zod schema' })
+}, { error: '"and" can only appear when followed by a schema' })
     .describe('Assertion "parts" which define the input of an assertion');
 /**
  * Type guard for a {@link AssertionFailure}.

package/dist/commonjs/internal-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal-schema.js","sourceRoot":"","sources":["../../src/internal-schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"internal-schema.js","sourceRoot":"","sources":["../../src/internal-schema.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/standard-schema.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Standard Schema v1 specification types.
+ *
+ * These types define the Standard Schema interface that enables
+ * interoperability between different validation libraries (Zod, Valibot,
+ * ArkType, etc.).
+ *
+ * @packageDocumentation
+ * @see {@link https://standardschema.dev | Standard Schema Specification}
+ */
+/**
+ * The Standard Schema interface.
+ *
+ * This is the primary interface that validation libraries implement to be
+ * Standard Schema compliant. The interface is designed to be minimal and
+ * non-invasive, tucked behind the `~standard` property to avoid API conflicts.
+ *
+ * @template Input - The input type accepted by the schema
+ * @template Output - The output type produced after successful validation
+ */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /**
+     * The Standard Schema properties.
+     *
+     * This property uses a tilde prefix to:
+     *
+     * - Avoid conflicts with existing library APIs
+     * - De-prioritize in IDE autocomplete (tilde sorts after alphanumeric)
+     * - Signal special/internal nature of the property
+     */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /**
+     * The result interface if validation fails.
+     *
+     * Contains an array of issues describing what went wrong during validation.
+     */
+    interface FailureResult {
+        /**
+         * The issues of failed validation.
+         *
+         * Always present and non-empty when validation fails.
+         */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /**
+     * Infers the input type of a Standard Schema.
+     *
+     * Utility type for extracting the input type from a schema instance.
+     *
+     * @template Schema - The Standard Schema to extract the input type from
+     */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /**
+     * Infers the output type of a Standard Schema.
+     *
+     * Utility type for extracting the output type from a schema instance.
+     *
+     * @template Schema - The Standard Schema to extract the output type from
+     */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+    /**
+     * The issue interface of the failure output.
+     *
+     * Describes a single validation problem, including a human-readable message
+     * and optional path to the problematic value in nested structures.
+     */
+    interface Issue {
+        /**
+         * The error message of the issue.
+         *
+         * Human-readable description of what validation rule was violated.
+         */
+        readonly message: string;
+        /**
+         * The path of the issue, if any.
+         *
+         * For nested structures, indicates where in the object/array hierarchy the
+         * validation failed. Can contain property keys or path segment objects.
+         */
+        readonly path?: ReadonlyArray<PathSegment | PropertyKey> | undefined;
+    }
+    /**
+     * The path segment interface of the issue.
+     *
+     * Allows path elements to carry additional metadata beyond just the key.
+     */
+    interface PathSegment {
+        /**
+         * The key representing a path segment.
+         *
+         * Can be a string, number, or symbol identifying the path component.
+         */
+        readonly key: PropertyKey;
+    }
+    /**
+     * The Standard Schema properties interface.
+     *
+     * Contains the actual validation logic and metadata required by the spec.
+     *
+     * @template Input - The input type accepted by the schema
+     * @template Output - The output type produced after successful validation
+     */
+    interface Props<Input = unknown, Output = Input> {
+        /**
+         * Inferred types associated with the schema.
+         *
+         * Optional property that allows TypeScript type inference for the schema.
+         * Not all libraries may provide this.
+         */
+        readonly types?: Types<Input, Output> | undefined;
+        /**
+         * Validates unknown input values.
+         *
+         * This function performs validation and returns either a success result
+         * with the validated/transformed data, or a failure result with validation
+         * issues. May return a Promise for async validation.
+         *
+         * @param value - The unknown value to validate
+         * @returns Result object or Promise resolving to result object
+         */
+        readonly validate: (value: unknown) => Promise<Result<Output>> | Result<Output>;
+        /**
+         * The vendor name of the schema library.
+         *
+         * Examples: 'zod', 'valibot', 'arktype', 'yup', etc.
+         */
+        readonly vendor: string;
+        /**
+         * The version number of the standard.
+         *
+         * Currently only version 1 is defined. Future versions will increment this
+         * number to maintain backward compatibility.
+         */
+        readonly version: 1;
+    }
+    /**
+     * The result interface of the validate function.
+     *
+     * A discriminated union that represents either successful or failed
+     * validation.
+     */
+    type Result<Output> = FailureResult | SuccessResult<Output>;
+    /**
+     * The result interface if validation succeeds.
+     *
+     * Contains the validated/transformed output value and explicitly sets
+     * `issues` to undefined to distinguish from failure results.
+     *
+     * @template Output - The output type after successful validation
+     */
+    interface SuccessResult<Output> {
+        /**
+         * The non-existent issues.
+         *
+         * Explicitly undefined to create a discriminated union with FailureResult.
+         */
+        readonly issues?: undefined;
+        /**
+         * The typed output value.
+         *
+         * This may be the same as the input or a transformed version, depending on
+         * the schema's validation logic.
+         */
+        readonly value: Output;
+    }
+    /**
+     * The Standard Schema types interface.
+     *
+     * Provides TypeScript type information for schemas that support type
+     * inference.
+     *
+     * @template Input - The input type of the schema
+     * @template Output - The output type of the schema
+     */
+    interface Types<Input = unknown, Output = Input> {
+        /**
+         * The input type of the schema.
+         *
+         * The type of values that can be passed to the validate function.
+         */
+        readonly input: Input;
+        /**
+         * The output type of the schema.
+         *
+         * The type of values produced after successful validation.
+         */
+        readonly output: Output;
+    }
+}
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/commonjs/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../../src/standard-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC7D;AAGD,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC;;;;OAIG;IACH,UAAiB,aAAa;QAC5B;;;;WAIG;QACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;KACvC;IAED;;;;;;OAMG;IACH,KAAY,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACnE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAC;IAEX;;;;;;OAMG;IACH,KAAY,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACpE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAC;IAEZ;;;;;OAKG;IACH,UAAiB,KAAK;QACpB;;;;WAIG;QACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAEzB;;;;;WAKG;QACH,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC;KACtE;IAED;;;;OAIG;IACH,UAAiB,WAAW;QAC1B;;;;WAIG;QACH,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;KAC3B;IAED;;;;;;;OAOG;IACH,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD;;;;;WAKG;QACH,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;QAElD;;;;;;;;;WASG;QACH,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,OAAO,KACX,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAE9C;;;;WAIG;QACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAExB;;;;;WAKG;QACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;KACrB;IAED;;;;;OAKG;IACH,KAAY,MAAM,CAAC,MAAM,IAAI,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IAEnE;;;;;;;OAOG;IACH,UAAiB,aAAa,CAAC,MAAM;QACnC;;;;WAIG;QACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;QAE5B;;;;;WAKG;QACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;KACxB;IAED;;;;;;;;OAQG;IACH,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD;;;;WAIG;QACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QAEtB;;;;WAIG;QACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB;CACF"}

package/dist/commonjs/standard-schema.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Standard Schema v1 specification types.
+ *
+ * These types define the Standard Schema interface that enables
+ * interoperability between different validation libraries (Zod, Valibot,
+ * ArkType, etc.).
+ *
+ * @packageDocumentation
+ * @see {@link https://standardschema.dev | Standard Schema Specification}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=standard-schema.js.map

package/dist/commonjs/standard-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../../src/standard-schema.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG"}