bupkis 0.1.2 → 0.2.0

package/dist/commonjs/index.d.ts

@@ -6,112 +6,163 @@
  * guards, schema definitions, utility functions, and error types.
  *
  * @module bupkis
+ * @category API
+ * @example
+ *
+ * ```ts
+ * import { expect, expectAsync, z, createAssertion } from 'bupkis';
+ * ```
+ *
+ * @showGroups
  */
-export type * from './api.js';
-export * as assertion from './assertion/index.js';
+import { z } from 'zod/v4';
 export { expect, expectAsync } from './bootstrap.js';
-export * as error from './error.js';
-export * as guards from './guards.js';
-export type * as metadata from './metadata.js';
-export * as schema from './schema.js';
+export { AssertionError } from './error.js';
+/**
+ * Re-export of most (all?) types defined within <span
+ * class="bupkis">Bupkis</span>.
+ *
+ * @example
+ *
+ * ```ts
+ * import { types } from 'bupkis';
+ * ```
+ */
 export type * as types from './types.js';
-export * as util from './util.js';
-export { z } from 'zod/v4';
+/**
+ * Re-export of {@link https://zod.dev Zod v4} for use in custom assertion
+ * implementations.
+ */
+export { z };
+/**
+ * @primaryExport
+ */
+export type { Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, FailFn, UseFn, } from './types.js';
 export { createAssertion, createAsyncAssertion, fail, use };
-declare const createAssertion: typeof import("./assertion/create.js").createAssertion, createAsyncAssertion: typeof import("./assertion/create.js").createAsyncAssertion, fail: (this: void, reason?: string) => never, use: import("./types.js").UseFn<readonly [import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodMap<import("zod/v4").ZodAny, import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [import("zod/v4").ZodMap<import("zod/v4").ZodAny, import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodSet<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Set<any>, value: any) => boolean, readonly [import("zod/v4").ZodSet<import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: any[], value: any) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have size", import("zod/v4").ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have length", import("zod/v4").ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have length">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be non-empty"], (subject: any[]) => {
+declare const 
+/**
+ * The main factory function for creating asynchronous assertions.
+ *
+ * Exported from the entry point; is also a property of {@link Expect} and
+ * {@link ExpectAsync}.
+ *
+ * @function
+ */
+createAssertion: import("./types.js").CreateAssertionFn, 
+/**
+ * The main factory function for creating asynchronous assertions.
+ *
+ * Exported from the entry point; is also a property of {@link Expect} and
+ * {@link ExpectAsync}.
+ *
+ * @function
+ */
+createAsyncAssertion: import("./types.js").CreateAsyncAssertionFn, 
+/**
+ * {@inheritDoc FailFn}
+ *
+ * @function
+ */
+fail: import("./types.js").FailFn, 
+/**
+ * {@inheritDoc UseFn}
+ *
+ * @function
+ */
+use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodAny, z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [z.ZodMap<z.ZodAny, z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: Set<any>, value: any) => boolean, readonly [z.ZodSet<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: any[], value: any) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to be non-empty"], (subject: any[]) => {
     actual: number;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to have keys", "to have properties", "to have props"], import("zod/v4").ZodTuple<[import("zod/v4").ZodString], import("zod/v4").ZodString>], (_: {
+} | undefined, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodObject<{}, z.core.$loose>, readonly ["to have keys", "to have properties", "to have props"], z.ZodTuple<[z.ZodString], z.ZodString>], (_: {
     [x: string]: unknown;
-}, keys: [string, ...string[]]) => import("zod/v4").ZodObject<{
-    [k: string]: import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>;
-}, import("zod/v4/core").$loose>, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props"]>, import("zod/v4").ZodTuple<[import("zod/v4").ZodString], import("zod/v4").ZodString>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, "to have size", import("zod/v4").ZodNumber], (subject: {
+}, keys: [string, ...string[]]) => z.ZodObject<{
+    [k: string]: z.ZodNonOptional<z.ZodUnknown>;
+}, z.core.$loose>, readonly [z.ZodObject<{}, z.core.$loose>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props"]>, z.ZodTuple<[z.ZodString], z.ZodString>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodObject<{}, z.core.$loose>, "to have size", z.ZodNumber], (subject: {
     [x: string]: unknown;
 }, expectedSize: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a string"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be infinite"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be true"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be false"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a function"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be NaN"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be null"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be undefined"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be falsy"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be an object"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be empty"]>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, "to be empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, "to be empty"]>, readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be an Error"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be an Error"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"]>, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"]>, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be defined"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a Set"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to have a null prototype"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to have a null prototype"]>, never>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, "to be an enumerable property of", import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], (subject: string | number | symbol, obj: {
+} | undefined, readonly [z.ZodObject<{}, z.core.$loose>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionSchemaSync<readonly ["to be a string"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be infinite"], import("./types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be true"], import("./types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be false"], import("./types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be NaN"], import("./types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be null"], import("./types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be undefined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be falsy"], import("./types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an object"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [z.ZodArray<z.ZodAny>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodAny>, "to be empty"]>, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"]>, readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly ["to be an Error"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an Error"]>, never>, import("./types.js").AssertionSchemaSync<readonly [z.ZodString, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodString, "to be non-empty"], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionSchemaSync<readonly ["to be defined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a Set"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to have a null prototype"], import("./types.js").AssertionImplSchemaSync<readonly ["to have a null prototype"]>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, "to be an enumerable property of", z.ZodObject<{}, z.core.$loose>], (subject: string | number | symbol, obj: {
     [x: string]: unknown;
-}) => boolean, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be frozen"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be frozen"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => import("zod/v4").ZodCustom<any, any>, readonly [import("zod/v4").ZodUnknown, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodAny, readonly ["to be a", "to be an"], import("zod/v4").ZodEnum<{
+}) => boolean, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be frozen"], import("./types.js").AssertionImplSchemaSync<readonly ["to be frozen"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => z.ZodCustom<any, any>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodAny, readonly ["to be a", "to be an"], z.ZodEnum<{
     [x: string]: string;
-}>], (_: any, type: string) => import("zod/v4").ZodString | import("zod/v4").ZodNumber | import("zod/v4").ZodSymbol | import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod/v4").ZodBoolean | import("zod/v4").ZodBigInt | import("zod/v4").ZodNull | import("zod/v4").ZodUndefined | import("zod/v4").ZodArray<import("zod/v4").ZodAny> | import("zod/v4").ZodCustom<RegExp, RegExp> | import("zod/v4").ZodDate | import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod/v4").ZodCustom<Error, Error> | import("zod/v4").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose> | import("zod/v4").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod/v4").ZodAny, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>, import("zod/v4").ZodEnum<{
+}>], (_: any, type: string) => z.ZodString | z.ZodNumber | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodArray<z.ZodAny> | z.ZodBoolean | z.ZodBigInt | z.ZodSymbol | z.ZodNull | z.ZodUndefined | z.ZodDate | z.ZodCustom<RegExp, RegExp> | z.ZodCustom<Error, Error> | z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | z.ZodObject<{}, z.core.$loose> | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [z.ZodAny, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>, z.ZodEnum<{
     [x: string]: string;
-}>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be greater than", import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be less than", import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, readonly ["to be greater than or equal to", "to be at least"], import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least"]>, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, readonly ["to be less than or equal to", "to be at most"], import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most"]>, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be within", import("zod/v4").ZodNumber, import("zod/v4").ZodNumber], (subject: number, min: number, max: number) => {
+}>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be greater than", z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be less than", z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be less than">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be greater than or equal to", "to be at least"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than or equal to", "to be at most"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be within", "to be between"], z.ZodNumber, z.ZodNumber], (subject: number, min: number, max: number) => {
     actual: number;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be within">, import("zod/v4").ZodNumber, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be close to", import("zod/v4").ZodNumber, import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
+} | undefined, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, z.ZodNumber, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be close to", z.ZodNumber, z.ZodOptional<z.ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be close to">, import("zod/v4").ZodNumber, import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be greater than", import("zod/v4").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be close to">, z.ZodNumber, z.ZodOptional<z.ZodNumber>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than", z.ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be less than", import("zod/v4").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than", z.ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be greater than or equal to", import("zod/v4").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be less than">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than or equal to", z.ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be less than or equal to", import("zod/v4").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than or equal to">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than or equal to", z.ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["to begin with", "to start with"], import("zod/v4").ZodString], (subject: string, prefix: string) => {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be less than or equal to">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["to begin with", "to start with"], z.ZodString], (subject: string, prefix: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to end with", import("zod/v4").ZodString], (subject: string, suffix: string) => {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to end with", z.ZodString], (subject: string, suffix: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to end with">, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodAny, "to be one of", import("zod/v4").ZodArray<import("zod/v4").ZodAny>], (subject: any, values: any[]) => {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to end with">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodAny, "to be one of", z.ZodArray<z.ZodAny>], (subject: any, values: any[]) => {
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodAny, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be one of">, import("zod/v4").ZodArray<import("zod/v4").ZodAny>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to have arity", import("zod/v4").ZodNumber], (subject: (...args: any[]) => any, expectedArity: number) => {
+} | undefined, readonly [z.ZodAny, import("./types.js").PhraseLiteralSlot<"to be one of">, z.ZodArray<z.ZodAny>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod/v4").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Error, Error>, "to have message", import("zod/v4").ZodString], (subject: Error, expectedMessage: string) => {
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString], (subject: Error, expectedMessage: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<Error, Error>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have message">, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Error, Error>, "to have message matching", import("zod/v4").ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
+} | undefined, readonly [z.ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message matching", z.ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<Error, Error>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have message matching">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"], import("zod/v4").ZodUnknown], (subject: unknown, value: unknown) => {
+} | undefined, readonly [z.ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message matching">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"], z.ZodUnknown], (subject: unknown, value: unknown) => {
     actual: unknown;
     expected: unknown;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnknown, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, import("zod/v4").ZodUnknown]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to throw"], (subject: (...args: any[]) => any) => {
+} | undefined, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, z.ZodUnknown]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodObject<{}, z.core.$loose>, readonly ["to deep equal", "to deeply equal"], z.ZodObject<{}, z.core.$loose>], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodObject<{}, z.core.$loose>, readonly ["to deep equal", "to deeply equal"], z.ZodObject<{}, z.core.$loose>]>, readonly [z.ZodObject<{}, z.core.$loose>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>, readonly ["to deep equal", "to deeply equal"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>, readonly ["to deep equal", "to deeply equal"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>]>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
     actual: unknown;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to throw">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to throw a", "to thrown an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: any[]) => any, ctor: import("./types.js").Constructor) => false | {
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to thrown an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => false | {
     actual: {};
     expected: import("./types.js").Constructor;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to throw"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, param: string | RegExp | {
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => boolean, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to throw a", "to thrown an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, ctor: import("./types.js").Constructor, param: string | RegExp | {
+}) => boolean, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to thrown an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: string | RegExp | {
     [x: string]: unknown;
 }) => {
     actual: string;
@@ -123,33 +174,33 @@ declare const createAssertion: typeof import("./assertion/create.js").createAsse
         [x: string]: unknown;
     };
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"satisfying">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod/v4").ZodString], (subject: string, expected: string) => boolean, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod/v4").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to match", import("zod/v4").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod/v4").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to match">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], (_subject: {
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, readonly ["to satisfy", "to be like"], z.ZodObject<{}, z.core.$loose>], (subject: {
     [x: string]: unknown;
 }, shape: {
     [x: string]: unknown;
-}) => import("zod/v4").ZodType<{}, import("zod/v4/core").$loose>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>], (_subject: any[] | [any, ...any[]] | {
+}) => z.ZodType<{}, z.core.$loose>, readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>, readonly ["to satisfy", "to be like"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>], (subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}, shape: any[] | [any, ...any[]] | {
+}, shape: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}) => typeof import("./schema.js").ArrayLikeSchema, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("zod/v4").ZodTuple<[import("zod/v4").ZodAny], import("zod/v4").ZodAny>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to have arity", import("zod/v4").ZodNumber], (subject: (...args: any[]) => any, expectedArity: number) => {
+}) => typeof import("./schema.js").ArrayLikeSchema, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+    length: z.ZodNumber;
+}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod/v4").ZodNumber]>], readonly [import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to resolve", "to fulfill"]], (subject: (...args: any[]) => any) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to reject"], (subject: (...args: any[]) => any) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to reject">]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to reject">]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: any[]) => any, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to reject with"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, param: string | RegExp | {
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, z.ZodNumber]>], readonly [import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to reject"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: PromiseLike<unknown>, param: string | RegExp | {
+}) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: PromiseLike<unknown>, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve to value satisfying"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (promise: PromiseLike<unknown>, param: string | RegExp | {
+}) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (promise: PromiseLike<unknown>, param: string | RegExp | {
     [x: string]: unknown;
 }) => Promise<boolean | {
     actual: unknown;
@@ -163,7 +214,7 @@ declare const createAssertion: typeof import("./assertion/create.js").createAsse
     };
     message: string;
     expect?: never;
-}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve to value satisfying"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to fulfill with value satisfying", "to resolve to value satisfying"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, param: string | RegExp | {
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
 }) => Promise<boolean | {
     actual: unknown;
@@ -177,5 +228,5 @@ declare const createAssertion: typeof import("./assertion/create.js").createAsse
     };
     message: string;
     expect?: never;
-}>, readonly [import("zod/v4").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve to value satisfying"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>]>;
+}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>]>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,mBAAmB,UAAU,CAAC;AAE9B,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,YAAY,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA,MAAQ,eAAe,0DAAE,oBAAoB,+DAAE,IAAI,0CAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6ZACrC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,MAAM,EACN,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iZAEgB,CAAC"}

package/dist/commonjs/index.js

@@ -7,54 +7,56 @@
  * guards, schema definitions, utility functions, and error types.
  *
  * @module bupkis
+ * @category API
+ * @example
+ *
+ * ```ts
+ * import { expect, expectAsync, z, createAssertion } from 'bupkis';
+ * ```
+ *
+ * @showGroups
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.use = exports.fail = exports.createAsyncAssertion = exports.createAssertion = exports.z = exports.util = exports.schema = exports.guards = exports.error = exports.expectAsync = exports.expect = exports.assertion = void 0;
+exports.use = exports.fail = exports.createAsyncAssertion = exports.createAssertion = exports.z = exports.AssertionError = exports.expectAsync = exports.expect = void 0;
+const v4_1 = require("zod/v4");
+Object.defineProperty(exports, "z", { enumerable: true, get: function () { return v4_1.z; } });
 const bootstrap_js_1 = require("./bootstrap.js");
-exports.assertion = __importStar(require("./assertion/index.js"));
 var bootstrap_js_2 = require("./bootstrap.js");
 Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return bootstrap_js_2.expect; } });
 Object.defineProperty(exports, "expectAsync", { enumerable: true, get: function () { return bootstrap_js_2.expectAsync; } });
-exports.error = __importStar(require("./error.js"));
-exports.guards = __importStar(require("./guards.js"));
-exports.schema = __importStar(require("./schema.js"));
-exports.util = __importStar(require("./util.js"));
-var v4_1 = require("zod/v4");
-Object.defineProperty(exports, "z", { enumerable: true, get: function () { return v4_1.z; } });
-const { createAssertion, createAsyncAssertion, fail, use, ..._rest } = bootstrap_js_1.expect;
+var error_js_1 = require("./error.js");
+Object.defineProperty(exports, "AssertionError", { enumerable: true, get: function () { return error_js_1.AssertionError; } });
+const { 
+/**
+ * The main factory function for creating asynchronous assertions.
+ *
+ * Exported from the entry point; is also a property of {@link Expect} and
+ * {@link ExpectAsync}.
+ *
+ * @function
+ */
+createAssertion, 
+/**
+ * The main factory function for creating asynchronous assertions.
+ *
+ * Exported from the entry point; is also a property of {@link Expect} and
+ * {@link ExpectAsync}.
+ *
+ * @function
+ */
+createAsyncAssertion, 
+/**
+ * {@inheritDoc FailFn}
+ *
+ * @function
+ */
+fail, 
+/**
+ * {@inheritDoc UseFn}
+ *
+ * @function
+ */
+use, ..._rest } = bootstrap_js_1.expect;
 exports.createAssertion = createAssertion;
 exports.createAsyncAssertion = createAsyncAssertion;
 exports.fail = fail;

package/dist/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iDAA6D;AAG7D,kEAAkD;AAClD,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAE5B,oDAAoC;AACpC,sDAAsC;AAGtC,sDAAsC;AAEtC,kDAAkC;AAElC,6BAA2B;AAAlB,uFAAA,CAAC,OAAA;AAGV,MAAM,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,GAClE,qBAAiB,CAAC;AAFX,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,+BAA2B;AAuBlB,kFAvBA,MAAC,OAuBA;AArBV,iDAA6D;AAC7D,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAE5B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AAiCvB,MAAM;AACJ;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAjCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}