Function expect

expect(
    value: { "[InvalidAssertionChain]": "Only exists for autocompletion" },
    phrase: LiteralStringUnion<
        | "includes"
        | "to contain"
        | "to include"
        | "to have size"
        | "to be empty"
        | "to have item satisfying"
        | "to have an item satisfying"
        | "to contain item satisfying"
        | "to have length"
        | "to be non-empty"
        | "to have keys"
        | "to have properties"
        | "to have props"
        | "to contain keys"
        | "to contain properties"
        | "to contain props"
        | "to include keys"
        | "to include properties"
        | "to include props"
        | "to have exact key"
        | "to have exact property"
        | "to have exact prop"
        | "to have key"
        | "to have property"
        | "to have prop"
        | "to contain key"
        | "to contain property"
        | "to contain prop"
        | "to include key"
        | "to include property"
        | "to include prop"
        | "to equal"
        | "to be a subset of"
        | "to be a superset of"
        | "to intersect with"
        | "to be disjoint from"
        | "to have union"
        | "to have intersection"
        | "to have difference"
        | "to have symmetric difference"
        | "to have value"
        | "to contain value"
        | "to include value"
        | "to have entry"
        | "to have key/value pair"
        | "to contain entry"
        | "to contain key/value pair"
        | "to include entry"
        | "to include key/value pair"
        | "to have size greater than"
        | "to have size less than"
        | "to have size between"
        | "to have values satisfying"
        | "to contain values satisfying"
        | "to have values exhaustively satisfying"
        | "to have a value satisfying"
        | "to have value satisfying"
        | "to contain a value satisfying"
        | "to have a value exhaustively satisfying"
        | "to have value exhaustively satisfying"
        | "to have keys satisfying"
        | "to have props satisfying"
        | "to have properties satisfying"
        | "to have fields satisfying"
        | "to contain keys satisfying"
        | "to contain props satisfying"
        | "to contain properties satisfying"
        | "to contain fields satisfying"
        | "to have keys exhaustively satisfying"
        | "to have props exhaustively satisfying"
        | "to have properties exhaustively satisfying"
        | "to have fields exhaustively satisfying"
        | "to have a key satisfying"
        | "to have key satisfying"
        | "to have a prop satisfying"
        | "to have prop satisfying"
        | "to have a property satisfying"
        | "to have property satisfying"
        | "to have a field satisfying"
        | "to have field satisfying"
        | "to have a key exhaustively satisfying"
        | "to have key exhaustively satisfying"
        | "to have a prop exhaustively satisfying"
        | "to have prop exhaustively satisfying"
        | "to have a property exhaustively satisfying"
        | "to have property exhaustively satisfying"
        | "to have a field exhaustively satisfying"
        | "to have field exhaustively satisfying"
        | "to have keys matching"
        | "to have props matching"
        | "to have properties matching"
        | "to have fields matching"
        | "to have a key matching"
        | "to have key matching"
        | "to have a prop matching"
        | "to have prop matching"
        | "to have a property matching"
        | "to have property matching"
        | "to have a field matching"
        | "to have field matching"
        | "to be an array"
        | "to be array"
        | "to be an async function"
        | "to be a bigint"
        | "to be a BigInt"
        | "to be a boolean"
        | "to be boolean"
        | "to be a bool"
        | "to be a class"
        | "to be a constructor"
        | "to be constructible"
        | "to be a date"
        | "to be a Date"
        | "to be defined"
        | "to be an Error"
        | "to be a Error"
        | "to be false"
        | "to be falsy"
        | "to be a function"
        | "to be infinite"
        | "to be an integer"
        | "to be a safe integer"
        | "to be an int"
        | "to be a safe int"
        | "to be NaN"
        | "to be negative"
        | "to be a negative number"
        | "to be -Infinity"
        | "to be a negative integer"
        | "to be a negative int"
        | "to be null"
        | "to be a number"
        | "to be finite"
        | "to be an object"
        | "to be positive"
        | "to be a positive number"
        | "to be Infinity"
        | "to be a positive integer"
        | "to be a positive int"
        | "to be a primitive"
        | "to be a record"
        | "to be a plain object"
        | "to be a RegExp"
        | "to be a regex"
        | "to be a regexp"
        | "to be a Set"
        | "to be a string"
        | "to be a symbol"
        | "to be a Symbol"
        | "to be true"
        | "to be truthy"
        | "to exist"
        | "to be ok"
        | "to be undefined"
        | "to be a WeakMap"
        | "to be a WeakSet"
        | "to be an instance of"
        | "to be a"
        | "to be an"
        | "to have type"
        | "to be greater than"
        | "to be less than"
        | "to be lt"
        | "to be greater than or equal to"
        | "to be at least"
        | "to be gte"
        | "to be less than or equal to"
        | "to be at most"
        | "to be lte"
        | "to be within"
        | "to be between"
        | "to be close to"
        | "to begin with"
        | "to start with"
        | "to end with"
        | "to be one of"
        | "to have arity"
        | "to have message"
        | "to have message matching"
        | "to be"
        | "equals"
        | "is"
        | "is equal to"
        | "to strictly equal"
        | "is strictly equal to"
        | "to deep equal"
        | "to deeply equal"
        | "to throw"
        | "to throw a"
        | "to throw an"
        | "to throw error satisfying"
        | "contains"
        | "to match"
        | "to satisfy"
        | "to be like"
        | "satisfies"
        | "to have a null prototype"
        | "to be a dictionary"
        | "to be frozen"
        | "to be an enumerable property of"
        | "to have enumerable property"
        | "to be sealed"
        | "to be extensible"
        | "to be after"
        | "to be before"
        | "to be the same date as"
        | "to be a valid date"
        | "to be date-like"
        | "to be a weekday"
        | "to be a weekend"
        | "to match snapshot"
        | "to match the snapshot"
        | "to equal snapshot"
        | "to equal the snapshot"
        | "to yield"
        | "to emit"
        | "to yield value satisfying"
        | "to yield value exhaustively satisfying"
        | "to yield items satisfying"
        | "to yield items exhaustively satisfying"
        | "to yield first"
        | "to yield first satisfying"
        | "to yield first exhaustively satisfying"
        | "to yield last"
        | "to yield last satisfying"
        | "to yield last exhaustively satisfying"
        | "to yield count"
        | "to yield at least"
        | "to yield at most"
        | "to be an empty iterable"
        | "to yield exactly"
        | "to yield sequence satisfying"
        | "to yield array satisfying"
        | "not to yield"
        | "not to emit"
        | "not to yield value satisfying"
        | "not to yield value exhaustively satisfying"
        | "not to yield items satisfying"
        | "not to yield items exhaustively satisfying"
        | "not to yield first"
        | "not to yield first satisfying"
        | "not to yield first exhaustively satisfying"
        | "not to yield last"
        | "not to yield last satisfying"
        | "not to yield last exhaustively satisfying"
        | "not to yield count"
        | "not to yield at least"
        | "not to yield at most"
        | "not to be an empty iterable"
        | "not to yield exactly"
        | "not to yield sequence satisfying"
        | "not to yield array satisfying"
        | "not to contain"
        | "not to include"
        | "not to have size"
        | "not to be empty"
        | "not to have item satisfying"
        | "not to have an item satisfying"
        | "not to contain item satisfying"
        | "not to have length"
        | "not to be non-empty"
        | "not to have keys"
        | "not to have properties"
        | "not to have props"
        | "not to contain keys"
        | "not to contain properties"
        | "not to contain props"
        | "not to include keys"
        | "not to include properties"
        | "not to include props"
        | "not to have exact key"
        | "not to have exact property"
        | "not to have exact prop"
        | "not to have key"
        | "not to have property"
        | "not to have prop"
        | "not to contain key"
        | "not to contain property"
        | "not to contain prop"
        | "not to include key"
        | "not to include property"
        | "not to include prop"
        | "not to equal"
        | "not to be a subset of"
        | "not to be a superset of"
        | "not to intersect with"
        | "not to be disjoint from"
        | "not to have union"
        | "not to have intersection"
        | "not to have difference"
        | "not to have symmetric difference"
        | "not to have value"
        | "not to contain value"
        | "not to include value"
        | "not to have entry"
        | "not to have key/value pair"
        | "not to contain entry"
        | "not to contain key/value pair"
        | "not to include entry"
        | "not to include key/value pair"
        | "not to have size greater than"
        | "not to have size less than"
        | "not to have size between"
        | "not to have values satisfying"
        | "not to contain values satisfying"
        | "not to have values exhaustively satisfying"
        | "not to have a value satisfying"
        | "not to have value satisfying"
        | "not to contain a value satisfying"
        | "not to have a value exhaustively satisfying"
        | "not to have value exhaustively satisfying"
        | "not to have keys satisfying"
        | "not to have props satisfying"
        | "not to have properties satisfying"
        | "not to have fields satisfying"
        | "not to contain keys satisfying"
        | "not to contain props satisfying"
        | "not to contain properties satisfying"
        | "not to contain fields satisfying"
        | "not to have keys exhaustively satisfying"
        | "not to have props exhaustively satisfying"
        | "not to have properties exhaustively satisfying"
        | "not to have fields exhaustively satisfying"
        | "not to have a key satisfying"
        | "not to have key satisfying"
        | "not to have a prop satisfying"
        | "not to have prop satisfying"
        | "not to have a property satisfying"
        | "not to have property satisfying"
        | "not to have a field satisfying"
        | "not to have field satisfying"
        | "not to have a key exhaustively satisfying"
        | "not to have key exhaustively satisfying"
        | "not to have a prop exhaustively satisfying"
        | "not to have prop exhaustively satisfying"
        | "not to have a property exhaustively satisfying"
        | "not to have property exhaustively satisfying"
        | "not to have a field exhaustively satisfying"
        | "not to have field exhaustively satisfying"
        | "not to have keys matching"
        | "not to have props matching"
        | "not to have properties matching"
        | "not to have fields matching"
        | "not to have a key matching"
        | "not to have key matching"
        | "not to have a prop matching"
        | "not to have prop matching"
        | "not to have a property matching"
        | "not to have property matching"
        | "not to have a field matching"
        | "not to have field matching"
        | "not to be an array"
        | "not to be array"
        | "not to be an async function"
        | "not to be a bigint"
        | "not to be a BigInt"
        | "not to be a boolean"
        | "not to be boolean"
        | "not to be a bool"
        | "not to be a class"
        | "not to be a constructor"
        | "not to be constructible"
        | "not to be a date"
        | "not to be a Date"
        | "not to be defined"
        | "not to be an Error"
        | "not to be a Error"
        | "not to be false"
        | "not to be falsy"
        | "not to be a function"
        | "not to be infinite"
        | "not to be an integer"
        | "not to be a safe integer"
        | "not to be an int"
        | "not to be a safe int"
        | "not to be NaN"
        | "not to be negative"
        | "not to be a negative number"
        | "not to be -Infinity"
        | "not to be a negative integer"
        | "not to be a negative int"
        | "not to be null"
        | "not to be a number"
        | "not to be finite"
        | "not to be an object"
        | "not to be positive"
        | "not to be a positive number"
        | "not to be Infinity"
        | "not to be a positive integer"
        | "not to be a positive int"
        | "not to be a primitive"
        | "not to be a record"
        | "not to be a plain object"
        | "not to be a RegExp"
        | "not to be a regex"
        | "not to be a regexp"
        | "not to be a Set"
        | "not to be a string"
        | "not to be a symbol"
        | "not to be a Symbol"
        | "not to be true"
        | "not to be truthy"
        | "not to exist"
        | "not to be ok"
        | "not to be undefined"
        | "not to be a WeakMap"
        | "not to be a WeakSet"
        | "not to be an instance of"
        | "not to be a"
        | "not to be an"
        | "not to have type"
        | "not to be greater than"
        | "not to be less than"
        | "not to be lt"
        | "not to be greater than or equal to"
        | "not to be at least"
        | "not to be gte"
        | "not to be less than or equal to"
        | "not to be at most"
        | "not to be lte"
        | "not to be within"
        | "not to be between"
        | "not to be close to"
        | "not to begin with"
        | "not to start with"
        | "not to end with"
        | "not to be one of"
        | "not to have arity"
        | "not to have message"
        | "not to have message matching"
        | "not to be"
        | "not equals"
        | "not is"
        | "not is equal to"
        | "not to strictly equal"
        | "not is strictly equal to"
        | "not to deep equal"
        | "not to deeply equal"
        | "not to throw"
        | "not to throw a"
        | "not to throw an"
        | "not to throw error satisfying"
        | "not includes"
        | "not contains"
        | "not to match"
        | "not to satisfy"
        | "not to be like"
        | "not satisfies"
        | "not to have a null prototype"
        | "not to be a dictionary"
        | "not to be frozen"
        | "not to be an enumerable property of"
        | "not to have enumerable property"
        | "not to be sealed"
        | "not to be extensible"
        | "not to be after"
        | "not to be before"
        | "not to be the same date as"
        | "not to be a valid date"
        | "not to be date-like"
        | "not to be a weekday"
        | "not to be a weekend"
        | "not to match snapshot"
        | "not to match the snapshot"
        | "not to equal snapshot"
        | "not to equal the snapshot",
    >,
    ...rest: LiteralStringUnion<
        | "includes"
        | "and"
        | "to contain"
        | "to include"
        | "to have size"
        | "to be empty"
        | "to have item satisfying"
        | "to have an item satisfying"
        | "to contain item satisfying"
        | "to have length"
        | "to be non-empty"
        | "to have keys"
        | "to have properties"
        | "to have props"
        | "to contain keys"
        | "to contain properties"
        | "to contain props"
        | "to include keys"
        | "to include properties"
        | "to include props"
        | "to have exact key"
        | "to have exact property"
        | "to have exact prop"
        | "to have key"
        | "to have property"
        | "to have prop"
        | "to contain key"
        | "to contain property"
        | "to contain prop"
        | "to include key"
        | "to include property"
        | "to include prop"
        | "to equal"
        | "to be a subset of"
        | "to be a superset of"
        | "to intersect with"
        | "to be disjoint from"
        | "to have union"
        | "equal to"
        | "to have intersection"
        | "to have difference"
        | "to have symmetric difference"
        | "to have value"
        | "to contain value"
        | "to include value"
        | "to have entry"
        | "to have key/value pair"
        | "to contain entry"
        | "to contain key/value pair"
        | "to include entry"
        | "to include key/value pair"
        | "to have size greater than"
        | "to have size less than"
        | "to have size between"
        | "to have values satisfying"
        | "to contain values satisfying"
        | "to have values exhaustively satisfying"
        | "to have a value satisfying"
        | "to have value satisfying"
        | "to contain a value satisfying"
        | "to have a value exhaustively satisfying"
        | "to have value exhaustively satisfying"
        | "to have keys satisfying"
        | "to have props satisfying"
        | "to have properties satisfying"
        | "to have fields satisfying"
        | "to contain keys satisfying"
        | "to contain props satisfying"
        | "to contain properties satisfying"
        | "to contain fields satisfying"
        | "to have keys exhaustively satisfying"
        | "to have props exhaustively satisfying"
        | "to have properties exhaustively satisfying"
        | "to have fields exhaustively satisfying"
        | "to have a key satisfying"
        | "to have key satisfying"
        | "to have a prop satisfying"
        | "to have prop satisfying"
        | "to have a property satisfying"
        | "to have property satisfying"
        | "to have a field satisfying"
        | "to have field satisfying"
        | "to have a key exhaustively satisfying"
        | "to have key exhaustively satisfying"
        | "to have a prop exhaustively satisfying"
        | "to have prop exhaustively satisfying"
        | "to have a property exhaustively satisfying"
        | "to have property exhaustively satisfying"
        | "to have a field exhaustively satisfying"
        | "to have field exhaustively satisfying"
        | "to have keys matching"
        | "to have props matching"
        | "to have properties matching"
        | "to have fields matching"
        | "to have a key matching"
        | "to have key matching"
        | "to have a prop matching"
        | "to have prop matching"
        | "to have a property matching"
        | "to have property matching"
        | "to have a field matching"
        | "to have field matching"
        | "to be an array"
        | "to be array"
        | "to be an async function"
        | "to be a bigint"
        | "to be a BigInt"
        | "to be a boolean"
        | "to be boolean"
        | "to be a bool"
        | "to be a class"
        | "to be a constructor"
        | "to be constructible"
        | "to be a date"
        | "to be a Date"
        | "to be defined"
        | "to be an Error"
        | "to be a Error"
        | "to be false"
        | "to be falsy"
        | "to be a function"
        | "to be infinite"
        | "to be an integer"
        | "to be a safe integer"
        | "to be an int"
        | "to be a safe int"
        | "to be NaN"
        | "to be negative"
        | "to be a negative number"
        | "to be -Infinity"
        | "to be a negative integer"
        | "to be a negative int"
        | "to be null"
        | "to be a number"
        | "to be finite"
        | "to be an object"
        | "to be positive"
        | "to be a positive number"
        | "to be Infinity"
        | "to be a positive integer"
        | "to be a positive int"
        | "to be a primitive"
        | "to be a record"
        | "to be a plain object"
        | "to be a RegExp"
        | "to be a regex"
        | "to be a regexp"
        | "to be a Set"
        | "to be a string"
        | "to be a symbol"
        | "to be a Symbol"
        | "to be true"
        | "to be truthy"
        | "to exist"
        | "to be ok"
        | "to be undefined"
        | "to be a WeakMap"
        | "to be a WeakSet"
        | "to be an instance of"
        | "to be a"
        | "to be an"
        | "to have type"
        | "to be greater than"
        | "to be less than"
        | "to be lt"
        | "to be greater than or equal to"
        | "to be at least"
        | "to be gte"
        | "to be less than or equal to"
        | "to be at most"
        | "to be lte"
        | "to be within"
        | "to be between"
        | "to be close to"
        | "to begin with"
        | "to start with"
        | "to end with"
        | "to be one of"
        | "to have arity"
        | "to have message"
        | "to have message matching"
        | "to be"
        | "equals"
        | "is"
        | "is equal to"
        | "to strictly equal"
        | "is strictly equal to"
        | "to deep equal"
        | "to deeply equal"
        | "to throw"
        | "to throw a"
        | "to throw an"
        | "to throw error satisfying"
        | "satisfying"
        | "contains"
        | "to match"
        | "to satisfy"
        | "to be like"
        | "satisfies"
        | "to have a null prototype"
        | "to be a dictionary"
        | "to be frozen"
        | "to be an enumerable property of"
        | "to have enumerable property"
        | "to be sealed"
        | "to be extensible"
        | "to be after"
        | "to be before"
        | "within"
        | "to be the same date as"
        | "to be a valid date"
        | "to be date-like"
        | "to be a weekday"
        | "to be a weekend"
        | "to match snapshot"
        | "to match the snapshot"
        | "to equal snapshot"
        | "to equal the snapshot"
        | "with options"
        | "to yield"
        | "to emit"
        | "to yield value satisfying"
        | "to yield value exhaustively satisfying"
        | "to yield items satisfying"
        | "to yield items exhaustively satisfying"
        | "to yield first"
        | "to yield first satisfying"
        | "to yield first exhaustively satisfying"
        | "to yield last"
        | "to yield last satisfying"
        | "to yield last exhaustively satisfying"
        | "to yield count"
        | "to yield at least"
        | "to yield at most"
        | "to be an empty iterable"
        | "to yield exactly"
        | "to yield sequence satisfying"
        | "to yield array satisfying"
        | "not to yield"
        | "not to emit"
        | "not to yield value satisfying"
        | "not to yield value exhaustively satisfying"
        | "not to yield items satisfying"
        | "not to yield items exhaustively satisfying"
        | "not to yield first"
        | "not to yield first satisfying"
        | "not to yield first exhaustively satisfying"
        | "not to yield last"
        | "not to yield last satisfying"
        | "not to yield last exhaustively satisfying"
        | "not to yield count"
        | "not to yield at least"
        | "not to yield at most"
        | "not to be an empty iterable"
        | "not to yield exactly"
        | "not to yield sequence satisfying"
        | "not to yield array satisfying"
        | "not to contain"
        | "not to include"
        | "not to have size"
        | "not to be empty"
        | "not to have item satisfying"
        | "not to have an item satisfying"
        | "not to contain item satisfying"
        | "not to have length"
        | "not to be non-empty"
        | "not to have keys"
        | "not to have properties"
        | "not to have props"
        | "not to contain keys"
        | "not to contain properties"
        | "not to contain props"
        | "not to include keys"
        | "not to include properties"
        | "not to include props"
        | "not to have exact key"
        | "not to have exact property"
        | "not to have exact prop"
        | "not to have key"
        | "not to have property"
        | "not to have prop"
        | "not to contain key"
        | "not to contain property"
        | "not to contain prop"
        | "not to include key"
        | "not to include property"
        | "not to include prop"
        | "not to equal"
        | "not to be a subset of"
        | "not to be a superset of"
        | "not to intersect with"
        | "not to be disjoint from"
        | "not to have union"
        | "not equal to"
        | "not to have intersection"
        | "not to have difference"
        | "not to have symmetric difference"
        | "not to have value"
        | "not to contain value"
        | "not to include value"
        | "not to have entry"
        | "not to have key/value pair"
        | "not to contain entry"
        | "not to contain key/value pair"
        | "not to include entry"
        | "not to include key/value pair"
        | "not to have size greater than"
        | "not to have size less than"
        | "not to have size between"
        | "not to have values satisfying"
        | "not to contain values satisfying"
        | "not to have values exhaustively satisfying"
        | "not to have a value satisfying"
        | "not to have value satisfying"
        | "not to contain a value satisfying"
        | "not to have a value exhaustively satisfying"
        | "not to have value exhaustively satisfying"
        | "not to have keys satisfying"
        | "not to have props satisfying"
        | "not to have properties satisfying"
        | "not to have fields satisfying"
        | "not to contain keys satisfying"
        | "not to contain props satisfying"
        | "not to contain properties satisfying"
        | "not to contain fields satisfying"
        | "not to have keys exhaustively satisfying"
        | "not to have props exhaustively satisfying"
        | "not to have properties exhaustively satisfying"
        | "not to have fields exhaustively satisfying"
        | "not to have a key satisfying"
        | "not to have key satisfying"
        | "not to have a prop satisfying"
        | "not to have prop satisfying"
        | "not to have a property satisfying"
        | "not to have property satisfying"
        | "not to have a field satisfying"
        | "not to have field satisfying"
        | "not to have a key exhaustively satisfying"
        | "not to have key exhaustively satisfying"
        | "not to have a prop exhaustively satisfying"
        | "not to have prop exhaustively satisfying"
        | "not to have a property exhaustively satisfying"
        | "not to have property exhaustively satisfying"
        | "not to have a field exhaustively satisfying"
        | "not to have field exhaustively satisfying"
        | "not to have keys matching"
        | "not to have props matching"
        | "not to have properties matching"
        | "not to have fields matching"
        | "not to have a key matching"
        | "not to have key matching"
        | "not to have a prop matching"
        | "not to have prop matching"
        | "not to have a property matching"
        | "not to have property matching"
        | "not to have a field matching"
        | "not to have field matching"
        | "not to be an array"
        | "not to be array"
        | "not to be an async function"
        | "not to be a bigint"
        | "not to be a BigInt"
        | "not to be a boolean"
        | "not to be boolean"
        | "not to be a bool"
        | "not to be a class"
        | "not to be a constructor"
        | "not to be constructible"
        | "not to be a date"
        | "not to be a Date"
        | "not to be defined"
        | "not to be an Error"
        | "not to be a Error"
        | "not to be false"
        | "not to be falsy"
        | "not to be a function"
        | "not to be infinite"
        | "not to be an integer"
        | "not to be a safe integer"
        | "not to be an int"
        | "not to be a safe int"
        | "not to be NaN"
        | "not to be negative"
        | "not to be a negative number"
        | "not to be -Infinity"
        | "not to be a negative integer"
        | "not to be a negative int"
        | "not to be null"
        | "not to be a number"
        | "not to be finite"
        | "not to be an object"
        | "not to be positive"
        | "not to be a positive number"
        | "not to be Infinity"
        | "not to be a positive integer"
        | "not to be a positive int"
        | "not to be a primitive"
        | "not to be a record"
        | "not to be a plain object"
        | "not to be a RegExp"
        | "not to be a regex"
        | "not to be a regexp"
        | "not to be a Set"
        | "not to be a string"
        | "not to be a symbol"
        | "not to be a Symbol"
        | "not to be true"
        | "not to be truthy"
        | "not to exist"
        | "not to be ok"
        | "not to be undefined"
        | "not to be a WeakMap"
        | "not to be a WeakSet"
        | "not to be an instance of"
        | "not to be a"
        | "not to be an"
        | "not to have type"
        | "not to be greater than"
        | "not to be less than"
        | "not to be lt"
        | "not to be greater than or equal to"
        | "not to be at least"
        | "not to be gte"
        | "not to be less than or equal to"
        | "not to be at most"
        | "not to be lte"
        | "not to be within"
        | "not to be between"
        | "not to be close to"
        | "not to begin with"
        | "not to start with"
        | "not to end with"
        | "not to be one of"
        | "not to have arity"
        | "not to have message"
        | "not to have message matching"
        | "not to be"
        | "not equals"
        | "not is"
        | "not is equal to"
        | "not to strictly equal"
        | "not is strictly equal to"
        | "not to deep equal"
        | "not to deeply equal"
        | "not to throw"
        | "not to throw a"
        | "not to throw an"
        | "not to throw error satisfying"
        | "not satisfying"
        | "not includes"
        | "not contains"
        | "not to match"
        | "not to satisfy"
        | "not to be like"
        | "not satisfies"
        | "not to have a null prototype"
        | "not to be a dictionary"
        | "not to be frozen"
        | "not to be an enumerable property of"
        | "not to have enumerable property"
        | "not to be sealed"
        | "not to be extensible"
        | "not to be after"
        | "not to be before"
        | "not and"
        | "not within"
        | "not to be the same date as"
        | "not to be a valid date"
        | "not to be date-like"
        | "not to be a weekday"
        | "not to be a weekend"
        | "not to match snapshot"
        | "not to match the snapshot"
        | "not to equal snapshot"
        | "not to equal the snapshot"
        | "not with options",
    >[],
): void

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