Function expect

The main synchronous assertion function which can execute only built-in assertions.

expect(...args: unknown[] | readonly unknown[]): void
Parameters
- ...args: unknown[] | readonly unknown[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            number
            | Map<unknown, unknown>
            | "to have size"
            | "not to have size"
        )[]
        | (number | Map<unknown, unknown> | "to have size" | "not to have size")[],
): void
Parameters
- ...args:
      | readonly (
          number
          | Map<unknown, unknown>
          | "to have size"
          | "not to have size"
      )[]
      | (number | Map<unknown, unknown> | "to have size" | "not to have size")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (Map<unknown, unknown> | "to be empty" | "not to be empty")[]
        | (Map<unknown, unknown> | "to be empty" | "not to be empty")[],
): void
Parameters
- ...args:
  | readonly (Map<unknown, unknown> | "to be empty" | "not to be empty")[]
  | (Map<unknown, unknown> | "to be empty" | "not to be empty")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            number
            | Set<unknown>
            | "to have size"
            | "not to have size"
        )[]
        | (number | Set<unknown> | "to have size" | "not to have size")[],
): void
Parameters
- ...args:
  | readonly (number | Set<unknown> | "to have size" | "not to have size")[]
  | (number | Set<unknown> | "to have size" | "not to have size")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (Set<unknown> | "to be empty" | "not to be empty")[]
        | (Set<unknown> | "to be empty" | "not to be empty")[],
): void
Parameters
- ...args:
  | readonly (Set<unknown> | "to be empty" | "not to be empty")[]
  | (Set<unknown> | "to be empty" | "not to be empty")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | number
            | unknown[]
            | "to have size"
            | "to have length"
            | "not to have size"
            | "not to have length"
        )[]
        | (
            | number
            | unknown[]
            | "to have size"
            | "to have length"
            | "not to have size"
            | "not to have length"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | number
          | unknown[]
          | "to have size"
          | "to have length"
          | "not to have size"
          | "not to have length"
      )[]
      | (
          | number
          | unknown[]
          | "to have size"
          | "to have length"
          | "not to have size"
          | "not to have length"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (unknown[] | "to be non-empty" | "not to be non-empty")[]
        | (unknown[] | "to be non-empty" | "not to be non-empty")[],
): void
Parameters
- ...args:
  | readonly (unknown[] | "to be non-empty" | "not to be non-empty")[]
  | (unknown[] | "to be non-empty" | "not to be non-empty")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | Record<PropertyKey, unknown>
            | ((...args: any[]) => any)
            | "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"
            | (string | number | symbol)[]
            | "not to have keys"
            | "not to have properties"
            | "not to have props"
            | "not to contain keys"
            | "not to contain properties"
            | "not to contain props"
            | "not to include keys"
            | "not to include properties"
            | "not to include props"
        )[]
        | (
            | Record<PropertyKey, unknown>
            | ((...args: any[]) => any)
            | "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"
            | (string | number | symbol)[]
            | "not to have keys"
            | "not to have properties"
            | "not to have props"
            | "not to contain keys"
            | "not to contain properties"
            | "not to contain props"
            | "not to include keys"
            | "not to include properties"
            | "not to include props"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | Record<PropertyKey, unknown>
          | ((...args: any[]) => any)
          | "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"
          | (string | number | symbol)[]
          | "not to have keys"
          | "not to have properties"
          | "not to have props"
          | "not to contain keys"
          | "not to contain properties"
          | "not to contain props"
          | "not to include keys"
          | "not to include properties"
          | "not to include props"
      )[]
      | (
          | Record<PropertyKey, unknown>
          | ((...args: any[]) => any)
          | "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"
          | (string | number | symbol)[]
          | "not to have keys"
          | "not to have properties"
          | "not to have props"
          | "not to contain keys"
          | "not to contain properties"
          | "not to contain props"
          | "not to include keys"
          | "not to include properties"
          | "not to include props"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | number
            | Record<string | number | symbol, unknown>
            | "to have size"
            | "not to have size"
        )[]
        | (
            | number
            | Record<string | number | symbol, unknown>
            | "to have size"
            | "not to have size"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | number
          | Record<string | number | symbol, unknown>
          | "to have size"
          | "not to have size"
      )[]
      | (
          | number
          | Record<string | number | symbol, unknown>
          | "to have size"
          | "not to have size"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | string
            | number
            | symbol
            | Record<PropertyKey, unknown>
            | ((...args: any[]) => any)
        )[]
        | (
            | string
            | number
            | symbol
            | Record<PropertyKey, unknown>
            | ((...args: any[]) => any)
        )[],
): void
Parameters
- ...args:
      | readonly (
          | string
          | number
          | symbol
          | Record<PropertyKey, unknown>
          | ((...args: any[]) => any)
      )[]
      | (
          | string
          | number
          | symbol
          | Record<PropertyKey, unknown>
          | ((...args: any[]) => any)
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            string
            | Record<PropertyKey, unknown>
            | ((...args: any[]) => any)
        )[]
        | (string | Record<PropertyKey, unknown> | ((...args: any[]) => any))[],
): void
Parameters
- ...args:
      | readonly (
          string
          | Record<PropertyKey, unknown>
          | ((...args: any[]) => any)
      )[]
      | (string | Record<PropertyKey, unknown> | ((...args: any[]) => any))[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (Set<unknown> | "to equal" | "not to equal")[]
        | readonly (Set<unknown> | "to equal" | "not to equal")[],
): void
Parameters
- ...args:
  | (Set<unknown> | "to equal" | "not to equal")[]
  | readonly (Set<unknown> | "to equal" | "not to equal")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (Set<unknown> | "to be a subset of" | "not to be a subset of")[]
        | readonly (Set<unknown> | "to be a subset of" | "not to be a subset of")[],
): void
Parameters
- ...args:
  | (Set<unknown> | "to be a subset of" | "not to be a subset of")[]
  | readonly (Set<unknown> | "to be a subset of" | "not to be a subset of")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (Set<unknown> | "to be a superset of" | "not to be a superset of")[]
        | readonly (
            Set<unknown>
            | "to be a superset of"
            | "not to be a superset of"
        )[],
): void
Parameters
- ...args:
      | (Set<unknown> | "to be a superset of" | "not to be a superset of")[]
      | readonly (
          Set<unknown>
          | "to be a superset of"
          | "not to be a superset of"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (Set<unknown> | "to intersect with" | "not to intersect with")[]
        | readonly (Set<unknown> | "to intersect with" | "not to intersect with")[],
): void
Parameters
- ...args:
  | (Set<unknown> | "to intersect with" | "not to intersect with")[]
  | readonly (Set<unknown> | "to intersect with" | "not to intersect with")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (Set<unknown> | "to be disjoint from" | "not to be disjoint from")[]
        | readonly (
            Set<unknown>
            | "to be disjoint from"
            | "not to be disjoint from"
        )[],
): void
Parameters
- ...args:
      | (Set<unknown> | "to be disjoint from" | "not to be disjoint from")[]
      | readonly (
          Set<unknown>
          | "to be disjoint from"
          | "not to be disjoint from"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | Set<unknown>
            | "to have union"
            | "equal to"
            | "not to have union"
            | "not equal to"
        )[]
        | readonly (
            | Set<unknown>
            | "to have union"
            | "equal to"
            | "not to have union"
            | "not equal to"
        )[],
): void
Parameters
- ...args:
      | (
          | Set<unknown>
          | "to have union"
          | "equal to"
          | "not to have union"
          | "not equal to"
      )[]
      | readonly (
          | Set<unknown>
          | "to have union"
          | "equal to"
          | "not to have union"
          | "not equal to"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | Set<unknown>
            | "equal to"
            | "to have intersection"
            | "not equal to"
            | "not to have intersection"
        )[]
        | readonly (
            | Set<unknown>
            | "equal to"
            | "to have intersection"
            | "not equal to"
            | "not to have intersection"
        )[],
): void
Parameters
- ...args:
      | (
          | Set<unknown>
          | "equal to"
          | "to have intersection"
          | "not equal to"
          | "not to have intersection"
      )[]
      | readonly (
          | Set<unknown>
          | "equal to"
          | "to have intersection"
          | "not equal to"
          | "not to have intersection"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | Set<unknown>
            | "equal to"
            | "to have difference"
            | "not equal to"
            | "not to have difference"
        )[]
        | readonly (
            | Set<unknown>
            | "equal to"
            | "to have difference"
            | "not equal to"
            | "not to have difference"
        )[],
): void
Parameters
- ...args:
      | (
          | Set<unknown>
          | "equal to"
          | "to have difference"
          | "not equal to"
          | "not to have difference"
      )[]
      | readonly (
          | Set<unknown>
          | "equal to"
          | "to have difference"
          | "not equal to"
          | "not to have difference"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | Set<unknown>
            | "equal to"
            | "to have symmetric difference"
            | "not equal to"
            | "not to have symmetric difference"
        )[]
        | readonly (
            | Set<unknown>
            | "equal to"
            | "to have symmetric difference"
            | "not equal to"
            | "not to have symmetric difference"
        )[],
): void
Parameters
- ...args:
      | (
          | Set<unknown>
          | "equal to"
          | "to have symmetric difference"
          | "not equal to"
          | "not to have symmetric difference"
      )[]
      | readonly (
          | Set<unknown>
          | "equal to"
          | "to have symmetric difference"
          | "not equal to"
          | "not to have symmetric difference"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | Map<unknown, unknown>
            | WeakMap<WeakKey, unknown>
            | [unknown, unknown]
            | "to have entry"
            | "to have key/value pair"
            | "to contain entry"
            | "to contain key/value pair"
            | "to include entry"
            | "to include key/value pair"
            | "not to have entry"
            | "not to have key/value pair"
            | "not to contain entry"
            | "not to contain key/value pair"
            | "not to include entry"
            | "not to include key/value pair"
        )[]
        | (
            | Map<unknown, unknown>
            | WeakMap<WeakKey, unknown>
            | [unknown, unknown]
            | "to have entry"
            | "to have key/value pair"
            | "to contain entry"
            | "to contain key/value pair"
            | "to include entry"
            | "to include key/value pair"
            | "not to have entry"
            | "not to have key/value pair"
            | "not to contain entry"
            | "not to contain key/value pair"
            | "not to include entry"
            | "not to include key/value pair"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | Map<unknown, unknown>
          | WeakMap<WeakKey, unknown>
          | [unknown, unknown]
          | "to have entry"
          | "to have key/value pair"
          | "to contain entry"
          | "to contain key/value pair"
          | "to include entry"
          | "to include key/value pair"
          | "not to have entry"
          | "not to have key/value pair"
          | "not to contain entry"
          | "not to contain key/value pair"
          | "not to include entry"
          | "not to include key/value pair"
      )[]
      | (
          | Map<unknown, unknown>
          | WeakMap<WeakKey, unknown>
          | [unknown, unknown]
          | "to have entry"
          | "to have key/value pair"
          | "to contain entry"
          | "to contain key/value pair"
          | "to include entry"
          | "to include key/value pair"
          | "not to have entry"
          | "not to have key/value pair"
          | "not to contain entry"
          | "not to contain key/value pair"
          | "not to include entry"
          | "not to include key/value pair"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (Map<unknown, unknown> | "to equal" | "not to equal")[]
        | readonly (Map<unknown, unknown> | "to equal" | "not to equal")[],
): void
Parameters
- ...args:
  | (Map<unknown, unknown> | "to equal" | "not to equal")[]
  | readonly (Map<unknown, unknown> | "to equal" | "not to equal")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | number
            | Map<unknown, unknown>
            | Set<unknown>
            | "to have size greater than"
            | "not to have size greater than"
        )[]
        | (
            | number
            | Map<unknown, unknown>
            | Set<unknown>
            | "to have size greater than"
            | "not to have size greater than"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | number
          | Map<unknown, unknown>
          | Set<unknown>
          | "to have size greater than"
          | "not to have size greater than"
      )[]
      | (
          | number
          | Map<unknown, unknown>
          | Set<unknown>
          | "to have size greater than"
          | "not to have size greater than"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | number
            | Map<unknown, unknown>
            | Set<unknown>
            | "to have size less than"
            | "not to have size less than"
        )[]
        | (
            | number
            | Map<unknown, unknown>
            | Set<unknown>
            | "to have size less than"
            | "not to have size less than"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | number
          | Map<unknown, unknown>
          | Set<unknown>
          | "to have size less than"
          | "not to have size less than"
      )[]
      | (
          | number
          | Map<unknown, unknown>
          | Set<unknown>
          | "to have size less than"
          | "not to have size less than"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | Map<unknown, unknown>
            | Set<unknown>
            | "to have size between"
            | [number, number]
            | "not to have size between"
        )[]
        | (
            | Map<unknown, unknown>
            | Set<unknown>
            | "to have size between"
            | [number, number]
            | "not to have size between"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | Map<unknown, unknown>
          | Set<unknown>
          | "to have size between"
          | [number, number]
          | "not to have size between"
      )[]
      | (
          | Map<unknown, unknown>
          | Set<unknown>
          | "to have size between"
          | [number, number]
          | "not to have size between"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | unknown[]
            | [unknown, ...unknown[]]
            | { length: number; [key: string]: unknown }
            | "to be empty"
            | "not to be empty"
        )[]
        | (
            | unknown[]
            | [unknown, ...unknown[]]
            | { length: number; [key: string]: unknown }
            | "to be empty"
            | "not to be empty"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | unknown[]
          | [unknown, ...unknown[]]
          | { length: number; [key: string]: unknown }
          | "to be empty"
          | "not to be empty"
      )[]
      | (
          | unknown[]
          | [unknown, ...unknown[]]
          | { length: number; [key: string]: unknown }
          | "to be empty"
          | "not to be empty"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | Record<string | number | symbol, unknown>
            | "to be empty"
            | "not to be empty"
        )[]
        | (
            | Record<string | number | symbol, unknown>
            | "to be empty"
            | "not to be empty"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | Record<string | number | symbol, unknown>
          | "to be empty"
          | "not to be empty"
      )[]
      | (
          | Record<string | number | symbol, unknown>
          | "to be empty"
          | "not to be empty"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(...args: string[] | readonly string[]): void
Parameters
- ...args: string[] | readonly string[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (number | "to be greater than" | "not to be greater than")[]
        | readonly (number | "to be greater than" | "not to be greater than")[],
): void
Parameters
- ...args:
  | (number | "to be greater than" | "not to be greater than")[]
  | readonly (number | "to be greater than" | "not to be greater than")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | number
            | "to be less than"
            | "to be lt"
            | "not to be less than"
            | "not to be lt"
        )[]
        | readonly (
            | number
            | "to be less than"
            | "to be lt"
            | "not to be less than"
            | "not to be lt"
        )[],
): void
Parameters
- ...args:
      | (
          | number
          | "to be less than"
          | "to be lt"
          | "not to be less than"
          | "not to be lt"
      )[]
      | readonly (
          | number
          | "to be less than"
          | "to be lt"
          | "not to be less than"
          | "not to be lt"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | number
            | "to be greater than or equal to"
            | "to be at least"
            | "to be gte"
            | "not to be greater than or equal to"
            | "not to be at least"
            | "not to be gte"
        )[]
        | readonly (
            | number
            | "to be greater than or equal to"
            | "to be at least"
            | "to be gte"
            | "not to be greater than or equal to"
            | "not to be at least"
            | "not to be gte"
        )[],
): void
Parameters
- ...args:
      | (
          | number
          | "to be greater than or equal to"
          | "to be at least"
          | "to be gte"
          | "not to be greater than or equal to"
          | "not to be at least"
          | "not to be gte"
      )[]
      | readonly (
          | number
          | "to be greater than or equal to"
          | "to be at least"
          | "to be gte"
          | "not to be greater than or equal to"
          | "not to be at least"
          | "not to be gte"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | number
            | "to be less than or equal to"
            | "to be at most"
            | "to be lte"
            | "not to be less than or equal to"
            | "not to be at most"
            | "not to be lte"
        )[]
        | readonly (
            | number
            | "to be less than or equal to"
            | "to be at most"
            | "to be lte"
            | "not to be less than or equal to"
            | "not to be at most"
            | "not to be lte"
        )[],
): void
Parameters
- ...args:
      | (
          | number
          | "to be less than or equal to"
          | "to be at most"
          | "to be lte"
          | "not to be less than or equal to"
          | "not to be at most"
          | "not to be lte"
      )[]
      | readonly (
          | number
          | "to be less than or equal to"
          | "to be at most"
          | "to be lte"
          | "not to be less than or equal to"
          | "not to be at most"
          | "not to be lte"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | number
            | "to be within"
            | "to be between"
            | "not to be within"
            | "not to be between"
        )[]
        | readonly (
            | number
            | "to be within"
            | "to be between"
            | "not to be within"
            | "not to be between"
        )[],
): void
Parameters
- ...args:
      | (
          | number
          | "to be within"
          | "to be between"
          | "not to be within"
          | "not to be between"
      )[]
      | readonly (
          | number
          | "to be within"
          | "to be between"
          | "not to be within"
          | "not to be between"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (number | "to be close to" | "not to be close to" | undefined)[]
        | readonly (number | "to be close to" | "not to be close to" | undefined)[],
): void
Parameters
- ...args:
  | (number | "to be close to" | "not to be close to" | undefined)[]
  | readonly (number | "to be close to" | "not to be close to" | undefined)[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | number
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to have arity"
            | "not to have arity"
        )[]
        | (
            | number
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to have arity"
            | "not to have arity"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | number
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to have arity"
          | "not to have arity"
      )[]
      | (
          | number
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to have arity"
          | "not to have arity"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(...args: readonly (string | Error)[] | (string | Error)[]): void
Parameters
- ...args: readonly (string | Error)[] | (string | Error)[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | RegExp
            | Error
            | "to have message matching"
            | "not to have message matching"
        )[]
        | (
            | RegExp
            | Error
            | "to have message matching"
            | "not to have message matching"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | RegExp
          | Error
          | "to have message matching"
          | "not to have message matching"
      )[]
      | (
          | RegExp
          | Error
          | "to have message matching"
          | "not to have message matching"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to throw"
            | "not to throw"
        )[]
        | (
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to throw"
            | "not to throw"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to throw"
          | "not to throw"
      )[]
      | (
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to throw"
          | "not to throw"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | Constructor
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to throw a"
            | "to throw an"
            | "not to throw a"
            | "not to throw an"
        )[]
        | (
            | Constructor
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to throw a"
            | "to throw an"
            | "not to throw a"
            | "not to throw an"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | Constructor
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to throw a"
          | "to throw an"
          | "not to throw a"
          | "not to throw an"
      )[]
      | (
          | Constructor
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to throw a"
          | "to throw an"
          | "not to throw a"
          | "not to throw an"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(...args: readonly (string | RegExp)[] | (string | RegExp)[]): void
Parameters
- ...args: readonly (string | RegExp)[] | (string | RegExp)[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (string | number | Date)[]
        | readonly (string | number | Date)[],
): void
Parameters
- ...args: (string | number | Date)[] | readonly (string | number | Date)[]
Returns void
- Defined in src/bootstrap.ts:43

Index

Properties

assertions createAssertion createAsyncAssertion fail it use

Properties

assertions

assertions: readonly [
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                ],
            >,
            readonly ["to contain", "to include"],
            ZodUnknown,
        ],
        (
            subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>,
            key: unknown,
        ) =>
            | { actual?: undefined; expected?: undefined; message: string }
            | { actual: unknown; expected: string; message: string }
            | undefined,
        readonly [
            ZodUnion<
                [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                ],
            >,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            "to have size",
            ZodInt,
        ],
        (
            _subject: Map<unknown, unknown>,
            expectedSize: number,
        ) => ZodMap<ZodUnknown, ZodUnknown>,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralSlot<"to have size">,
            ZodInt,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            "to be empty",
        ],
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                [
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                ],
            >,
            readonly ["to contain", "to include"],
            ZodUnknown,
        ],
        (
            subject: Set<unknown> | WeakSet<WeakKey>,
            value: unknown,
        ) =>
            | { actual?: undefined; expected?: undefined; message: string }
            | { actual: unknown; expected: string; message: string }
            | undefined,
        readonly [
            ZodUnion<
                [
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                ],
            >,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to have size",
            ZodInt,
        ],
        (_subject: Set<unknown>, expectedSize: number) => ZodSet<ZodUnknown>,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to have size">,
            ZodInt,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
        ZodCustom<Set<unknown>, Set<unknown>>,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodArray<ZodUnknown>,
            readonly ["to contain", "to include"],
            ZodUnknown,
        ],
        (subject: unknown[], value: unknown) => { message: string } | undefined,
        readonly [
            ZodArray<ZodUnknown>,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodArray<ZodUnknown>,
            readonly ["to have length", "to have size"],
            ZodInt,
        ],
        (_subject: unknown[], expectedSize: number) => ZodArray<ZodUnknown>,
        readonly [
            ZodArray<ZodUnknown>,
            PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>,
            ZodInt,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [ZodArray<ZodUnknown>, "to be non-empty"],
        ZodArray<ZodUnknown>,
        readonly [ZodArray<ZodUnknown>, PhraseLiteralSlot<"to be non-empty">],
    >,
    AssertionFunctionSync<
        readonly [
            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",
            ],
            ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>>,
        ],
        (
            _subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            keys: (string | number | symbol)[],
        ) => ZodCustom<
            Record<PropertyKey, unknown>
            | ((...args: any[]) => any),
            Record<PropertyKey, unknown> | ((...args: any[]) => any),
        >,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            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",
                ],
            >,
            ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            "to have size",
            ZodInt,
        ],
        (
            subject: Record<string | number | symbol, unknown>,
            expectedSize: number,
        ) => { actual: number; expected: number; message: string } | undefined,
        readonly [
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            PhraseLiteralSlot<"to have size">,
            ZodInt,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                "to have exact key",
                "to have exact property",
                "to have exact prop",
            ],
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
        ],
        (
            _: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            key: string | number | symbol,
        ) => ZodPipe<
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            ZodTransform<
                {},
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
            >,
        >,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have exact key",
                    "to have exact property",
                    "to have exact prop",
                ],
            >,
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                "to have key",
                "to have property",
                "to have prop",
                "to contain key",
                "to contain property",
                "to contain prop",
                "to include key",
                "to include property",
                "to include prop",
            ],
            ZodType<string, unknown, $ZodTypeInternals<string, unknown>>,
        ],
        (
            subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            keypath: string,
        ) => { actual: string; expect: string; message: string } | undefined,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have key",
                    "to have property",
                    "to have prop",
                    "to contain key",
                    "to contain property",
                    "to contain prop",
                    "to include key",
                    "to include property",
                    "to include prop",
                ],
            >,
            ZodType<string, unknown, $ZodTypeInternals<string, unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to equal",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (actual: Set<unknown>, expected: Set<unknown>) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to equal">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to be a subset of",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (subset: Set<unknown>, superset: Set<unknown>) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to be a subset of">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to be a superset of",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (superset: Set<unknown>, subset: Set<unknown>) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to be a superset of">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to intersect with",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (setA: Set<unknown>, setB: Set<unknown>) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to intersect with">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to be disjoint from",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (setA: Set<unknown>, setB: Set<unknown>) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to be disjoint from">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to have union",
            ZodCustom<Set<unknown>, Set<unknown>>,
            "equal to",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (
            setA: Set<unknown>,
            setB: Set<unknown>,
            expected: Set<unknown>,
        ) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to have union">,
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"equal to">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to have intersection",
            ZodCustom<Set<unknown>, Set<unknown>>,
            "equal to",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (
            setA: Set<unknown>,
            setB: Set<unknown>,
            expected: Set<unknown>,
        ) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to have intersection">,
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"equal to">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to have difference",
            ZodCustom<Set<unknown>, Set<unknown>>,
            "equal to",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (
            setA: Set<unknown>,
            setB: Set<unknown>,
            expected: Set<unknown>,
        ) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to have difference">,
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"equal to">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            "to have symmetric difference",
            ZodCustom<Set<unknown>, Set<unknown>>,
            "equal to",
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
        (
            setA: Set<unknown>,
            setB: Set<unknown>,
            expected: Set<unknown>,
        ) => boolean,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to have symmetric difference">,
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"equal to">,
            ZodCustom<Set<unknown>, Set<unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            "to have key",
            ZodUnknown,
        ],
        (
            map: Map<unknown, unknown>,
            key: unknown,
        ) =>
            | { actual: unknown[]; expected: unknown[]; message: string }
            | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralSlot<"to have key">,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly ["to have value", "to contain value", "to include value"],
            ZodUnknown,
        ],
        (
            map: Map<unknown, unknown>,
            value: unknown,
        ) => { actual: unknown[]; expected: unknown; message: string } | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralChoiceSlot<
                readonly ["to have value", "to contain value", "to include value"],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                ],
            >,
            readonly [
                "to have entry",
                "to have key/value pair",
                "to contain entry",
                "to contain key/value pair",
                "to include entry",
                "to include key/value pair",
            ],
            ZodTuple<[ZodUnknown, ZodUnknown], null>,
        ],
        (
            map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>,
            __namedParameters: [unknown, unknown],
        ) =>
            | { actual?: undefined; expected?: undefined; message: string }
            | { actual: unknown[] | undefined; expected: unknown[]; message: string }
            | undefined,
        readonly [
            ZodUnion<
                [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                ],
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have entry",
                    "to have key/value pair",
                    "to contain entry",
                    "to contain key/value pair",
                    "to include entry",
                    "to include key/value pair",
                ],
            >,
            ZodTuple<[ZodUnknown, ZodUnknown], null>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            "to equal",
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        ],
        (
            mapA: Map<unknown, unknown>,
            mapB: Map<unknown, unknown>,
        ) =>
            | { actual: number; expected: number; message: string }
            | { actual?: undefined; expected?: undefined; message: string }
            | { actual: unknown[]; expected: unknown[]; message: string }
            | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralSlot<"to equal">,
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            "to have size greater than",
            ZodInt,
        ],
        (
            collection: Map<unknown, unknown> | Set<unknown>,
            minSize: number,
        ) => { actual: number; expected: number; message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            PhraseLiteralSlot<"to have size greater than">,
            ZodInt,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            "to have size less than",
            ZodInt,
        ],
        (
            collection: Map<unknown, unknown> | Set<unknown>,
            maxSize: number,
        ) => { actual: number; expected: number; message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            PhraseLiteralSlot<"to have size less than">,
            ZodInt,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            "to have size between",
            ZodTuple<[ZodInt, ZodInt], null>,
        ],
        (
            collection: Map<unknown, unknown> | Set<unknown>,
            __namedParameters: [number, number],
        ) => { message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            PhraseLiteralSlot<"to have size between">,
            ZodTuple<[ZodInt, ZodInt], null>,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be an array", "to be array"]],
        ZodArray<ZodUnknown>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be an async function"],
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be a bigint", "to be a BigInt"]],
        ZodBigInt,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [
            readonly ["to be a boolean", "to be boolean", "to be a bool"],
        ],
        ZodBoolean,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [
            readonly [
                "to be a class",
                "to be a constructor",
                "to be constructible",
            ],
        ],
        ZodCustom<Constructor, Constructor>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be a date", "to be a Date"]],
        ZodDate,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be defined"],
        ZodNonOptional<ZodUnknown>,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodArray<ZodUnknown>,
                    ZodTuple<[ZodUnknown], ZodUnknown>,
                    ZodObject<{ length: ZodNumber }, $loose>,
                ],
            >,
            "to be empty",
        ],
        (
            subject:
                | unknown[]
                | [unknown, ...unknown[]]
                | { length: number; [key: string]: unknown },
        ) => { actual: number; expected: number; message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodArray<ZodUnknown>,
                    ZodTuple<[ZodUnknown], ZodUnknown>,
                    ZodObject<{ length: ZodNumber }, $loose>,
                ],
            >,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            "to be empty",
        ],
        ZodRecord<
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ZodUnknown,
        >,
        readonly [
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [ZodString, "to be empty"],
        ZodString,
        readonly [ZodString, PhraseLiteralSlot<"to be empty">],
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be an Error", "to be a Error"]],
        ZodCustom<Error, Error>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be false"],
        ZodLiteral<false>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be falsy"],
        ZodNullable<ZodAny>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be a function"],
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be infinite"],
        ZodUnion<[ZodLiteral<number>, ZodLiteral<number>]>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [
            readonly [
                "to be an integer",
                "to be a safe integer",
                "to be an int",
                "to be a safe int",
            ],
        ],
        ZodNumber,
        never,
    >,
    AssertionStandardSchemaSync<readonly ["to be NaN"], ZodNaN, never>,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be negative", "to be a negative number"]],
        ZodNumber,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be -Infinity"],
        ZodLiteral<number>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [
            readonly ["to be a negative integer", "to be a negative int"],
        ],
        ZodNumber,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [ZodString, "to be non-empty"],
        ZodString,
        readonly [ZodString, PhraseLiteralSlot<"to be non-empty">],
    >,
    AssertionStandardSchemaSync<readonly ["to be null"], ZodNull, never>,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be a number", "to be finite"]],
        ZodNumber,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be an object"],
        ZodNonOptional<ZodUnknown>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be positive", "to be a positive number"]],
        ZodNumber,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be Infinity"],
        ZodLiteral<number>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [
            readonly ["to be a positive integer", "to be a positive int"],
        ],
        ZodNumber,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be a primitive"],
        ZodUnion<
            readonly [
                ZodString,
                ZodNumber,
                ZodBoolean,
                ZodBigInt,
                ZodSymbol,
                ZodNull,
                ZodUndefined,
            ],
        >,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be a record", "to be a plain object"]],
        ZodRecord<
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ZodUnknown,
        >,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [
            readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
        ],
        ZodCustom<RegExp, RegExp>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be a Set"],
        ZodCustom<Set<unknown>, Set<unknown>>,
        never,
    >,
    AssertionStandardSchemaSync<readonly ["to be a string"], ZodString, never>,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be a symbol", "to be a Symbol"]],
        ZodSymbol,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be true"],
        ZodLiteral<true>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be truthy", "to exist", "to be ok"]],
        ZodNonOptional<ZodAny>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be undefined"],
        ZodUndefined,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be a WeakMap"],
        ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
        never,
    >,
    AssertionStandardSchemaSync<
        readonly ["to be a WeakSet"],
        ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            readonly ["to be an instance of", "to be a", "to be an"],
            ZodCustom<Constructor, Constructor>,
        ],
        (_: unknown, ctor: Constructor) => ZodCustom<Constructor, Constructor>,
        readonly [
            ZodUnknown,
            PhraseLiteralChoiceSlot<
                readonly ["to be an instance of", "to be a", "to be an"],
            >,
            ZodCustom<Constructor, Constructor>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnknown,
            readonly ["to be a", "to be an", "to have type"],
            ZodEnum<{ [key: string]: string }>,
        ],
        (
            _: unknown,
            type: string,
        ) =>
            | ZodString
            | ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >
            | ZodNumber
            | ZodSymbol
            | ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>
            | ZodBoolean
            | ZodBigInt
            | ZodNull
            | ZodUndefined
            | ZodArray<ZodUnknown>
            | ZodCustom<RegExp, RegExp>
            | ZodDate
            | ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>
            | ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>
            | ZodCustom<Error, Error>
            | ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>
            | ZodObject<{}, $loose>,
        readonly [
            ZodUnknown,
            PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>,
            ZodEnum<{ [key: string]: string }>,
        ],
    >,
    AssertionFunctionSync<
        readonly [ZodNumber, "to be greater than", ZodNumber],
        (_: number, other: number) => ZodNumber,
        readonly [ZodNumber, PhraseLiteralSlot<"to be greater than">, ZodNumber],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNumber,
            readonly ["to be less than", "to be lt"],
            ZodNumber,
        ],
        (_: number, other: number) => ZodNumber,
        readonly [
            ZodNumber,
            PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>,
            ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNumber,
            readonly [
                "to be greater than or equal to",
                "to be at least",
                "to be gte",
            ],
            ZodNumber,
        ],
        (_: number, other: number) => ZodNumber,
        readonly [
            ZodNumber,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to be greater than or equal to",
                    "to be at least",
                    "to be gte",
                ],
            >,
            ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNumber,
            readonly ["to be less than or equal to", "to be at most", "to be lte"],
            ZodNumber,
        ],
        (_: number, other: number) => ZodNumber,
        readonly [
            ZodNumber,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to be less than or equal to",
                    "to be at most",
                    "to be lte",
                ],
            >,
            ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNumber,
            readonly ["to be within", "to be between"],
            ZodNumber,
            ZodNumber,
        ],
        (
            subject: number,
            min: number,
            max: number,
        ) => { message: string } | undefined,
        readonly [
            ZodNumber,
            PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>,
            ZodNumber,
            ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNumber,
            "to be close to",
            ZodNumber,
            ZodOptional<ZodNumber>,
        ],
        (
            subject: number,
            expected: number,
            tolerance?: number | undefined,
        ) => { actual: number; expected: number; message: string } | undefined,
        readonly [
            ZodNumber,
            PhraseLiteralSlot<"to be close to">,
            ZodNumber,
            ZodOptional<ZodNumber>,
        ],
    >,
    AssertionFunctionSync<
        readonly [ZodString, "to be greater than", ZodString],
        (subject: string, other: string) => { message: string } | undefined,
        readonly [ZodString, PhraseLiteralSlot<"to be greater than">, ZodString],
    >,
    AssertionFunctionSync<
        readonly [ZodString, "to be less than", ZodString],
        (subject: string, other: string) => { message: string } | undefined,
        readonly [ZodString, PhraseLiteralSlot<"to be less than">, ZodString],
    >,
    AssertionFunctionSync<
        readonly [ZodString, "to be greater than or equal to", ZodString],
        (subject: string, other: string) => { message: string } | undefined,
        readonly [
            ZodString,
            PhraseLiteralSlot<"to be greater than or equal to">,
            ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [ZodString, "to be less than or equal to", ZodString],
        (subject: string, other: string) => { message: string } | undefined,
        readonly [
            ZodString,
            PhraseLiteralSlot<"to be less than or equal to">,
            ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodString,
            readonly ["to begin with", "to start with"],
            ZodString,
        ],
        (subject: string, prefix: string) => { message: string } | undefined,
        readonly [
            ZodString,
            PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>,
            ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [ZodString, "to end with", ZodString],
        (subject: string, suffix: string) => { message: string } | undefined,
        readonly [ZodString, PhraseLiteralSlot<"to end with">, ZodString],
    >,
    AssertionFunctionSync<
        readonly ["to be one of", ZodArray<ZodUnknown>],
        (
            subject: unknown,
            values: unknown[],
        ) => { actual: unknown; expected: unknown[]; message: string } | undefined,
        readonly [
            ZodUnknown,
            PhraseLiteralSlot<"to be one of">,
            ZodArray<ZodUnknown>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            "to have arity",
            ZodInt,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            expectedArity: number,
        ) => { actual: number; expected: number; message: string } | undefined,
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralSlot<"to have arity">,
            ZodInt,
        ],
    >,
    AssertionFunctionSync<
        readonly [ZodCustom<Error, Error>, "to have message", ZodString],
        (
            subject: Error,
            expectedMessage: string,
        ) => { actual: string; expected: string; message: string } | undefined,
        readonly [
            ZodCustom<Error, Error>,
            PhraseLiteralSlot<"to have message">,
            ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Error, Error>,
            "to have message matching",
            ZodCustom<RegExp, RegExp>,
        ],
        (subject: Error, pattern: RegExp) => { message: string } | undefined,
        readonly [
            ZodCustom<Error, Error>,
            PhraseLiteralSlot<"to have message matching">,
            ZodCustom<RegExp, RegExp>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            readonly [
                "to be",
                "to equal",
                "equals",
                "is",
                "is equal to",
                "to strictly equal",
                "is strictly equal to",
            ],
            ZodUnknown,
        ],
        (
            subject: unknown,
            value: unknown,
        ) => { actual: unknown; expected: unknown; message: string } | undefined,
        readonly [
            ZodUnknown,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to be",
                    "to equal",
                    "equals",
                    "is",
                    "is equal to",
                    "to strictly equal",
                    "is strictly equal to",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            readonly ["to deep equal", "to deeply equal"],
            ZodUnknown,
        ],
        (
            _: Record<string | number | symbol, unknown>,
            expected: unknown,
        ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        readonly [
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodArray<ZodUnknown>,
                    ZodTuple<[ZodUnknown], ZodUnknown>,
                    ZodObject<{ length: ZodNumber }, $loose>,
                ],
            >,
            readonly ["to deep equal", "to deeply equal"],
            ZodUnknown,
        ],
        (
            _:
                | unknown[]
                | [unknown, ...unknown[]]
                | { length: number; [key: string]: unknown },
            expected: unknown,
        ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        readonly [
            ZodUnion<
                readonly [
                    ZodArray<ZodUnknown>,
                    ZodTuple<[ZodUnknown], ZodUnknown>,
                    ZodObject<{ length: ZodNumber }, $loose>,
                ],
            >,
            PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly ["to deep equal", "to deeply equal"],
            ZodUnknown,
        ],
        (
            _: Map<unknown, unknown>,
            expected: unknown,
        ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            readonly ["to deep equal", "to deeply equal"],
            ZodUnknown,
        ],
        (
            _: Set<unknown>,
            expected: unknown,
        ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        readonly [
            ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            "to throw",
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralSlot<"to throw">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to throw a", "to throw an"],
            ZodCustom<Constructor, Constructor>,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ctor: Constructor,
        ) =>
            | { actual?: undefined; expected?: undefined; message: string }
            | { actual: string; expected: string; message: string }
            | undefined,
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>,
            ZodCustom<Constructor, Constructor>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to throw", "to throw error satisfying"],
            ZodUnknown,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            param: unknown,
        ) =>
            | { message: string; schema?: undefined; subject?: undefined }
            | {
                message?: undefined;
                schema: ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                subject: {} | null;
            },
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralChoiceSlot<
                readonly ["to throw", "to throw error satisfying"],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to throw a", "to throw an"],
            ZodCustom<Constructor, Constructor>,
            "satisfying",
            ZodUnknown,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ctor: Constructor,
            param: unknown,
        ) =>
            | { message: string; schema?: undefined; subject?: undefined }
            | {
                message?: undefined;
                schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                subject: {} | null;
            },
        readonly [
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>,
            ZodCustom<Constructor, Constructor>,
            PhraseLiteralSlot<"satisfying">,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodString,
            readonly ["includes", "contains", "to include", "to contain"],
            ZodString,
        ],
        (subject: string, expected: string) => { message: string } | undefined,
        readonly [
            ZodString,
            PhraseLiteralChoiceSlot<
                readonly ["includes", "contains", "to include", "to contain"],
            >,
            ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [ZodString, "to match", ZodCustom<RegExp, RegExp>],
        (subject: string, regex: RegExp) => boolean,
        readonly [
            ZodString,
            PhraseLiteralSlot<"to match">,
            ZodCustom<RegExp, RegExp>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNonOptional<ZodObject<{}, $loose>>,
            readonly ["to satisfy", "to be like", "satisfies"],
            ZodUnknown,
        ],
        (
            _subject: { [key: string]: unknown },
            shape: unknown,
        ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        readonly [
            ZodNonOptional<ZodObject<{}, $loose>>,
            PhraseLiteralChoiceSlot<
                readonly ["to satisfy", "to be like", "satisfies"],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodArray<ZodUnknown>,
                    ZodTuple<[ZodUnknown], ZodUnknown>,
                    ZodObject<{ length: ZodNumber }, $loose>,
                ],
            >,
            readonly ["to satisfy", "to be like"],
            ZodUnknown,
        ],
        (
            _subject:
                | unknown[]
                | [unknown, ...unknown[]]
                | { length: number; [key: string]: unknown },
            shape: unknown,
        ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        readonly [
            ZodUnion<
                readonly [
                    ZodArray<ZodUnknown>,
                    ZodTuple<[ZodUnknown], ZodUnknown>,
                    ZodObject<{ length: ZodNumber }, $loose>,
                ],
            >,
            PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
            ZodUnknown,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to have a null prototype", "to be a dictionary"]],
        ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>,
        never,
    >,
    AssertionFunctionSync<
        readonly ["to be frozen"],
        (
            subject: unknown,
        ) => { actual: boolean; expected: boolean; message: string } | undefined,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            "to be an enumerable property of",
            ZodNonOptional<ZodUnknown>,
        ],
        (
            subject: string | number | symbol,
            obj: unknown,
        ) => { actual: boolean; expected: boolean; message: string } | undefined,
        readonly [
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            PhraseLiteralSlot<"to be an enumerable property of">,
            ZodNonOptional<ZodUnknown>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodNonOptional<ZodUnknown>,
            "to have enumerable property",
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
        ],
        (
            _subject: unknown,
            key: string | number | symbol,
        ) => ZodCustom<unknown, unknown>,
        readonly [
            ZodNonOptional<ZodUnknown>,
            PhraseLiteralSlot<"to have enumerable property">,
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
        ],
    >,
    AssertionStandardSchemaSync<readonly ["to be sealed"], ZodUnknown, never>,
    AssertionStandardSchemaSync<
        readonly ["to be extensible"],
        ZodUnknown,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "to be after",
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
        (
            subject: string | number | Date,
            other: string | number | Date,
        ) =>
            | { message: string; schema?: undefined; subject?: undefined }
            | { message?: undefined; schema: ZodDate; subject: Date },
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"to be after">,
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "to be before",
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
        (
            subject: string | number | Date,
            other: string | number | Date,
        ) =>
            | { message: string; schema?: undefined; subject?: undefined }
            | { message?: undefined; schema: ZodDate; subject: Date },
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"to be before">,
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "to be between",
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "and",
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
        (
            subject: string | number | Date,
            start: string | number | Date,
            end: string | number | Date,
        ) =>
            | { message: string; schema?: undefined; subject?: undefined }
            | { message?: undefined; schema: ZodDate; subject: Date },
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"to be between">,
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"and">,
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "to equal",
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "within",
            ZodCustomStringFormat<"duration">,
        ],
        (
            subject: string | number | Date,
            other: string | number | Date,
            toleranceStr: string,
        ) =>
            | { actual?: undefined; expected?: undefined; message: string }
            | {
                actual: { difference: number };
                expected: { maxDifference: number };
                message: string;
            }
            | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"to equal">,
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"within">,
            ZodCustomStringFormat<"duration">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            "to be the same date as",
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
        (
            subject: string | number | Date,
            other: string | number | Date,
        ) =>
            | { actual?: undefined; expected?: undefined; message: string }
            | { actual: string; expected: string; message: string }
            | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            PhraseLiteralSlot<"to be the same date as">,
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
        ],
    >,
    AssertionStandardSchemaSync<
        readonly [readonly ["to be a valid date", "to be date-like"]],
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        never,
    >,
    AssertionFunctionSync<
        readonly ["to be a weekday"],
        (subject: unknown) => { message: string } | undefined,
        never,
    >,
    AssertionFunctionSync<
        readonly ["to be a weekend"],
        (subject: unknown) => { message: string } | undefined,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnknown,
            readonly [
                "to match snapshot",
                "to match the snapshot",
                "to equal snapshot",
                "to equal the snapshot",
            ],
            ZodNonOptional<ZodUnknown>,
        ],
        (actual: unknown, context: unknown) => void | AssertionFailure,
        readonly [
            ZodUnknown,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to match snapshot",
                    "to match the snapshot",
                    "to equal snapshot",
                    "to equal the snapshot",
                ],
            >,
            ZodNonOptional<ZodUnknown>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnknown,
            readonly [
                "to match snapshot",
                "to match the snapshot",
                "to equal snapshot",
                "to equal the snapshot",
            ],
            ZodNonOptional<ZodUnknown>,
            "with options",
            ZodObject<
                { hint: ZodOptional<ZodString>; serializer: ZodOptional<ZodAny> },
                $strip,
            >,
        ],
        (
            actual: unknown,
            context: unknown,
            options: { hint?: string; serializer?: any },
        ) => void | AssertionFailure,
        readonly [
            ZodUnknown,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to match snapshot",
                    "to match the snapshot",
                    "to equal snapshot",
                    "to equal the snapshot",
                ],
            >,
            ZodNonOptional<ZodUnknown>,
            PhraseLiteralSlot<"with options">,
            ZodObject<
                { hint: ZodOptional<ZodString>; serializer: ZodOptional<ZodAny> },
                $strip,
            >,
        ],
    >,
]

Tuple of all assertions available in this expect().

createAssertion

createAssertion: CreateAssertionFn

Creates a new synchronous assertion.

createAsyncAssertion

createAsyncAssertion: CreateAsyncAssertionFn

Creates a new asynchronous assertion.

fail

fail: FailFn

Fails immediately with optional reason.

Param: reason

Reason for failure

Throws

it

it: ExpectItFunction<
    readonly [
        ZodUnion<
            [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
            ],
        >,
        readonly ["to contain", "to include"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        "to have size",
        ZodInt,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        "to be empty",
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            [
                ZodCustom<Set<unknown>, Set<unknown>>,
                ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
            ],
        >,
        readonly ["to contain", "to include"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [ZodCustom<Set<unknown>, Set<unknown>>, "to have size", ZodInt],
> & ExpectItFunction<
    readonly [ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
> & ExpectItFunction<
    readonly [
        ZodArray<ZodUnknown>,
        readonly ["to contain", "to include"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodArray<ZodUnknown>,
        readonly ["to have length", "to have size"],
        ZodInt,
    ],
> & ExpectItFunction<readonly [ZodArray<ZodUnknown>, "to be non-empty"]> & ExpectItFunction<
    readonly [
        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",
        ],
        ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodRecord<
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ZodUnknown,
        >,
        "to have size",
        ZodInt,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            Record<PropertyKey, unknown>
            | ((...args: any[]) => any),
            Record<PropertyKey, unknown> | ((...args: any[]) => any),
        >,
        readonly [
            "to have exact key",
            "to have exact property",
            "to have exact prop",
        ],
        ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            Record<PropertyKey, unknown>
            | ((...args: any[]) => any),
            Record<PropertyKey, unknown> | ((...args: any[]) => any),
        >,
        readonly [
            "to have key",
            "to have property",
            "to have prop",
            "to contain key",
            "to contain property",
            "to contain prop",
            "to include key",
            "to include property",
            "to include prop",
        ],
        ZodType<string, unknown, $ZodTypeInternals<string, unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to equal",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to be a subset of",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to be a superset of",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to intersect with",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to be disjoint from",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to have union",
        ZodCustom<Set<unknown>, Set<unknown>>,
        "equal to",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to have intersection",
        ZodCustom<Set<unknown>, Set<unknown>>,
        "equal to",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to have difference",
        ZodCustom<Set<unknown>, Set<unknown>>,
        "equal to",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        "to have symmetric difference",
        ZodCustom<Set<unknown>, Set<unknown>>,
        "equal to",
        ZodCustom<Set<unknown>, Set<unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        "to have key",
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        readonly ["to have value", "to contain value", "to include value"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
            ],
        >,
        readonly [
            "to have entry",
            "to have key/value pair",
            "to contain entry",
            "to contain key/value pair",
            "to include entry",
            "to include key/value pair",
        ],
        ZodTuple<[ZodUnknown, ZodUnknown], null>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        "to equal",
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        "to have size greater than",
        ZodInt,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        "to have size less than",
        ZodInt,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        "to have size between",
        ZodTuple<[ZodInt, ZodInt], null>,
    ],
> & ExpectItFunction<readonly [readonly ["to be an array", "to be array"]]> & ExpectItFunction<
    readonly ["to be an async function"],
> & ExpectItFunction<
    readonly [readonly ["to be a bigint", "to be a BigInt"]],
> & ExpectItFunction<
    readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]],
> & ExpectItFunction<
    readonly [
        readonly [
            "to be a class",
            "to be a constructor",
            "to be constructible",
        ],
    ],
> & ExpectItFunction<readonly [readonly ["to be a date", "to be a Date"]]> & ExpectItFunction<
    readonly ["to be defined"],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodArray<ZodUnknown>,
                ZodTuple<[ZodUnknown], ZodUnknown>,
                ZodObject<{ length: ZodNumber }, $loose>,
            ],
        >,
        "to be empty",
    ],
> & ExpectItFunction<
    readonly [
        ZodRecord<
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ZodUnknown,
        >,
        "to be empty",
    ],
> & ExpectItFunction<readonly [ZodString, "to be empty"]> & ExpectItFunction<
    readonly [readonly ["to be an Error", "to be a Error"]],
> & ExpectItFunction<readonly ["to be false"]> & ExpectItFunction<
    readonly ["to be falsy"],
> & ExpectItFunction<readonly ["to be a function"]> & ExpectItFunction<
    readonly ["to be infinite"],
> & ExpectItFunction<
    readonly [
        readonly [
            "to be an integer",
            "to be a safe integer",
            "to be an int",
            "to be a safe int",
        ],
    ],
> & ExpectItFunction<readonly ["to be NaN"]> & ExpectItFunction<
    readonly [readonly ["to be negative", "to be a negative number"]],
> & ExpectItFunction<readonly ["to be -Infinity"]> & ExpectItFunction<
    readonly [readonly ["to be a negative integer", "to be a negative int"]],
> & ExpectItFunction<readonly [ZodString, "to be non-empty"]> & ExpectItFunction<
    readonly ["to be null"],
> & ExpectItFunction<readonly [readonly ["to be a number", "to be finite"]]> & ExpectItFunction<
    readonly ["to be an object"],
> & ExpectItFunction<
    readonly [readonly ["to be positive", "to be a positive number"]],
> & ExpectItFunction<readonly ["to be Infinity"]> & ExpectItFunction<
    readonly [readonly ["to be a positive integer", "to be a positive int"]],
> & ExpectItFunction<readonly ["to be a primitive"]> & ExpectItFunction<
    readonly [readonly ["to be a record", "to be a plain object"]],
> & ExpectItFunction<
    readonly [
        readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
    ],
> & ExpectItFunction<readonly ["to be a Set"]> & ExpectItFunction<
    readonly ["to be a string"],
> & ExpectItFunction<
    readonly [readonly ["to be a symbol", "to be a Symbol"]],
> & ExpectItFunction<readonly ["to be true"]> & ExpectItFunction<
    readonly [readonly ["to be truthy", "to exist", "to be ok"]],
> & ExpectItFunction<readonly ["to be undefined"]> & ExpectItFunction<
    readonly ["to be a WeakMap"],
> & ExpectItFunction<readonly ["to be a WeakSet"]> & ExpectItFunction<
    readonly [
        readonly ["to be an instance of", "to be a", "to be an"],
        ZodCustom<Constructor, Constructor>,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnknown,
        readonly ["to be a", "to be an", "to have type"],
        ZodEnum<{ [key: string]: string }>,
    ],
> & ExpectItFunction<readonly [ZodNumber, "to be greater than", ZodNumber]> & ExpectItFunction<
    readonly [
        ZodNumber,
        readonly ["to be less than", "to be lt"],
        ZodNumber,
    ],
> & ExpectItFunction<
    readonly [
        ZodNumber,
        readonly ["to be greater than or equal to", "to be at least", "to be gte"],
        ZodNumber,
    ],
> & ExpectItFunction<
    readonly [
        ZodNumber,
        readonly ["to be less than or equal to", "to be at most", "to be lte"],
        ZodNumber,
    ],
> & ExpectItFunction<
    readonly [
        ZodNumber,
        readonly ["to be within", "to be between"],
        ZodNumber,
        ZodNumber,
    ],
> & ExpectItFunction<
    readonly [
        ZodNumber,
        "to be close to",
        ZodNumber,
        ZodOptional<ZodNumber>,
    ],
> & ExpectItFunction<readonly [ZodString, "to be greater than", ZodString]> & ExpectItFunction<
    readonly [ZodString, "to be less than", ZodString],
> & ExpectItFunction<
    readonly [ZodString, "to be greater than or equal to", ZodString],
> & ExpectItFunction<
    readonly [ZodString, "to be less than or equal to", ZodString],
> & ExpectItFunction<
    readonly [
        ZodString,
        readonly ["to begin with", "to start with"],
        ZodString,
    ],
> & ExpectItFunction<readonly [ZodString, "to end with", ZodString]> & ExpectItFunction<
    readonly ["to be one of", ZodArray<ZodUnknown>],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        "to have arity",
        ZodInt,
    ],
> & ExpectItFunction<
    readonly [ZodCustom<Error, Error>, "to have message", ZodString],
> & ExpectItFunction<
    readonly [
        ZodCustom<Error, Error>,
        "to have message matching",
        ZodCustom<RegExp, RegExp>,
    ],
> & ExpectItFunction<
    readonly [
        readonly [
            "to be",
            "to equal",
            "equals",
            "is",
            "is equal to",
            "to strictly equal",
            "is strictly equal to",
        ],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodRecord<
            ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ZodUnknown,
        >,
        readonly ["to deep equal", "to deeply equal"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodArray<ZodUnknown>,
                ZodTuple<[ZodUnknown], ZodUnknown>,
                ZodObject<{ length: ZodNumber }, $loose>,
            ],
        >,
        readonly ["to deep equal", "to deeply equal"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
        readonly ["to deep equal", "to deeply equal"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<Set<unknown>, Set<unknown>>,
        readonly ["to deep equal", "to deeply equal"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        "to throw",
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        readonly ["to throw a", "to throw an"],
        ZodCustom<Constructor, Constructor>,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        readonly ["to throw", "to throw error satisfying"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodCustom<
            (...args: unknown[] | readonly unknown[]) => unknown,
            (...args: unknown[] | readonly unknown[]) => unknown,
        >,
        readonly ["to throw a", "to throw an"],
        ZodCustom<Constructor, Constructor>,
        "satisfying",
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodString,
        readonly ["includes", "contains", "to include", "to contain"],
        ZodString,
    ],
> & ExpectItFunction<
    readonly [ZodString, "to match", ZodCustom<RegExp, RegExp>],
> & ExpectItFunction<
    readonly [
        ZodNonOptional<ZodObject<{}, $loose>>,
        readonly ["to satisfy", "to be like", "satisfies"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodArray<ZodUnknown>,
                ZodTuple<[ZodUnknown], ZodUnknown>,
                ZodObject<{ length: ZodNumber }, $loose>,
            ],
        >,
        readonly ["to satisfy", "to be like"],
        ZodUnknown,
    ],
> & ExpectItFunction<
    readonly [readonly ["to have a null prototype", "to be a dictionary"]],
> & ExpectItFunction<readonly ["to be frozen"]> & ExpectItFunction<
    readonly [
        ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
        "to be an enumerable property of",
        ZodNonOptional<ZodUnknown>,
    ],
> & ExpectItFunction<
    readonly [
        ZodNonOptional<ZodUnknown>,
        "to have enumerable property",
        ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
    ],
> & ExpectItFunction<readonly ["to be sealed"]> & ExpectItFunction<
    readonly ["to be extensible"],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "to be after",
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "to be before",
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "to be between",
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "and",
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "to equal",
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "within",
        ZodCustomStringFormat<"duration">,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
        "to be the same date as",
        ZodUnion<
            readonly [
                ZodDate,
                ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                ZodNumber,
            ],
        >,
    ],
> & ExpectItFunction<
    readonly [readonly ["to be a valid date", "to be date-like"]],
> & ExpectItFunction<readonly ["to be a weekday"]> & ExpectItFunction<
    readonly ["to be a weekend"],
> & ExpectItFunction<
    readonly [
        ZodUnknown,
        readonly [
            "to match snapshot",
            "to match the snapshot",
            "to equal snapshot",
            "to equal the snapshot",
        ],
        ZodNonOptional<ZodUnknown>,
    ],
> & ExpectItFunction<
    readonly [
        ZodUnknown,
        readonly [
            "to match snapshot",
            "to match the snapshot",
            "to equal snapshot",
            "to equal the snapshot",
        ],
        ZodNonOptional<ZodUnknown>,
        "with options",
        ZodObject<
            { hint: ZodOptional<ZodString>; serializer: ZodOptional<ZodAny> },
            $strip,
        >,
    ],
>

use

use: UseFn<
    readonly [
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                    ],
                >,
                readonly ["to contain", "to include"],
                ZodUnknown,
            ],
            (
                subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>,
                key: unknown,
            ) =>
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: unknown; expected: string; message: string }
                | undefined,
            readonly [
                ZodUnion<
                    [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to have size",
                ZodInt,
            ],
            (
                _subject: Map<unknown, unknown>,
                expectedSize: number,
            ) => ZodMap<ZodUnknown, ZodUnknown>,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to have size">,
                ZodInt,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to be empty",
            ],
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    [
                        ZodCustom<Set<unknown>, Set<unknown>>,
                        ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                    ],
                >,
                readonly ["to contain", "to include"],
                ZodUnknown,
            ],
            (
                subject: Set<unknown> | WeakSet<WeakKey>,
                value: unknown,
            ) =>
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: unknown; expected: string; message: string }
                | undefined,
            readonly [
                ZodUnion<
                    [
                        ZodCustom<Set<unknown>, Set<unknown>>,
                        ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to have size",
                ZodInt,
            ],
            (_subject: Set<unknown>, expectedSize: number) => ZodSet<ZodUnknown>,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have size">,
                ZodInt,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
            ZodCustom<Set<unknown>, Set<unknown>>,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodArray<ZodUnknown>,
                readonly ["to contain", "to include"],
                ZodUnknown,
            ],
            (subject: unknown[], value: unknown) => { message: string } | undefined,
            readonly [
                ZodArray<ZodUnknown>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodArray<ZodUnknown>,
                readonly ["to have length", "to have size"],
                ZodInt,
            ],
            (_subject: unknown[], expectedSize: number) => ZodArray<ZodUnknown>,
            readonly [
                ZodArray<ZodUnknown>,
                PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>,
                ZodInt,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [ZodArray<ZodUnknown>, "to be non-empty"],
            ZodArray<ZodUnknown>,
            readonly [ZodArray<ZodUnknown>, PhraseLiteralSlot<"to be non-empty">],
        >,
        AssertionFunctionSync<
            readonly [
                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",
                ],
                ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>>,
            ],
            (
                _subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
                keys: (string | number | symbol)[],
            ) => ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                ZodCustom<
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                    Record<PropertyKey, unknown> | ((...args: any[]) => any),
                >,
                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",
                    ],
                >,
                ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodRecord<
                    ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                    ZodUnknown,
                >,
                "to have size",
                ZodInt,
            ],
            (
                subject: Record<string | number | symbol, unknown>,
                expectedSize: number,
            ) => { actual: number; expected: number; message: string } | undefined,
            readonly [
                ZodRecord<
                    ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                    ZodUnknown,
                >,
                PhraseLiteralSlot<"to have size">,
                ZodInt,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                    Record<PropertyKey, unknown> | ((...args: any[]) => any),
                >,
                readonly [
                    "to have exact key",
                    "to have exact property",
                    "to have exact prop",
                ],
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ],
            (
                _: Record<PropertyKey, unknown> | ((...args: any[]) => any),
                key: string | number | symbol,
            ) => ZodPipe<
                ZodCustom<
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                    Record<PropertyKey, unknown> | ((...args: any[]) => any),
                >,
                ZodTransform<
                    {},
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                >,
            >,
            readonly [
                ZodCustom<
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                    Record<PropertyKey, unknown> | ((...args: any[]) => any),
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to have exact key",
                        "to have exact property",
                        "to have exact prop",
                    ],
                >,
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                    Record<PropertyKey, unknown> | ((...args: any[]) => any),
                >,
                readonly [
                    "to have key",
                    "to have property",
                    "to have prop",
                    "to contain key",
                    "to contain property",
                    "to contain prop",
                    "to include key",
                    "to include property",
                    "to include prop",
                ],
                ZodType<string, unknown, $ZodTypeInternals<string, unknown>>,
            ],
            (
                subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
                keypath: string,
            ) => { actual: string; expect: string; message: string } | undefined,
            readonly [
                ZodCustom<
                    Record<PropertyKey, unknown>
                    | ((...args: any[]) => any),
                    Record<PropertyKey, unknown> | ((...args: any[]) => any),
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to have key",
                        "to have property",
                        "to have prop",
                        "to contain key",
                        "to contain property",
                        "to contain prop",
                        "to include key",
                        "to include property",
                        "to include prop",
                    ],
                >,
                ZodType<string, unknown, $ZodTypeInternals<string, unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to equal",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (actual: Set<unknown>, expected: Set<unknown>) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to equal">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to be a subset of",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (subset: Set<unknown>, superset: Set<unknown>) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to be a subset of">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to be a superset of",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (superset: Set<unknown>, subset: Set<unknown>) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to be a superset of">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to intersect with",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (setA: Set<unknown>, setB: Set<unknown>) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to intersect with">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to be disjoint from",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (setA: Set<unknown>, setB: Set<unknown>) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to be disjoint from">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to have union",
                ZodCustom<Set<unknown>, Set<unknown>>,
                "equal to",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (
                setA: Set<unknown>,
                setB: Set<unknown>,
                expected: Set<unknown>,
            ) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have union">,
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"equal to">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to have intersection",
                ZodCustom<Set<unknown>, Set<unknown>>,
                "equal to",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (
                setA: Set<unknown>,
                setB: Set<unknown>,
                expected: Set<unknown>,
            ) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have intersection">,
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"equal to">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to have difference",
                ZodCustom<Set<unknown>, Set<unknown>>,
                "equal to",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (
                setA: Set<unknown>,
                setB: Set<unknown>,
                expected: Set<unknown>,
            ) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have difference">,
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"equal to">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                "to have symmetric difference",
                ZodCustom<Set<unknown>, Set<unknown>>,
                "equal to",
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
            (
                setA: Set<unknown>,
                setB: Set<unknown>,
                expected: Set<unknown>,
            ) => boolean,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have symmetric difference">,
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"equal to">,
                ZodCustom<Set<unknown>, Set<unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to have key",
                ZodUnknown,
            ],
            (
                map: Map<unknown, unknown>,
                key: unknown,
            ) =>
                | { actual: unknown[]; expected: unknown[]; message: string }
                | undefined,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to have key">,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                readonly ["to have value", "to contain value", "to include value"],
                ZodUnknown,
            ],
            (
                map: Map<unknown, unknown>,
                value: unknown,
            ) =>
                | { actual: unknown[]; expected: unknown; message: string }
                | undefined,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly ["to have value", "to contain value", "to include value"],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                    ],
                >,
                readonly [
                    "to have entry",
                    "to have key/value pair",
                    "to contain entry",
                    "to contain key/value pair",
                    "to include entry",
                    "to include key/value pair",
                ],
                ZodTuple<[ZodUnknown, ZodUnknown], null>,
            ],
            (
                map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>,
                __namedParameters: [unknown, unknown],
            ) =>
                | { actual?: undefined; expected?: undefined; message: string }
                | {
                    actual: unknown[] | undefined;
                    expected: unknown[];
                    message: string;
                }
                | undefined,
            readonly [
                ZodUnion<
                    [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                    ],
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to have entry",
                        "to have key/value pair",
                        "to contain entry",
                        "to contain key/value pair",
                        "to include entry",
                        "to include key/value pair",
                    ],
                >,
                ZodTuple<[ZodUnknown, ZodUnknown], null>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to equal",
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            ],
            (
                mapA: Map<unknown, unknown>,
                mapB: Map<unknown, unknown>,
            ) =>
                | { actual: number; expected: number; message: string }
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: unknown[]; expected: unknown[]; message: string }
                | undefined,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to equal">,
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<Set<unknown>, Set<unknown>>,
                    ],
                >,
                "to have size greater than",
                ZodInt,
            ],
            (
                collection: Map<unknown, unknown> | Set<unknown>,
                minSize: number,
            ) => { actual: number; expected: number; message: string } | undefined,
            readonly [
                ZodUnion<
                    readonly [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<Set<unknown>, Set<unknown>>,
                    ],
                >,
                PhraseLiteralSlot<"to have size greater than">,
                ZodInt,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<Set<unknown>, Set<unknown>>,
                    ],
                >,
                "to have size less than",
                ZodInt,
            ],
            (
                collection: Map<unknown, unknown> | Set<unknown>,
                maxSize: number,
            ) => { actual: number; expected: number; message: string } | undefined,
            readonly [
                ZodUnion<
                    readonly [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<Set<unknown>, Set<unknown>>,
                    ],
                >,
                PhraseLiteralSlot<"to have size less than">,
                ZodInt,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<Set<unknown>, Set<unknown>>,
                    ],
                >,
                "to have size between",
                ZodTuple<[ZodInt, ZodInt], null>,
            ],
            (
                collection: Map<unknown, unknown> | Set<unknown>,
                __namedParameters: [number, number],
            ) => { message: string } | undefined,
            readonly [
                ZodUnion<
                    readonly [
                        ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        ZodCustom<Set<unknown>, Set<unknown>>,
                    ],
                >,
                PhraseLiteralSlot<"to have size between">,
                ZodTuple<[ZodInt, ZodInt], null>,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be an array", "to be array"]],
            ZodArray<ZodUnknown>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be an async function"],
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be a bigint", "to be a BigInt"]],
            ZodBigInt,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [
                readonly ["to be a boolean", "to be boolean", "to be a bool"],
            ],
            ZodBoolean,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [
                readonly [
                    "to be a class",
                    "to be a constructor",
                    "to be constructible",
                ],
            ],
            ZodCustom<Constructor, Constructor>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be a date", "to be a Date"]],
            ZodDate,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be defined"],
            ZodNonOptional<ZodUnknown>,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodArray<ZodUnknown>,
                        ZodTuple<[ZodUnknown], ZodUnknown>,
                        ZodObject<{ length: ZodNumber }, $loose>,
                    ],
                >,
                "to be empty",
            ],
            (
                subject:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
            ) => { actual: number; expected: number; message: string } | undefined,
            readonly [
                ZodUnion<
                    readonly [
                        ZodArray<ZodUnknown>,
                        ZodTuple<[ZodUnknown], ZodUnknown>,
                        ZodObject<{ length: ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [
                ZodRecord<
                    ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                    ZodUnknown,
                >,
                "to be empty",
            ],
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            readonly [
                ZodRecord<
                    ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                    ZodUnknown,
                >,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [ZodString, "to be empty"],
            ZodString,
            readonly [ZodString, PhraseLiteralSlot<"to be empty">],
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be an Error", "to be a Error"]],
            ZodCustom<Error, Error>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be false"],
            ZodLiteral<false>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be falsy"],
            ZodNullable<ZodAny>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be a function"],
            ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be infinite"],
            ZodUnion<[ZodLiteral<number>, ZodLiteral<number>]>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [
                readonly [
                    "to be an integer",
                    "to be a safe integer",
                    "to be an int",
                    "to be a safe int",
                ],
            ],
            ZodNumber,
            never,
        >,
        AssertionStandardSchemaSync<readonly ["to be NaN"], ZodNaN, never>,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be negative", "to be a negative number"]],
            ZodNumber,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be -Infinity"],
            ZodLiteral<number>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [
                readonly ["to be a negative integer", "to be a negative int"],
            ],
            ZodNumber,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [ZodString, "to be non-empty"],
            ZodString,
            readonly [ZodString, PhraseLiteralSlot<"to be non-empty">],
        >,
        AssertionStandardSchemaSync<readonly ["to be null"], ZodNull, never>,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be a number", "to be finite"]],
            ZodNumber,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be an object"],
            ZodNonOptional<ZodUnknown>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be positive", "to be a positive number"]],
            ZodNumber,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be Infinity"],
            ZodLiteral<number>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [
                readonly ["to be a positive integer", "to be a positive int"],
            ],
            ZodNumber,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be a primitive"],
            ZodUnion<
                readonly [
                    ZodString,
                    ZodNumber,
                    ZodBoolean,
                    ZodBigInt,
                    ZodSymbol,
                    ZodNull,
                    ZodUndefined,
                ],
            >,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be a record", "to be a plain object"]],
            ZodRecord<
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                ZodUnknown,
            >,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [
                readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
            ],
            ZodCustom<RegExp, RegExp>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be a Set"],
            ZodCustom<Set<unknown>, Set<unknown>>,
            never,
        >,
        AssertionStandardSchemaSync<readonly ["to be a string"], ZodString, never>,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be a symbol", "to be a Symbol"]],
            ZodSymbol,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be true"],
            ZodLiteral<true>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be truthy", "to exist", "to be ok"]],
            ZodNonOptional<ZodAny>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be undefined"],
            ZodUndefined,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be a WeakMap"],
            ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
            never,
        >,
        AssertionStandardSchemaSync<
            readonly ["to be a WeakSet"],
            ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                readonly ["to be an instance of", "to be a", "to be an"],
                ZodCustom<Constructor, Constructor>,
            ],
            (_: unknown, ctor: Constructor) => ZodCustom<Constructor, Constructor>,
            readonly [
                ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly ["to be an instance of", "to be a", "to be an"],
                >,
                ZodCustom<Constructor, Constructor>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnknown,
                readonly ["to be a", "to be an", "to have type"],
                ZodEnum<{ [key: string]: string }>,
            ],
            (
                _: unknown,
                type: string,
            ) =>
                | ZodString
                | ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >
                | ZodNumber
                | ZodSymbol
                | ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>
                | ZodBoolean
                | ZodBigInt
                | ZodNull
                | ZodUndefined
                | ZodArray<ZodUnknown>
                | ZodCustom<RegExp, RegExp>
                | ZodDate
                | ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>
                | ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>
                | ZodCustom<Error, Error>
                | ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>
                | ZodObject<{}, $loose>,
            readonly [
                ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly ["to be a", "to be an", "to have type"],
                >,
                ZodEnum<{ [key: string]: string }>,
            ],
        >,
        AssertionFunctionSync<
            readonly [ZodNumber, "to be greater than", ZodNumber],
            (_: number, other: number) => ZodNumber,
            readonly [ZodNumber, PhraseLiteralSlot<"to be greater than">, ZodNumber],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNumber,
                readonly ["to be less than", "to be lt"],
                ZodNumber,
            ],
            (_: number, other: number) => ZodNumber,
            readonly [
                ZodNumber,
                PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>,
                ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNumber,
                readonly [
                    "to be greater than or equal to",
                    "to be at least",
                    "to be gte",
                ],
                ZodNumber,
            ],
            (_: number, other: number) => ZodNumber,
            readonly [
                ZodNumber,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to be greater than or equal to",
                        "to be at least",
                        "to be gte",
                    ],
                >,
                ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNumber,
                readonly ["to be less than or equal to", "to be at most", "to be lte"],
                ZodNumber,
            ],
            (_: number, other: number) => ZodNumber,
            readonly [
                ZodNumber,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to be less than or equal to",
                        "to be at most",
                        "to be lte",
                    ],
                >,
                ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNumber,
                readonly ["to be within", "to be between"],
                ZodNumber,
                ZodNumber,
            ],
            (
                subject: number,
                min: number,
                max: number,
            ) => { message: string } | undefined,
            readonly [
                ZodNumber,
                PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>,
                ZodNumber,
                ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNumber,
                "to be close to",
                ZodNumber,
                ZodOptional<ZodNumber>,
            ],
            (
                subject: number,
                expected: number,
                tolerance?: number | undefined,
            ) => { actual: number; expected: number; message: string } | undefined,
            readonly [
                ZodNumber,
                PhraseLiteralSlot<"to be close to">,
                ZodNumber,
                ZodOptional<ZodNumber>,
            ],
        >,
        AssertionFunctionSync<
            readonly [ZodString, "to be greater than", ZodString],
            (subject: string, other: string) => { message: string } | undefined,
            readonly [ZodString, PhraseLiteralSlot<"to be greater than">, ZodString],
        >,
        AssertionFunctionSync<
            readonly [ZodString, "to be less than", ZodString],
            (subject: string, other: string) => { message: string } | undefined,
            readonly [ZodString, PhraseLiteralSlot<"to be less than">, ZodString],
        >,
        AssertionFunctionSync<
            readonly [ZodString, "to be greater than or equal to", ZodString],
            (subject: string, other: string) => { message: string } | undefined,
            readonly [
                ZodString,
                PhraseLiteralSlot<"to be greater than or equal to">,
                ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [ZodString, "to be less than or equal to", ZodString],
            (subject: string, other: string) => { message: string } | undefined,
            readonly [
                ZodString,
                PhraseLiteralSlot<"to be less than or equal to">,
                ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodString,
                readonly ["to begin with", "to start with"],
                ZodString,
            ],
            (subject: string, prefix: string) => { message: string } | undefined,
            readonly [
                ZodString,
                PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>,
                ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [ZodString, "to end with", ZodString],
            (subject: string, suffix: string) => { message: string } | undefined,
            readonly [ZodString, PhraseLiteralSlot<"to end with">, ZodString],
        >,
        AssertionFunctionSync<
            readonly ["to be one of", ZodArray<ZodUnknown>],
            (
                subject: unknown,
                values: unknown[],
            ) =>
                | { actual: unknown; expected: unknown[]; message: string }
                | undefined,
            readonly [
                ZodUnknown,
                PhraseLiteralSlot<"to be one of">,
                ZodArray<ZodUnknown>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to have arity",
                ZodInt,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                expectedArity: number,
            ) => { actual: number; expected: number; message: string } | undefined,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to have arity">,
                ZodInt,
            ],
        >,
        AssertionFunctionSync<
            readonly [ZodCustom<Error, Error>, "to have message", ZodString],
            (
                subject: Error,
                expectedMessage: string,
            ) => { actual: string; expected: string; message: string } | undefined,
            readonly [
                ZodCustom<Error, Error>,
                PhraseLiteralSlot<"to have message">,
                ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Error, Error>,
                "to have message matching",
                ZodCustom<RegExp, RegExp>,
            ],
            (subject: Error, pattern: RegExp) => { message: string } | undefined,
            readonly [
                ZodCustom<Error, Error>,
                PhraseLiteralSlot<"to have message matching">,
                ZodCustom<RegExp, RegExp>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                readonly [
                    "to be",
                    "to equal",
                    "equals",
                    "is",
                    "is equal to",
                    "to strictly equal",
                    "is strictly equal to",
                ],
                ZodUnknown,
            ],
            (
                subject: unknown,
                value: unknown,
            ) => { actual: unknown; expected: unknown; message: string } | undefined,
            readonly [
                ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to be",
                        "to equal",
                        "equals",
                        "is",
                        "is equal to",
                        "to strictly equal",
                        "is strictly equal to",
                    ],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodRecord<
                    ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                    ZodUnknown,
                >,
                readonly ["to deep equal", "to deeply equal"],
                ZodUnknown,
            ],
            (
                _: Record<string | number | symbol, unknown>,
                expected: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodRecord<
                    ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                    ZodUnknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodArray<ZodUnknown>,
                        ZodTuple<[ZodUnknown], ZodUnknown>,
                        ZodObject<{ length: ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to deep equal", "to deeply equal"],
                ZodUnknown,
            ],
            (
                _:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
                expected: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodUnion<
                    readonly [
                        ZodArray<ZodUnknown>,
                        ZodTuple<[ZodUnknown], ZodUnknown>,
                        ZodObject<{ length: ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                readonly ["to deep equal", "to deeply equal"],
                ZodUnknown,
            ],
            (
                _: Map<unknown, unknown>,
                expected: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                readonly ["to deep equal", "to deeply equal"],
                ZodUnknown,
            ],
            (
                _: Set<unknown>,
                expected: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to throw",
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => { message: string } | undefined,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to throw">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw a", "to throw an"],
                ZodCustom<Constructor, Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: Constructor,
            ) =>
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: string; expected: string; message: string }
                | undefined,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>,
                ZodCustom<Constructor, Constructor>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw", "to throw error satisfying"],
                ZodUnknown,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: unknown,
            ) =>
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                    subject: {} | null;
                },
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly ["to throw", "to throw error satisfying"],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw a", "to throw an"],
                ZodCustom<Constructor, Constructor>,
                "satisfying",
                ZodUnknown,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: Constructor,
                param: unknown,
            ) =>
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                    subject: {} | null;
                },
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>,
                ZodCustom<Constructor, Constructor>,
                PhraseLiteralSlot<"satisfying">,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodString,
                readonly ["includes", "contains", "to include", "to contain"],
                ZodString,
            ],
            (subject: string, expected: string) => { message: string } | undefined,
            readonly [
                ZodString,
                PhraseLiteralChoiceSlot<
                    readonly ["includes", "contains", "to include", "to contain"],
                >,
                ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [ZodString, "to match", ZodCustom<RegExp, RegExp>],
            (subject: string, regex: RegExp) => boolean,
            readonly [
                ZodString,
                PhraseLiteralSlot<"to match">,
                ZodCustom<RegExp, RegExp>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNonOptional<ZodObject<{}, $loose>>,
                readonly ["to satisfy", "to be like", "satisfies"],
                ZodUnknown,
            ],
            (
                _subject: { [key: string]: unknown },
                shape: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodNonOptional<ZodObject<{}, $loose>>,
                PhraseLiteralChoiceSlot<
                    readonly ["to satisfy", "to be like", "satisfies"],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodArray<ZodUnknown>,
                        ZodTuple<[ZodUnknown], ZodUnknown>,
                        ZodObject<{ length: ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to satisfy", "to be like"],
                ZodUnknown,
            ],
            (
                _subject:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
                shape: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodUnion<
                    readonly [
                        ZodArray<ZodUnknown>,
                        ZodTuple<[ZodUnknown], ZodUnknown>,
                        ZodObject<{ length: ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
                ZodUnknown,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to have a null prototype", "to be a dictionary"]],
            ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>,
            never,
        >,
        AssertionFunctionSync<
            readonly ["to be frozen"],
            (
                subject: unknown,
            ) => { actual: boolean; expected: boolean; message: string } | undefined,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                "to be an enumerable property of",
                ZodNonOptional<ZodUnknown>,
            ],
            (
                subject: string | number | symbol,
                obj: unknown,
            ) => { actual: boolean; expected: boolean; message: string } | undefined,
            readonly [
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
                PhraseLiteralSlot<"to be an enumerable property of">,
                ZodNonOptional<ZodUnknown>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodNonOptional<ZodUnknown>,
                "to have enumerable property",
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ],
            (
                _subject: unknown,
                key: string | number | symbol,
            ) => ZodCustom<unknown, unknown>,
            readonly [
                ZodNonOptional<ZodUnknown>,
                PhraseLiteralSlot<"to have enumerable property">,
                ZodUnion<readonly [ZodString, ZodNumber, ZodSymbol]>,
            ],
        >,
        AssertionStandardSchemaSync<readonly ["to be sealed"], ZodUnknown, never>,
        AssertionStandardSchemaSync<
            readonly ["to be extensible"],
            ZodUnknown,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "to be after",
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
            (
                subject: string | number | Date,
                other: string | number | Date,
            ) =>
                | { message: string; schema?: undefined; subject?: undefined }
                | { message?: undefined; schema: ZodDate; subject: Date },
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"to be after">,
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "to be before",
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
            (
                subject: string | number | Date,
                other: string | number | Date,
            ) =>
                | { message: string; schema?: undefined; subject?: undefined }
                | { message?: undefined; schema: ZodDate; subject: Date },
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"to be before">,
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "to be between",
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "and",
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
            (
                subject: string | number | Date,
                start: string | number | Date,
                end: string | number | Date,
            ) =>
                | { message: string; schema?: undefined; subject?: undefined }
                | { message?: undefined; schema: ZodDate; subject: Date },
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"to be between">,
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"and">,
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "to equal",
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "within",
                ZodCustomStringFormat<"duration">,
            ],
            (
                subject: string | number | Date,
                other: string | number | Date,
                toleranceStr: string,
            ) =>
                | { actual?: undefined; expected?: undefined; message: string }
                | {
                    actual: { difference: number };
                    expected: { maxDifference: number };
                    message: string;
                }
                | undefined,
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"to equal">,
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"within">,
                ZodCustomStringFormat<"duration">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                "to be the same date as",
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
            (
                subject: string | number | Date,
                other: string | number | Date,
            ) =>
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: string; expected: string; message: string }
                | undefined,
            readonly [
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
                PhraseLiteralSlot<"to be the same date as">,
                ZodUnion<
                    readonly [
                        ZodDate,
                        ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                        ZodNumber,
                    ],
                >,
            ],
        >,
        AssertionStandardSchemaSync<
            readonly [readonly ["to be a valid date", "to be date-like"]],
            ZodUnion<
                readonly [
                    ZodDate,
                    ZodUnion<readonly [ZodISODateTime, ZodISODate]>,
                    ZodNumber,
                ],
            >,
            never,
        >,
        AssertionFunctionSync<
            readonly ["to be a weekday"],
            (subject: unknown) => { message: string } | undefined,
            never,
        >,
        AssertionFunctionSync<
            readonly ["to be a weekend"],
            (subject: unknown) => { message: string } | undefined,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnknown,
                readonly [
                    "to match snapshot",
                    "to match the snapshot",
                    "to equal snapshot",
                    "to equal the snapshot",
                ],
                ZodNonOptional<ZodUnknown>,
            ],
            (actual: unknown, context: unknown) => void | AssertionFailure,
            readonly [
                ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to match snapshot",
                        "to match the snapshot",
                        "to equal snapshot",
                        "to equal the snapshot",
                    ],
                >,
                ZodNonOptional<ZodUnknown>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodUnknown,
                readonly [
                    "to match snapshot",
                    "to match the snapshot",
                    "to equal snapshot",
                    "to equal the snapshot",
                ],
                ZodNonOptional<ZodUnknown>,
                "with options",
                ZodObject<
                    { hint: ZodOptional<ZodString>; serializer: ZodOptional<ZodAny> },
                    $strip,
                >,
            ],
            (
                actual: unknown,
                context: unknown,
                options: { hint?: string; serializer?: any },
            ) => void | AssertionFailure,
            readonly [
                ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to match snapshot",
                        "to match the snapshot",
                        "to equal snapshot",
                        "to equal the snapshot",
                    ],
                >,
                ZodNonOptional<ZodUnknown>,
                PhraseLiteralSlot<"with options">,
                ZodObject<
                    { hint: ZodOptional<ZodString>; serializer: ZodOptional<ZodAny> },
                    $strip,
                >,
            ],
        >,
    ],
    readonly [
        AssertionFunctionAsync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to resolve", "to fulfill"],
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to resolve", "to fulfill"],
            ],
            (
                subject: PromiseLike<unknown>,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject", "to be rejected"],
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject", "to be rejected"],
            ],
            (
                subject: PromiseLike<unknown>,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly [
                    "to reject with a",
                    "to reject with an",
                    "to be rejected with a",
                    "to be rejected with an",
                ],
                ZodCustom<Constructor, Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: Constructor,
            ) => Promise<
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: string; expected: string; message: string }
                | undefined,
            >,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to reject with a",
                        "to reject with an",
                        "to be rejected with a",
                        "to be rejected with an",
                    ],
                >,
                ZodCustom<Constructor, Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly [
                    "to reject with a",
                    "to reject with an",
                    "to be rejected with a",
                    "to be rejected with an",
                ],
                ZodCustom<Constructor, Constructor>,
            ],
            (
                subject: PromiseLike<unknown>,
                ctor: Constructor,
            ) => Promise<
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: string; expected: string; message: string }
                | undefined,
            >,
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to reject with a",
                        "to reject with an",
                        "to be rejected with a",
                        "to be rejected with an",
                    ],
                >,
                ZodCustom<Constructor, Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly [
                    "to reject with error satisfying",
                    "to be rejected with error satisfying",
                ],
                ZodUnknown,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                    subject: {} | null;
                },
            >,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to reject with error satisfying",
                        "to be rejected with error satisfying",
                    ],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly [
                    "to reject with error satisfying",
                    "to be rejected with error satisfying",
                ],
                ZodUnknown,
            ],
            (
                subject: PromiseLike<unknown>,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                    subject: {} | null;
                },
            >,
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to reject with error satisfying",
                        "to be rejected with error satisfying",
                    ],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                ZodUnknown,
            ],
            (
                promise: PromiseLike<unknown>,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                    subject: unknown;
                },
            >,
            readonly [
                ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                ZodUnknown,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                ZodUnknown,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                    subject: unknown;
                },
            >,
            readonly [
                ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                ZodUnknown,
            ],
        >,
    ],
>

Function to add more assertions to this expect(), returning a new expect() and expectAsync() pair with the combined assertions.

Function expect

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters

Returns void

Parameters