Function expect

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

expect(...args: any[] | readonly any[]): void
Parameters
- ...args: any[] | readonly any[]
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 | any[] | "to have size" | "not to have size")[]
        | (number | any[] | "to have size" | "not to have size")[],
): void
Parameters
- ...args:
  | readonly (number | any[] | "to have size" | "not to have size")[]
  | (number | any[] | "to have size" | "not to have size")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (number | any[] | "to have length" | "not to have length")[]
        | (number | any[] | "to have length" | "not to have length")[],
): void
Parameters
- ...args:
  | readonly (number | any[] | "to have length" | "not to have length")[]
  | (number | any[] | "to have length" | "not to have length")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (any[] | "to be non-empty" | "not to be non-empty")[]
        | (any[] | "to be non-empty" | "not to be non-empty")[],
): void
Parameters
- ...args:
  | readonly (any[] | "to be non-empty" | "not to be non-empty")[]
  | (any[] | "to be non-empty" | "not to be non-empty")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | [string, ...string[]]
            | "to have keys"
            | "to have properties"
            | "to have props"
            | { [key: string]: unknown }
            | "not to have keys"
            | "not to have properties"
            | "not to have props"
        )[]
        | (
            | [string, ...string[]]
            | "to have keys"
            | "to have properties"
            | "to have props"
            | { [key: string]: unknown }
            | "not to have keys"
            | "not to have properties"
            | "not to have props"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | [string, ...string[]]
          | "to have keys"
          | "to have properties"
          | "to have props"
          | { [key: string]: unknown }
          | "not to have keys"
          | "not to have properties"
          | "not to have props"
      )[]
      | (
          | [string, ...string[]]
          | "to have keys"
          | "to have properties"
          | "to have props"
          | { [key: string]: unknown }
          | "not to have keys"
          | "not to have properties"
          | "not to have props"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | number
            | "to have size"
            | { [key: string]: unknown }
            | "not to have size"
        )[]
        | (
            | number
            | "to have size"
            | { [key: string]: unknown }
            | "not to have size"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | number
          | "to have size"
          | { [key: string]: unknown }
          | "not to have size"
      )[]
      | (
          | number
          | "to have size"
          | { [key: string]: unknown }
          | "not to have size"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(...args: unknown[] | readonly unknown[]): void
Parameters
- ...args: unknown[] | readonly unknown[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (any[] | "to be empty" | "not to be empty")[]
        | (any[] | "to be empty" | "not to be empty")[],
): void
Parameters
- ...args:
  | readonly (any[] | "to be empty" | "not to be empty")[]
  | (any[] | "to be empty" | "not to be empty")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly ("to be empty" | Record<any, unknown> | "not to be empty")[]
        | ("to be empty" | Record<any, unknown> | "not to be empty")[],
): void
Parameters
- ...args:
  | readonly ("to be empty" | Record<any, unknown> | "not to be empty")[]
  | ("to be empty" | Record<any, unknown> | "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:
        | readonly (string | number | symbol | { [key: string]: unknown })[]
        | (string | number | symbol | { [key: string]: unknown })[],
): void
Parameters
- ...args:
  | readonly (string | number | symbol | { [key: string]: unknown })[]
  | (string | number | symbol | { [key: string]: unknown })[]
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" | "not to be less than")[]
        | readonly (number | "to be less than" | "not to be less than")[],
): void
Parameters
- ...args:
  | (number | "to be less than" | "not to be less than")[]
  | readonly (number | "to be less than" | "not to be less than")[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | number
            | "to be greater than or equal to"
            | "to be at least"
            | "not to be greater than or equal to"
            | "not to be at least"
        )[]
        | readonly (
            | number
            | "to be greater than or equal to"
            | "to be at least"
            | "not to be greater than or equal to"
            | "not to be at least"
        )[],
): void
Parameters
- ...args:
      | (
          | number
          | "to be greater than or equal to"
          | "to be at least"
          | "not to be greater than or equal to"
          | "not to be at least"
      )[]
      | readonly (
          | number
          | "to be greater than or equal to"
          | "to be at least"
          | "not to be greater than or equal to"
          | "not to be at least"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | number
            | "to be less than or equal to"
            | "to be at most"
            | "not to be less than or equal to"
            | "not to be at most"
        )[]
        | readonly (
            | number
            | "to be less than or equal to"
            | "to be at most"
            | "not to be less than or equal to"
            | "not to be at most"
        )[],
): void
Parameters
- ...args:
      | (
          | number
          | "to be less than or equal to"
          | "to be at most"
          | "not to be less than or equal to"
          | "not to be at most"
      )[]
      | readonly (
          | number
          | "to be less than or equal to"
          | "to be at most"
          | "not to be less than or equal to"
          | "not to be at most"
      )[]
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:
        | (undefined | number | "to be close to" | "not to be close to")[]
        | readonly (undefined | number | "to be close to" | "not to be close to")[],
): void
Parameters
- ...args:
  | (undefined | number | "to be close to" | "not to be close to")[]
  | readonly (undefined | number | "to be close to" | "not to be close to")[]
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 (
            | "to deep equal"
            | "to deeply equal"
            | { [key: string]: unknown }
            | { [key: string]: unknown }
            | "not to deep equal"
            | "not to deeply equal"
        )[]
        | (
            | "to deep equal"
            | "to deeply equal"
            | { [key: string]: unknown }
            | { [key: string]: unknown }
            | "not to deep equal"
            | "not to deeply equal"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | "to deep equal"
          | "to deeply equal"
          | { [key: string]: unknown }
          | { [key: string]: unknown }
          | "not to deep equal"
          | "not to deeply equal"
      )[]
      | (
          | "to deep equal"
          | "to deeply equal"
          | { [key: string]: unknown }
          | { [key: string]: unknown }
          | "not to deep equal"
          | "not to deeply equal"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | unknown[]
            | [unknown, ...unknown[]]
            | "to deep equal"
            | "to deeply equal"
            | { length: number; [key: string]: unknown }
            | "not to deep equal"
            | "not to deeply equal"
        )[]
        | readonly (
            | unknown[]
            | [unknown, ...unknown[]]
            | "to deep equal"
            | "to deeply equal"
            | { length: number; [key: string]: unknown }
            | "not to deep equal"
            | "not to deeply equal"
        )[],
): void
Parameters
- ...args:
      | (
          | unknown[]
          | [unknown, ...unknown[]]
          | "to deep equal"
          | "to deeply equal"
          | { length: number; [key: string]: unknown }
          | "not to deep equal"
          | "not to deeply equal"
      )[]
      | readonly (
          | unknown[]
          | [unknown, ...unknown[]]
          | "to deep equal"
          | "to deeply equal"
          | { length: number; [key: string]: unknown }
          | "not to deep equal"
          | "not to deeply equal"
      )[]
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 (
            | types.Constructor
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to throw a"
            | "to thrown an"
            | "not to throw a"
            | "not to thrown an"
        )[]
        | (
            | types.Constructor
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | "to throw a"
            | "to thrown an"
            | "not to throw a"
            | "not to thrown an"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | types.Constructor
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to throw a"
          | "to thrown an"
          | "not to throw a"
          | "not to thrown an"
      )[]
      | (
          | types.Constructor
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | "to throw a"
          | "to thrown an"
          | "not to throw a"
          | "not to thrown an"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | string
            | RegExp
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | { [key: string]: unknown }
        )[]
        | (
            | string
            | RegExp
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | { [key: string]: unknown }
        )[],
): void
Parameters
- ...args:
      | readonly (
          | string
          | RegExp
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | { [key: string]: unknown }
      )[]
      | (
          | string
          | RegExp
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | { [key: string]: unknown }
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | readonly (
            | string
            | RegExp
            | types.Constructor
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | { [key: string]: unknown }
        )[]
        | (
            | string
            | RegExp
            | types.Constructor
            | ((...args: unknown[] | readonly unknown[]) => unknown)
            | { [key: string]: unknown }
        )[],
): void
Parameters
- ...args:
      | readonly (
          | string
          | RegExp
          | types.Constructor
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | { [key: string]: unknown }
      )[]
      | (
          | string
          | RegExp
          | types.Constructor
          | ((...args: unknown[] | readonly unknown[]) => unknown)
          | { [key: string]: unknown }
      )[]
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:
        | readonly (
            | "to satisfy"
            | "to be like"
            | { [key: string]: unknown }
            | { [key: string]: unknown }
            | "not to satisfy"
            | "not to be like"
        )[]
        | (
            | "to satisfy"
            | "to be like"
            | { [key: string]: unknown }
            | { [key: string]: unknown }
            | "not to satisfy"
            | "not to be like"
        )[],
): void
Parameters
- ...args:
      | readonly (
          | "to satisfy"
          | "to be like"
          | { [key: string]: unknown }
          | { [key: string]: unknown }
          | "not to satisfy"
          | "not to be like"
      )[]
      | (
          | "to satisfy"
          | "to be like"
          | { [key: string]: unknown }
          | { [key: string]: unknown }
          | "not to satisfy"
          | "not to be like"
      )[]
Returns void
- Defined in src/bootstrap.ts:43
expect(
    ...args:
        | (
            | unknown[]
            | [unknown, ...unknown[]]
            | { length: number; [key: string]: unknown }
            | "to satisfy"
            | "to be like"
            | "not to satisfy"
            | "not to be like"
        )[]
        | readonly (
            | unknown[]
            | [unknown, ...unknown[]]
            | { length: number; [key: string]: unknown }
            | "to satisfy"
            | "to be like"
            | "not to satisfy"
            | "not to be like"
        )[],
): void
Parameters
- ...args:
      | (
          | unknown[]
          | [unknown, ...unknown[]]
          | { length: number; [key: string]: unknown }
          | "to satisfy"
          | "to be like"
          | "not to satisfy"
          | "not to be like"
      )[]
      | readonly (
          | unknown[]
          | [unknown, ...unknown[]]
          | { length: number; [key: string]: unknown }
          | "to satisfy"
          | "to be like"
          | "not to satisfy"
          | "not to be like"
      )[]
Returns void
- Defined in src/bootstrap.ts:43

Index

Properties

assertions use createAssertion createAsyncAssertion fail

Properties

assertions

assertions: readonly [
    AssertionFunctionSync<
        readonly [
            z.ZodMap<z.ZodAny, z.ZodAny>,
            readonly ["to contain", "to include"],
            z.ZodAny,
        ],
        (subject: Map<any, any>, key: any) => boolean,
        readonly [
            z.ZodMap<z.ZodAny, z.ZodAny>,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            z.ZodAny,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            "to have size",
            z.ZodNumber,
        ],
        (subject: Map<unknown, unknown>, expectedSize: number) => boolean,
        readonly [
            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralSlot<"to have size">,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            "to be empty",
        ],
        (subject: Map<unknown, unknown>) => boolean,
        readonly [
            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodSet<z.ZodAny>,
            readonly ["to contain", "to include"],
            z.ZodAny,
        ],
        (subject: Set<any>, value: any) => boolean,
        readonly [
            z.ZodSet<z.ZodAny>,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            z.ZodAny,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<Set<unknown>, Set<unknown>>,
            "to have size",
            z.ZodNumber,
        ],
        (subject: Set<unknown>, expectedSize: number) => boolean,
        readonly [
            z.ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to have size">,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
        (subject: Set<unknown>) => boolean,
        readonly [
            z.ZodCustom<Set<unknown>, Set<unknown>>,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
            readonly ["to contain", "to include"],
            z.ZodAny,
        ],
        (subject: WeakMap<WeakKey, unknown>, key: any) => boolean,
        readonly [
            z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            z.ZodAny,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
            readonly ["to contain", "to include"],
            z.ZodAny,
        ],
        (subject: WeakSet<WeakKey>, value: any) => boolean,
        readonly [
            z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            z.ZodAny,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodArray<z.ZodAny>,
            readonly ["to contain", "to include"],
            z.ZodAny,
        ],
        (subject: any[], value: any) => boolean,
        readonly [
            z.ZodArray<z.ZodAny>,
            PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
            z.ZodAny,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber],
        (subject: any[], expectedSize: number) => boolean,
        readonly [
            z.ZodArray<z.ZodAny>,
            PhraseLiteralSlot<"to have size">,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber],
        (subject: any[], expectedLength: number) => boolean,
        readonly [
            z.ZodArray<z.ZodAny>,
            PhraseLiteralSlot<"to have length">,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodArray<z.ZodAny>, "to be non-empty"],
        (
            subject: any[],
        ) => undefined | { actual: number; expected: string; message: string },
        readonly [z.ZodArray<z.ZodAny>, PhraseLiteralSlot<"to be non-empty">],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodObject<{}, $loose>,
            readonly ["to have keys", "to have properties", "to have props"],
            z.ZodTuple<[z.ZodString], z.ZodString>,
        ],
        (
            _: { [key: string]: unknown },
            keys: [string, ...string[]],
        ) => z.ZodObject<{ [k: string]: z.ZodNonOptional<z.ZodUnknown> }, $loose>,
        readonly [
            z.ZodObject<{}, $loose>,
            PhraseLiteralChoiceSlot<
                readonly ["to have keys", "to have properties", "to have props"],
            >,
            z.ZodTuple<[z.ZodString], z.ZodString>,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodObject<{}, $loose>, "to have size", z.ZodNumber],
        (
            subject: { [key: string]: unknown },
            expectedSize: number,
        ) => undefined | { actual: number; expected: number; message: string },
        readonly [
            z.ZodObject<{}, $loose>,
            PhraseLiteralSlot<"to have size">,
            z.ZodNumber,
        ],
    >,
    AssertionSchemaSync<
        readonly ["to be a string"],
        AssertionImplSchemaSync<readonly ["to be a string"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be a number", "to be finite"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be a number", "to be finite"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be infinite"],
        AssertionImplSchemaSync<readonly ["to be infinite"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be Infinity"],
        AssertionImplSchemaSync<readonly ["to be Infinity"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be -Infinity"],
        AssertionImplSchemaSync<readonly ["to be -Infinity"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [
            readonly ["to be a boolean", "to be boolean", "to be a bool"],
        ],
        AssertionImplSchemaSync<
            readonly [
                readonly ["to be a boolean", "to be boolean", "to be a bool"],
            ],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be positive", "to be a positive number"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be positive", "to be a positive number"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [
            readonly ["to be a positive integer", "to be a positive int"],
        ],
        AssertionImplSchemaSync<
            readonly [
                readonly ["to be a positive integer", "to be a positive int"],
            ],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be negative", "to be a negative number"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be negative", "to be a negative number"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [
            readonly ["to be a negative integer", "to be a negative int"],
        ],
        AssertionImplSchemaSync<
            readonly [
                readonly ["to be a negative integer", "to be a negative int"],
            ],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be true"],
        AssertionImplSchemaSync<readonly ["to be true"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be false"],
        AssertionImplSchemaSync<readonly ["to be false"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be a bigint", "to be a BigInt"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be a bigint", "to be a BigInt"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be a symbol", "to be a Symbol"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be a symbol", "to be a Symbol"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be a function"],
        AssertionImplSchemaSync<readonly ["to be a function"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be an async function"],
        AssertionImplSchemaSync<readonly ["to be an async function"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be NaN"],
        AssertionImplSchemaSync<readonly ["to be NaN"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [
            readonly [
                "to be an integer",
                "to be a safe integer",
                "to be an int",
                "to be a safe int",
            ],
        ],
        AssertionImplSchemaSync<
            readonly [
                readonly [
                    "to be an integer",
                    "to be a safe integer",
                    "to be an int",
                    "to be a safe int",
                ],
            ],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be null"],
        AssertionImplSchemaSync<readonly ["to be null"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be undefined"],
        AssertionImplSchemaSync<readonly ["to be undefined"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be an array", "to be array"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be an array", "to be array"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be a date", "to be a Date"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be a date", "to be a Date"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be a class", "to be a constructor"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be a class", "to be a constructor"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be a primitive"],
        AssertionImplSchemaSync<readonly ["to be a primitive"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [
            readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
        ],
        AssertionImplSchemaSync<
            readonly [
                readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
            ],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be truthy", "to exist", "to be ok"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be truthy", "to exist", "to be ok"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be falsy"],
        AssertionImplSchemaSync<readonly ["to be falsy"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be an object"],
        AssertionImplSchemaSync<readonly ["to be an object"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [readonly ["to be a record", "to be a plain object"]],
        AssertionImplSchemaSync<
            readonly [readonly ["to be a record", "to be a plain object"]],
        >,
        never,
    >,
    AssertionSchemaSync<
        readonly [z.ZodArray<z.ZodAny>, "to be empty"],
        AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodAny>, "to be empty"]>,
        readonly [z.ZodArray<z.ZodAny>, PhraseLiteralSlot<"to be empty">],
    >,
    AssertionSchemaSync<
        readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"],
        AssertionImplSchemaSync<
            readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"],
        >,
        readonly [
            z.ZodRecord<z.ZodAny, z.ZodUnknown>,
            PhraseLiteralSlot<"to be empty">,
        ],
    >,
    AssertionSchemaSync<
        readonly ["to be an Error"],
        AssertionImplSchemaSync<readonly ["to be an Error"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly [z.ZodString, "to be empty"],
        AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>,
        readonly [z.ZodString, PhraseLiteralSlot<"to be empty">],
    >,
    AssertionSchemaSync<
        readonly [z.ZodString, "to be non-empty"],
        AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>,
        readonly [z.ZodString, PhraseLiteralSlot<"to be non-empty">],
    >,
    AssertionSchemaSync<
        readonly ["to be defined"],
        AssertionImplSchemaSync<readonly ["to be defined"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be a Set"],
        AssertionImplSchemaSync<readonly ["to be a Set"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be a WeakMap"],
        AssertionImplSchemaSync<readonly ["to be a WeakMap"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be a WeakSet"],
        AssertionImplSchemaSync<readonly ["to be a WeakSet"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to have a null prototype"],
        AssertionImplSchemaSync<readonly ["to have a null prototype"]>,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
            "to be an enumerable property of",
            z.ZodObject<{}, $loose>,
        ],
        (
            subject: string | number | symbol,
            obj: { [key: string]: unknown },
        ) => boolean,
        readonly [
            z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
            PhraseLiteralSlot<"to be an enumerable property of">,
            z.ZodObject<{}, $loose>,
        ],
    >,
    AssertionSchemaSync<
        readonly ["to be sealed"],
        AssertionImplSchemaSync<readonly ["to be sealed"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be frozen"],
        AssertionImplSchemaSync<readonly ["to be frozen"]>,
        never,
    >,
    AssertionSchemaSync<
        readonly ["to be extensible"],
        AssertionImplSchemaSync<readonly ["to be extensible"]>,
        never,
    >,
    AssertionFunctionSync<
        readonly [
            readonly ["to be an instance of", "to be a"],
            z.ZodCustom<types.Constructor, types.Constructor>,
        ],
        (_: unknown, ctor: types.Constructor) => z.ZodCustom<any, any>,
        readonly [
            z.ZodUnknown,
            PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>,
            z.ZodCustom<types.Constructor, types.Constructor>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodAny,
            readonly ["to be a", "to be an"],
            z.ZodEnum<{ [key: string]: string }>,
        ],
        (
            _: any,
            type: string,
        ) =>
            | z.ZodString
            | z.ZodNumber
            | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>
            | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>
            | z.ZodArray<z.ZodAny>
            | z.ZodBoolean
            | z.ZodBigInt
            | z.ZodSymbol
            | z.ZodNull
            | z.ZodUndefined
            | z.ZodDate
            | z.ZodCustom<RegExp, RegExp>
            | z.ZodCustom<Error, Error>
            | z.ZodFunction<$ZodFunctionArgs, $ZodFunctionOut>
            | z.ZodObject<{}, $loose>
            | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>
            | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>,
        readonly [
            z.ZodAny,
            PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>,
            z.ZodEnum<{ [key: string]: string }>,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodNumber, "to be greater than", z.ZodNumber],
        (_: number, other: number) => z.ZodNumber,
        readonly [
            z.ZodNumber,
            PhraseLiteralSlot<"to be greater than">,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodNumber, "to be less than", z.ZodNumber],
        (_: number, other: number) => z.ZodNumber,
        readonly [z.ZodNumber, PhraseLiteralSlot<"to be less than">, z.ZodNumber],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodNumber,
            readonly ["to be greater than or equal to", "to be at least"],
            z.ZodNumber,
        ],
        (_: number, other: number) => z.ZodNumber,
        readonly [
            z.ZodNumber,
            PhraseLiteralChoiceSlot<
                readonly ["to be greater than or equal to", "to be at least"],
            >,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodNumber,
            readonly ["to be less than or equal to", "to be at most"],
            z.ZodNumber,
        ],
        (_: number, other: number) => z.ZodNumber,
        readonly [
            z.ZodNumber,
            PhraseLiteralChoiceSlot<
                readonly ["to be less than or equal to", "to be at most"],
            >,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodNumber,
            readonly ["to be within", "to be between"],
            z.ZodNumber,
            z.ZodNumber,
        ],
        (
            subject: number,
            min: number,
            max: number,
        ) => undefined | { actual: number; expected: string; message: string },
        readonly [
            z.ZodNumber,
            PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>,
            z.ZodNumber,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodNumber,
            "to be close to",
            z.ZodNumber,
            z.ZodOptional<z.ZodNumber>,
        ],
        (
            subject: number,
            expected: number,
            tolerance?: undefined | number,
        ) => undefined | { actual: number; expected: number; message: string },
        readonly [
            z.ZodNumber,
            PhraseLiteralSlot<"to be close to">,
            z.ZodNumber,
            z.ZodOptional<z.ZodNumber>,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodString, "to be greater than", z.ZodString],
        (
            subject: string,
            other: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [
            z.ZodString,
            PhraseLiteralSlot<"to be greater than">,
            z.ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodString, "to be less than", z.ZodString],
        (
            subject: string,
            other: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [z.ZodString, PhraseLiteralSlot<"to be less than">, z.ZodString],
    >,
    AssertionFunctionSync<
        readonly [z.ZodString, "to be greater than or equal to", z.ZodString],
        (
            subject: string,
            other: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [
            z.ZodString,
            PhraseLiteralSlot<"to be greater than or equal to">,
            z.ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodString, "to be less than or equal to", z.ZodString],
        (
            subject: string,
            other: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [
            z.ZodString,
            PhraseLiteralSlot<"to be less than or equal to">,
            z.ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodString,
            readonly ["to begin with", "to start with"],
            z.ZodString,
        ],
        (
            subject: string,
            prefix: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [
            z.ZodString,
            PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>,
            z.ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodString, "to end with", z.ZodString],
        (
            subject: string,
            suffix: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [z.ZodString, PhraseLiteralSlot<"to end with">, z.ZodString],
    >,
    AssertionFunctionSync<
        readonly [z.ZodAny, "to be one of", z.ZodArray<z.ZodAny>],
        (
            subject: any,
            values: any[],
        ) => undefined | { actual: unknown; expected: string; message: string },
        readonly [
            z.ZodAny,
            PhraseLiteralSlot<"to be one of">,
            z.ZodArray<z.ZodAny>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            "to have arity",
            z.ZodNumber,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            expectedArity: number,
        ) => undefined | { actual: number; expected: number; message: string },
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralSlot<"to have arity">,
            z.ZodNumber,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString],
        (
            subject: Error,
            expectedMessage: string,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [
            z.ZodCustom<Error, Error>,
            PhraseLiteralSlot<"to have message">,
            z.ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<Error, Error>,
            "to have message matching",
            z.ZodCustom<RegExp, RegExp>,
        ],
        (
            subject: Error,
            pattern: RegExp,
        ) => undefined | { actual: string; expected: string; message: string },
        readonly [
            z.ZodCustom<Error, Error>,
            PhraseLiteralSlot<"to have message matching">,
            z.ZodCustom<RegExp, RegExp>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            readonly [
                "to be",
                "to equal",
                "equals",
                "is",
                "is equal to",
                "to strictly equal",
            ],
            z.ZodUnknown,
        ],
        (
            subject: unknown,
            value: unknown,
        ) => undefined | { actual: unknown; expected: unknown; message: string },
        readonly [
            z.ZodUnknown,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to be",
                    "to equal",
                    "equals",
                    "is",
                    "is equal to",
                    "to strictly equal",
                ],
            >,
            z.ZodUnknown,
        ],
    >,
    AssertionSchemaSync<
        readonly [
            z.ZodObject<{}, $loose>,
            readonly ["to deep equal", "to deeply equal"],
            z.ZodObject<{}, $loose>,
        ],
        AssertionImplSchemaSync<
            readonly [
                z.ZodObject<{}, $loose>,
                readonly ["to deep equal", "to deeply equal"],
                z.ZodObject<{}, $loose>,
            ],
        >,
        readonly [
            z.ZodObject<{}, $loose>,
            PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
            z.ZodObject<{}, $loose>,
        ],
    >,
    AssertionSchemaSync<
        readonly [
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
            readonly ["to deep equal", "to deeply equal"],
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
        ],
        AssertionImplSchemaSync<
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to deep equal", "to deeply equal"],
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
        >,
        readonly [
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
            PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            "to throw",
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
        ) => undefined | { actual: unknown; message: string },
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralSlot<"to throw">,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to throw a", "to thrown an"],
            z.ZodCustom<types.Constructor, types.Constructor>,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ctor: types.Constructor,
        ) =>
            | undefined
            | false
            | { actual: {}; expected: types.Constructor; message: string },
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>,
            z.ZodCustom<types.Constructor, types.Constructor>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to throw"],
            z.ZodUnion<
                readonly [
                    z.ZodString,
                    z.ZodCustom<RegExp, RegExp>,
                    z.ZodObject<{}, $loose>,
                ],
            >,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            param: string | RegExp | { [key: string]: unknown },
        ) => boolean,
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralChoiceSlot<readonly ["to throw"]>,
            z.ZodUnion<
                readonly [
                    z.ZodString,
                    z.ZodCustom<RegExp, RegExp>,
                    z.ZodObject<{}, $loose>,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to throw a", "to thrown an"],
            z.ZodCustom<types.Constructor, types.Constructor>,
            "satisfying",
            z.ZodUnion<
                readonly [
                    z.ZodString,
                    z.ZodCustom<RegExp, RegExp>,
                    z.ZodObject<{}, $loose>,
                ],
            >,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ctor: types.Constructor,
            param: string | RegExp | { [key: string]: unknown },
        ) =>
            | undefined
            | { actual: string; expected: string; message: string }
            | {
                actual: unknown;
                expected: { [key: string]: unknown };
                message: string;
            },
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>,
            z.ZodCustom<types.Constructor, types.Constructor>,
            PhraseLiteralSlot<"satisfying">,
            z.ZodUnion<
                readonly [
                    z.ZodString,
                    z.ZodCustom<RegExp, RegExp>,
                    z.ZodObject<{}, $loose>,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodString,
            readonly ["includes", "contains", "to include", "to contain"],
            z.ZodString,
        ],
        (subject: string, expected: string) => boolean,
        readonly [
            z.ZodString,
            PhraseLiteralChoiceSlot<
                readonly ["includes", "contains", "to include", "to contain"],
            >,
            z.ZodString,
        ],
    >,
    AssertionFunctionSync<
        readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>],
        (subject: string, regex: RegExp) => boolean,
        readonly [
            z.ZodString,
            PhraseLiteralSlot<"to match">,
            z.ZodCustom<RegExp, RegExp>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodNonOptional<z.ZodObject<{}, $loose>>,
            readonly ["to satisfy", "to be like"],
            z.ZodObject<{}, $loose>,
        ],
        (
            subject: { [key: string]: unknown },
            shape: { [key: string]: unknown },
        ) => z.ZodType<{}, $loose, $ZodTypeInternals<{}, $loose>>,
        readonly [
            z.ZodNonOptional<z.ZodObject<{}, $loose>>,
            PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
            z.ZodObject<{}, $loose>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
            readonly ["to satisfy", "to be like"],
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
        ],
        (
            subject:
                | unknown[]
                | [unknown, ...unknown[]]
                | { length: number; [key: string]: unknown },
            shape:
                | unknown[]
                | [unknown, ...unknown[]]
                | { length: number; [key: string]: unknown },
        ) => z.ZodUnion<
            readonly [
                z.ZodArray<z.ZodUnknown>,
                z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                z.ZodObject<{ length: z.ZodNumber }, $loose>,
            ],
        >,
        readonly [
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
            PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
            z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            "to have arity",
            z.ZodNumber,
        ],
        (
            subject: (...args: unknown[] | readonly unknown[]) => unknown,
            expectedArity: number,
        ) => undefined | { actual: number; expected: number; message: string },
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            PhraseLiteralSlot<"to have arity">,
            z.ZodNumber,
        ],
    >,
]

Tuple of all assertions available in this expect().

use

use: UseFn<
    readonly [
        AssertionFunctionSync<
            readonly [
                z.ZodMap<z.ZodAny, z.ZodAny>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: Map<any, any>, key: any) => boolean,
            readonly [
                z.ZodMap<z.ZodAny, z.ZodAny>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to have size",
                z.ZodNumber,
            ],
            (subject: Map<unknown, unknown>, expectedSize: number) => boolean,
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to be empty",
            ],
            (subject: Map<unknown, unknown>) => boolean,
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodSet<z.ZodAny>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: Set<any>, value: any) => boolean,
            readonly [
                z.ZodSet<z.ZodAny>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Set<unknown>, Set<unknown>>,
                "to have size",
                z.ZodNumber,
            ],
            (subject: Set<unknown>, expectedSize: number) => boolean,
            readonly [
                z.ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
            (subject: Set<unknown>) => boolean,
            readonly [
                z.ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: WeakMap<WeakKey, unknown>, key: any) => boolean,
            readonly [
                z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: WeakSet<WeakKey>, value: any) => boolean,
            readonly [
                z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodArray<z.ZodAny>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: any[], value: any) => boolean,
            readonly [
                z.ZodArray<z.ZodAny>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber],
            (subject: any[], expectedSize: number) => boolean,
            readonly [
                z.ZodArray<z.ZodAny>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber],
            (subject: any[], expectedLength: number) => boolean,
            readonly [
                z.ZodArray<z.ZodAny>,
                PhraseLiteralSlot<"to have length">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodArray<z.ZodAny>, "to be non-empty"],
            (
                subject: any[],
            ) => undefined | { actual: number; expected: string; message: string },
            readonly [z.ZodArray<z.ZodAny>, PhraseLiteralSlot<"to be non-empty">],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodObject<{}, $loose>,
                readonly ["to have keys", "to have properties", "to have props"],
                z.ZodTuple<[z.ZodString], z.ZodString>,
            ],
            (
                _: { [key: string]: unknown },
                keys: [string, ...string[]],
            ) => z.ZodObject<{ [k: string]: z.ZodNonOptional<z.ZodUnknown> }, $loose>,
            readonly [
                z.ZodObject<{}, $loose>,
                PhraseLiteralChoiceSlot<
                    readonly ["to have keys", "to have properties", "to have props"],
                >,
                z.ZodTuple<[z.ZodString], z.ZodString>,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodObject<{}, $loose>, "to have size", z.ZodNumber],
            (
                subject: { [key: string]: unknown },
                expectedSize: number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodObject<{}, $loose>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionSchemaSync<
            readonly ["to be a string"],
            AssertionImplSchemaSync<readonly ["to be a string"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a number", "to be finite"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a number", "to be finite"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be infinite"],
            AssertionImplSchemaSync<readonly ["to be infinite"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be Infinity"],
            AssertionImplSchemaSync<readonly ["to be Infinity"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be -Infinity"],
            AssertionImplSchemaSync<readonly ["to be -Infinity"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a boolean", "to be boolean", "to be a bool"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a boolean", "to be boolean", "to be a bool"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be positive", "to be a positive number"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be positive", "to be a positive number"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a positive integer", "to be a positive int"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a positive integer", "to be a positive int"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be negative", "to be a negative number"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be negative", "to be a negative number"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a negative integer", "to be a negative int"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a negative integer", "to be a negative int"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be true"],
            AssertionImplSchemaSync<readonly ["to be true"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be false"],
            AssertionImplSchemaSync<readonly ["to be false"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a bigint", "to be a BigInt"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a bigint", "to be a BigInt"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a symbol", "to be a Symbol"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a symbol", "to be a Symbol"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a function"],
            AssertionImplSchemaSync<readonly ["to be a function"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be an async function"],
            AssertionImplSchemaSync<readonly ["to be an async function"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be NaN"],
            AssertionImplSchemaSync<readonly ["to be NaN"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly [
                    "to be an integer",
                    "to be a safe integer",
                    "to be an int",
                    "to be a safe int",
                ],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly [
                        "to be an integer",
                        "to be a safe integer",
                        "to be an int",
                        "to be a safe int",
                    ],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be null"],
            AssertionImplSchemaSync<readonly ["to be null"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be undefined"],
            AssertionImplSchemaSync<readonly ["to be undefined"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be an array", "to be array"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be an array", "to be array"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a date", "to be a Date"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a date", "to be a Date"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a class", "to be a constructor"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a class", "to be a constructor"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a primitive"],
            AssertionImplSchemaSync<readonly ["to be a primitive"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be truthy", "to exist", "to be ok"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be truthy", "to exist", "to be ok"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be falsy"],
            AssertionImplSchemaSync<readonly ["to be falsy"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be an object"],
            AssertionImplSchemaSync<readonly ["to be an object"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a record", "to be a plain object"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a record", "to be a plain object"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [z.ZodArray<z.ZodAny>, "to be empty"],
            AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodAny>, "to be empty"]>,
            readonly [z.ZodArray<z.ZodAny>, PhraseLiteralSlot<"to be empty">],
        >,
        AssertionSchemaSync<
            readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"],
            AssertionImplSchemaSync<
                readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"],
            >,
            readonly [
                z.ZodRecord<z.ZodAny, z.ZodUnknown>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionSchemaSync<
            readonly ["to be an Error"],
            AssertionImplSchemaSync<readonly ["to be an Error"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [z.ZodString, "to be empty"],
            AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>,
            readonly [z.ZodString, PhraseLiteralSlot<"to be empty">],
        >,
        AssertionSchemaSync<
            readonly [z.ZodString, "to be non-empty"],
            AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>,
            readonly [z.ZodString, PhraseLiteralSlot<"to be non-empty">],
        >,
        AssertionSchemaSync<
            readonly ["to be defined"],
            AssertionImplSchemaSync<readonly ["to be defined"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a Set"],
            AssertionImplSchemaSync<readonly ["to be a Set"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a WeakMap"],
            AssertionImplSchemaSync<readonly ["to be a WeakMap"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a WeakSet"],
            AssertionImplSchemaSync<readonly ["to be a WeakSet"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to have a null prototype"],
            AssertionImplSchemaSync<readonly ["to have a null prototype"]>,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                "to be an enumerable property of",
                z.ZodObject<{}, $loose>,
            ],
            (
                subject: string | number | symbol,
                obj: { [key: string]: unknown },
            ) => boolean,
            readonly [
                z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                PhraseLiteralSlot<"to be an enumerable property of">,
                z.ZodObject<{}, $loose>,
            ],
        >,
        AssertionSchemaSync<
            readonly ["to be sealed"],
            AssertionImplSchemaSync<readonly ["to be sealed"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be frozen"],
            AssertionImplSchemaSync<readonly ["to be frozen"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be extensible"],
            AssertionImplSchemaSync<readonly ["to be extensible"]>,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                readonly ["to be an instance of", "to be a"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (_: unknown, ctor: types.Constructor) => z.ZodCustom<any, any>,
            readonly [
                z.ZodUnknown,
                PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodAny,
                readonly ["to be a", "to be an"],
                z.ZodEnum<{ [key: string]: string }>,
            ],
            (
                _: any,
                type: string,
            ) =>
                | z.ZodString
                | z.ZodNumber
                | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>
                | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>
                | z.ZodArray<z.ZodAny>
                | z.ZodBoolean
                | z.ZodBigInt
                | z.ZodSymbol
                | z.ZodNull
                | z.ZodUndefined
                | z.ZodDate
                | z.ZodCustom<RegExp, RegExp>
                | z.ZodCustom<Error, Error>
                | z.ZodFunction<$ZodFunctionArgs, $ZodFunctionOut>
                | z.ZodObject<{}, $loose>
                | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>
                | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>,
            readonly [
                z.ZodAny,
                PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>,
                z.ZodEnum<{ [key: string]: string }>,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodNumber, "to be greater than", z.ZodNumber],
            (_: number, other: number) => z.ZodNumber,
            readonly [
                z.ZodNumber,
                PhraseLiteralSlot<"to be greater than">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodNumber, "to be less than", z.ZodNumber],
            (_: number, other: number) => z.ZodNumber,
            readonly [z.ZodNumber, PhraseLiteralSlot<"to be less than">, z.ZodNumber],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                readonly ["to be greater than or equal to", "to be at least"],
                z.ZodNumber,
            ],
            (_: number, other: number) => z.ZodNumber,
            readonly [
                z.ZodNumber,
                PhraseLiteralChoiceSlot<
                    readonly ["to be greater than or equal to", "to be at least"],
                >,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                readonly ["to be less than or equal to", "to be at most"],
                z.ZodNumber,
            ],
            (_: number, other: number) => z.ZodNumber,
            readonly [
                z.ZodNumber,
                PhraseLiteralChoiceSlot<
                    readonly ["to be less than or equal to", "to be at most"],
                >,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                readonly ["to be within", "to be between"],
                z.ZodNumber,
                z.ZodNumber,
            ],
            (
                subject: number,
                min: number,
                max: number,
            ) => undefined | { actual: number; expected: string; message: string },
            readonly [
                z.ZodNumber,
                PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>,
                z.ZodNumber,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                "to be close to",
                z.ZodNumber,
                z.ZodOptional<z.ZodNumber>,
            ],
            (
                subject: number,
                expected: number,
                tolerance?: undefined | number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodNumber,
                PhraseLiteralSlot<"to be close to">,
                z.ZodNumber,
                z.ZodOptional<z.ZodNumber>,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be greater than", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to be greater than">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be less than", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [z.ZodString, PhraseLiteralSlot<"to be less than">, z.ZodString],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be greater than or equal to", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to be greater than or equal to">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be less than or equal to", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to be less than or equal to">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodString,
                readonly ["to begin with", "to start with"],
                z.ZodString,
            ],
            (
                subject: string,
                prefix: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to end with", z.ZodString],
            (
                subject: string,
                suffix: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [z.ZodString, PhraseLiteralSlot<"to end with">, z.ZodString],
        >,
        AssertionFunctionSync<
            readonly [z.ZodAny, "to be one of", z.ZodArray<z.ZodAny>],
            (
                subject: any,
                values: any[],
            ) => undefined | { actual: unknown; expected: string; message: string },
            readonly [
                z.ZodAny,
                PhraseLiteralSlot<"to be one of">,
                z.ZodArray<z.ZodAny>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to have arity",
                z.ZodNumber,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                expectedArity: number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to have arity">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString],
            (
                subject: Error,
                expectedMessage: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodCustom<Error, Error>,
                PhraseLiteralSlot<"to have message">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Error, Error>,
                "to have message matching",
                z.ZodCustom<RegExp, RegExp>,
            ],
            (
                subject: Error,
                pattern: RegExp,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodCustom<Error, Error>,
                PhraseLiteralSlot<"to have message matching">,
                z.ZodCustom<RegExp, RegExp>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                readonly [
                    "to be",
                    "to equal",
                    "equals",
                    "is",
                    "is equal to",
                    "to strictly equal",
                ],
                z.ZodUnknown,
            ],
            (
                subject: unknown,
                value: unknown,
            ) => undefined | { actual: unknown; expected: unknown; message: string },
            readonly [
                z.ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to be",
                        "to equal",
                        "equals",
                        "is",
                        "is equal to",
                        "to strictly equal",
                    ],
                >,
                z.ZodUnknown,
            ],
        >,
        AssertionSchemaSync<
            readonly [
                z.ZodObject<{}, $loose>,
                readonly ["to deep equal", "to deeply equal"],
                z.ZodObject<{}, $loose>,
            ],
            AssertionImplSchemaSync<
                readonly [
                    z.ZodObject<{}, $loose>,
                    readonly ["to deep equal", "to deeply equal"],
                    z.ZodObject<{}, $loose>,
                ],
            >,
            readonly [
                z.ZodObject<{}, $loose>,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                z.ZodObject<{}, $loose>,
            ],
        >,
        AssertionSchemaSync<
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to deep equal", "to deeply equal"],
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
            AssertionImplSchemaSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    readonly ["to deep equal", "to deeply equal"],
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                ],
            >,
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to throw",
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => undefined | { actual: unknown; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to throw">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw a", "to thrown an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
            ) =>
                | undefined
                | false
                | { actual: {}; expected: types.Constructor; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw"],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: string | RegExp | { [key: string]: unknown },
            ) => boolean,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw a", "to thrown an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
                "satisfying",
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
                param: string | RegExp | { [key: string]: unknown },
            ) =>
                | undefined
                | { actual: string; expected: string; message: string }
                | {
                    actual: unknown;
                    expected: { [key: string]: unknown };
                    message: string;
                },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>,
                z.ZodCustom<types.Constructor, types.Constructor>,
                PhraseLiteralSlot<"satisfying">,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodString,
                readonly ["includes", "contains", "to include", "to contain"],
                z.ZodString,
            ],
            (subject: string, expected: string) => boolean,
            readonly [
                z.ZodString,
                PhraseLiteralChoiceSlot<
                    readonly ["includes", "contains", "to include", "to contain"],
                >,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>],
            (subject: string, regex: RegExp) => boolean,
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to match">,
                z.ZodCustom<RegExp, RegExp>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNonOptional<z.ZodObject<{}, $loose>>,
                readonly ["to satisfy", "to be like"],
                z.ZodObject<{}, $loose>,
            ],
            (
                subject: { [key: string]: unknown },
                shape: { [key: string]: unknown },
            ) => z.ZodType<{}, $loose, $ZodTypeInternals<{}, $loose>>,
            readonly [
                z.ZodNonOptional<z.ZodObject<{}, $loose>>,
                PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
                z.ZodObject<{}, $loose>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to satisfy", "to be like"],
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
            (
                subject:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
                shape:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
            ) => z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to have arity",
                z.ZodNumber,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                expectedArity: number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to have arity">,
                z.ZodNumber,
            ],
        >,
    ],
    readonly [
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to resolve", "to fulfill"],
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to resolve", "to fulfill"],
            ],
            (subject: PromiseLike<unknown>) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to reject",
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to reject">,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                "to reject",
            ],
            (subject: PromiseLike<unknown>) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralSlot<"to reject">,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject with a", "to reject with an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly ["to reject with a", "to reject with an"],
                >,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject with a", "to reject with an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: PromiseLike<unknown>,
                ctor: types.Constructor,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly ["to reject with a", "to reject with an"],
                >,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject with"],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to reject with"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject with"],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: PromiseLike<unknown>,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to reject with"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                promise: PromiseLike<unknown>,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<
                | boolean
                | {
                    actual: unknown;
                    expect: string;
                    message: string;
                    expected?: undefined;
                }
                | {
                    actual: unknown;
                    expected: { [key: string]: unknown };
                    message: string;
                    expect?: undefined;
                },
            >,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<
                | boolean
                | {
                    actual: unknown;
                    expect: string;
                    message: string;
                    expected?: undefined;
                }
                | {
                    actual: unknown;
                    expected: { [key: string]: unknown };
                    message: string;
                    expect?: undefined;
                },
            >,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
    ],
>

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

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

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

Index

Properties

Properties

assertions

use

createAssertion

createAsyncAssertion

fail

Param: reason

Throws

Settings

On This Page