bupkis 0.1.2 → 0.3.0

package/src/value-to-schema.ts

@@ -0,0 +1,464 @@
+import { z } from 'zod/v4';
+
+import {
+  isNonNullObject,
+  isObject,
+  isPromiseLike,
+  isString,
+  isZodType,
+} from './guards.js';
+import {
+  RegExpSchema,
+  StrongMapSchema,
+  StrongSetSchema,
+  WrappedPromiseLikeSchema,
+} from './schema.js';
+
+/**
+ * Recursively converts an arbitrary value to a Zod v4 schema that would
+ * validate values with the same structure.
+ *
+ * This function analyzes the runtime value and generates a corresponding Zod
+ * schema that captures the value's structure and type information. It handles
+ * primitives, objects, arrays, functions, and various built-in types, with
+ * support for circular reference detection.
+ *
+ * @example
+ *
+ * ```typescript
+ * // Primitive types
+ * valueToSchema('hello'); // z.string()
+ * valueToSchema(42); // z.number()
+ * valueToSchema(true); // z.boolean()
+ *
+ * // Objects
+ * valueToSchema({ name: 'John', age: 30 });
+ * // z.object({ name: z.string(), age: z.number() })
+ *
+ * // Arrays
+ * valueToSchema(['a', 'b', 'c']); // z.array(z.string())
+ * valueToSchema([1, 'mixed']); // z.array(z.union([z.number(), z.string()]))
+ *
+ * // Nested structures
+ * valueToSchema({ users: [{ name: 'John' }] });
+ * // z.object({ users: z.array(z.object({ name: z.string() })) })
+ * ```
+ *
+ * @param value - The value to convert to a schema
+ * @param options - Configuration options for schema generation
+ * @param visited - Internal WeakSet for circular reference detection
+ * @returns A Zod schema that validates values matching the input's structure.
+ *   This value is unfortunately untyped due to the complexity involved. But the
+ *   schema works!
+ */
+
+export const valueToSchema = (
+  value: unknown,
+  options: ValueToSchemaOptions = {},
+  visited = new WeakSet<object>(),
+): z.ZodType<any> => {
+  const {
+    _currentDepth = 0,
+    literalEmptyObjects = false,
+    literalPrimitives = false,
+    literalRegExp = false,
+    literalTuples = false,
+    maxDepth = 10,
+    noMixedArrays = false,
+    strict = false,
+  } = options;
+
+  // Prevent infinite recursion
+  if (_currentDepth >= maxDepth) {
+    return z.unknown();
+  }
+
+  // Handle primitives
+  if (value === null) {
+    return z.null();
+  }
+
+  if (value === undefined) {
+    return literalPrimitives
+      ? z.custom<undefined>((val: unknown) => val === undefined, {
+          message: 'Expected undefined',
+        })
+      : z.undefined();
+  }
+  if (Number.isNaN(value as number)) {
+    return z.nan();
+  }
+  if (value === Infinity || value === -Infinity) {
+    return z.literal(value);
+  }
+
+  const valueType = typeof value;
+
+  switch (valueType) {
+    case 'bigint':
+      return literalPrimitives ? z.literal(value as bigint) : z.bigint();
+    case 'boolean':
+      return literalPrimitives ? z.literal(value as boolean) : z.boolean();
+    case 'function':
+      return z.function();
+    case 'number':
+      return literalPrimitives ? z.literal(value as number) : z.number();
+    case 'string':
+      return literalPrimitives ? z.literal(value as string) : z.string();
+    case 'symbol':
+      return z.symbol();
+  }
+
+  // Handle objects
+  if (typeof value === 'object' && value !== null) {
+    // Check for circular references
+    if (visited.has(value)) {
+      // Return a recursive schema reference or unknown for circular refs
+      return z.unknown();
+    }
+
+    visited.add(value);
+
+    try {
+      // Check for objects with own __proto__ property - these can cause unexpected behavior
+      if (Object.hasOwn(value, '__proto__')) {
+        throw new TypeError(
+          'Objects with an own "__proto__" property are not supported by valueToSchema',
+        );
+      }
+
+      // Handle built-in object types
+      if (value instanceof Date) {
+        // Check if it's a valid date
+        if (isNaN(value.getTime())) {
+          // For invalid dates, use a literal or custom validator
+          return z.custom<Date>(
+            (val) => val instanceof Date && isNaN(val.getTime()),
+            {
+              message: 'Expected an invalid Date',
+            },
+          );
+        }
+        return z.date();
+      }
+
+      if (value instanceof RegExp) {
+        if (literalRegExp) {
+          return RegExpSchema;
+        }
+        return z.coerce.string().regex(value);
+      }
+
+      if (value instanceof Map) {
+        return StrongMapSchema;
+      }
+
+      if (value instanceof Set) {
+        return StrongSetSchema;
+      }
+
+      if (value instanceof WeakMap) {
+        return z.instanceof(WeakMap);
+      }
+
+      if (value instanceof WeakSet) {
+        return z.instanceof(WeakSet);
+      }
+
+      if (value instanceof Error) {
+        return z.instanceof(Error);
+      }
+
+      if (isPromiseLike(value)) {
+        return WrappedPromiseLikeSchema;
+      }
+
+      // Handle arrays
+      if (Array.isArray(value)) {
+        // For arrays, we need to preserve undefined values while allowing
+        // other elements to use the original literalPrimitives setting
+        const filteredValue = value; // Always process all elements
+
+        if (filteredValue.length === 0) {
+          // For empty arrays, use z.tuple() if literalTuples is enabled
+          if (literalTuples) {
+            return z.tuple([]);
+          }
+          return z.array(z.never());
+        }
+
+        const elementSchemas = filteredValue.map((item) => {
+          // Use literal mode for undefined values to preserve them exactly,
+          // but use the original setting for other values
+          const itemLiteralPrimitives =
+            item === undefined ? true : literalPrimitives;
+
+          return valueToSchema(
+            item,
+            {
+              ...options,
+              _currentDepth: _currentDepth + 1,
+              literalPrimitives: itemLiteralPrimitives,
+            },
+            visited,
+          );
+        });
+
+        // Use z.tuple() if literalTuples is enabled
+        if (literalTuples) {
+          return z.tuple(elementSchemas as [z.ZodType, ...z.ZodType[]]);
+        }
+
+        if (!noMixedArrays) {
+          // Helper function to generate structural keys for schemas
+          const getSchemaKey = <T extends z.core.SomeType | z.ZodType>(
+            zodType: T,
+          ): string => {
+            const schema = zodType as z.ZodType;
+            if (isZodType(schema, 'literal')) {
+              return `${schema.constructor.name}:${String(schema.def.values)}`;
+            }
+
+            if (isZodType(schema, 'array')) {
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+              const elementKey = getSchemaKey((schema.def as any).element);
+              return `ZodArray<${elementKey}>`;
+            }
+
+            if (isZodType(schema, 'object')) {
+              // For objects, create a key based on the property keys and their types
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+              const shape = (schema.def as any).shape as Record<
+                string,
+                z.ZodType
+              >;
+              const shapeKeys = Object.keys(shape)
+                .sort()
+                .map((key) => {
+                  const propSchema = shape[key]!;
+                  return `${key}:${getSchemaKey(propSchema)}`;
+                });
+              return `ZodObject<{${shapeKeys.join(',')}}>`;
+            }
+
+            if (isZodType(schema, 'union')) {
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+              const optionKeys = ((schema.def as any).options as z.ZodType[])
+                .map((option) => getSchemaKey(option))
+                .sort();
+              return `ZodUnion<[${optionKeys.join(',')}]>`;
+            }
+
+            // For other types, use the constructor name
+            return schema.constructor.name;
+          };
+
+          const seenSchemaKeys = new Set<string>();
+          const uniqueSchemas: z.ZodType[] = [];
+
+          for (const schema of elementSchemas) {
+            const schemaKey = getSchemaKey(schema);
+
+            if (!seenSchemaKeys.has(schemaKey)) {
+              seenSchemaKeys.add(schemaKey);
+              uniqueSchemas.push(schema);
+            }
+          }
+
+          if (uniqueSchemas.length === 1) {
+            return z.array(uniqueSchemas[0]!);
+          } else {
+            return z.array(
+              z.union(uniqueSchemas as [z.ZodType, z.ZodType, ...z.ZodType[]]),
+            );
+          }
+        } else {
+          // Use the first element's schema for all elements
+          return z.array(elementSchemas[0]!);
+        }
+      }
+
+      // Handle plain objects
+      if (isNonNullObject(value)) {
+        const schemaShape: Record<string, z.ZodType<any>> = {};
+        const undefinedKeys: string[] = [];
+
+        for (const [key, val] of Object.entries(value)) {
+          if (isString(key)) {
+            // Skip undefined values unless we're in literalPrimitives mode
+            // This prevents objects with only undefined values from matching any object
+            if (val === undefined && !literalPrimitives) {
+              continue;
+            }
+
+            if (val === undefined && literalPrimitives) {
+              // Track keys that should have undefined values
+              undefinedKeys.push(key);
+              schemaShape[key] = z.undefined();
+            } else {
+              schemaShape[key] = valueToSchema(
+                val,
+                {
+                  ...options,
+                  _currentDepth: _currentDepth + 1,
+                },
+                visited,
+              );
+            }
+          }
+        }
+
+        // Create the base object schema
+        const baseSchema = strict
+          ? z.strictObject(schemaShape)
+          : z.looseObject(schemaShape);
+
+        // If we have undefined keys in literalPrimitives mode, add validation to ensure they exist
+        if (undefinedKeys.length > 0 && literalPrimitives) {
+          return baseSchema.superRefine((data, ctx) => {
+            if (typeof data !== 'object' || data === null) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Expected an object',
+              });
+              return;
+            }
+
+            const obj = data as Record<string, unknown>;
+            for (const key of undefinedKeys) {
+              if (!Object.hasOwn(obj, key)) {
+                ctx.addIssue({
+                  code: z.ZodIssueCode.custom,
+                  message: `Expected property "${key}" to exist with value undefined`,
+                  path: [key],
+                });
+              }
+            }
+          });
+        }
+
+        // Check if this is an empty object and literalEmptyObjects is enabled
+        if (Object.keys(schemaShape).length === 0 && literalEmptyObjects) {
+          // Create a schema that only matches empty objects
+          return z.custom<Record<string, never>>(
+            (val) => isObject(val) && Object.keys(val).length === 0,
+            {
+              message: 'Expected an empty object with no own properties',
+            },
+          );
+        }
+
+        return baseSchema;
+      }
+
+      // Handle other object types (ArrayBuffer, etc.)
+      return z.custom<object>(
+        (val) => typeof val === 'object' && val !== null,
+        { message: 'Expected an object' },
+      );
+    } finally {
+      visited.delete(value);
+    }
+  }
+
+  // Fallback for unknown types
+  return z.unknown();
+};
+
+/**
+ * Options for {@link valueToSchema}
+ */
+export interface ValueToSchemaOptions {
+  /**
+   * Current depth (internal)
+   *
+   * @internal
+   */
+  _currentDepth?: number;
+
+  /**
+   * If `true`, treat empty objects `{}` as literal empty objects that only
+   * match objects with zero own properties
+   *
+   * @defaultValue false
+   */
+  literalEmptyObjects?: boolean;
+
+  /**
+   * If `true`, use literal schema for primitive values instead of type schema
+   *
+   * @defaultValue false
+   */
+  literalPrimitives?: boolean;
+
+  /**
+   * If `true`, treat `RegExp` literals as `RegExp` literals; otherwise treat as
+   * strings and attempt match
+   *
+   * @defaultValue false
+   */
+  literalRegExp?: boolean;
+
+  /**
+   * If `true`, treat arrays as tuples wherever possible.
+   *
+   * Implies `false` for {@link noMixedArrays}.
+   *
+   * @defaultValue false
+   */
+  literalTuples?: boolean;
+
+  /**
+   * Maximum nesting depth to prevent stack overflow
+   *
+   * @defaultValue 10
+   */
+  maxDepth?: number;
+
+  /**
+   * Whether to allow mixed types in arrays
+   *
+   * If {@link literalTuples} is `true`, this option is ignored and treated as
+   * `false`.
+   *
+   * @defaultValue false
+   */
+  noMixedArrays?: boolean;
+
+  /**
+   * If `true`, will disallow unknown properties in parsed objects
+   *
+   * @defaultValue false
+   */
+  strict?: boolean;
+}
+
+/**
+ * Predefined options for {@link valueToSchema} optimized for object satisfaction
+ * checks.
+ *
+ * Uses literal primitives and tuples for exact matching while allowing extra
+ * properties.
+ */
+export const valueToSchemaOptionsForSatisfies = Object.freeze({
+  literalEmptyObjects: true,
+  literalPrimitives: true,
+  literalRegExp: false,
+  literalTuples: true,
+  strict: false,
+} as const) satisfies ValueToSchemaOptions;
+
+/**
+ * Predefined options for {@link valueToSchema} optimized for deep equality
+ * checks.
+ *
+ * Uses literal primitives, regexp, and tuples with strict validation for exact
+ * matching.
+ */
+export const valueToSchemaOptionsForDeepEqual = Object.freeze({
+  literalEmptyObjects: true,
+  literalPrimitives: true,
+  literalRegExp: true,
+  literalTuples: true,
+  strict: true,
+} as const) satisfies ValueToSchemaOptions;

package/dist/commonjs/api.d.ts

@@ -1,93 +0,0 @@
-/**
- * Contains the main API types
- *
- * @packageDocumentation
- */
-import type { TupleToUnion, UnionToIntersection } from 'type-fest';
-import type { AnyAsyncAssertion, AnyAsyncAssertions, AnySyncAssertion, AnySyncAssertions, BuiltinAsyncAssertions, BuiltinSyncAssertions } from './assertion/assertion-types.js';
-import type { createAssertion, createAsyncAssertion } from './assertion/create.js';
-import { type InferredExpectSlots, type MutableOrReadonly, type UseFn } from './types.js';
-/**
- * Base set of properties included in both {@link Expect} and {@link ExpectAsync}.
- */
-export interface BaseExpect {
-    /**
-     * Creates a new synchronous assertion.
-     */
-    createAssertion: typeof createAssertion;
-    /**
-     * Creates a new asynchronous assertion.
-     */
-    createAsyncAssertion: typeof createAsyncAssertion;
-    /**
-     * Fails immediately with optional `reason`.
-     *
-     * @param reason Reason for failure
-     * @throws {AssertionError}
-     */
-    fail(this: void, reason?: string): never;
-}
-/**
- * The main synchronous assertion function.
- *
- * Contains properties in {@link ExpectSyncProps}.
- *
- * @template T All synchronous assertions available
- * @template U All asynchronous assertions available; for use in
- *   {@link ExpectSyncProps.use}
- * @useDeclaredType
- * @see {@link expect}
- */
-export type Expect<T extends AnySyncAssertions = BuiltinSyncAssertions, U extends AnyAsyncAssertions = BuiltinAsyncAssertions> = ExpectFunction<T> & ExpectSyncProps<T, U>;
-/**
- * The main asynchronous assertion function.
- *
- * Contains properties in {@link ExpectSyncProps}.
- *
- * @useDeclaredType
- * @see {@link expectAsync}
- */
-export type ExpectAsync<T extends AnyAsyncAssertions = BuiltinAsyncAssertions, U extends AnySyncAssertions = BuiltinSyncAssertions> = ExpectAsyncFunction<T> & ExpectAsyncProps<T, U>;
-/**
- * All function overloads for `expectAsync()`; part of {@link ExpectAsync}.
- */
-export type ExpectAsyncFunction<T extends AnyAsyncAssertions = BuiltinAsyncAssertions> = UnionToIntersection<TupleToUnion<{
-    [K in keyof T]: T[K] extends AnyAsyncAssertion ? (...args: MutableOrReadonly<InferredExpectSlots<T[K]['parts']>>) => Promise<void> : never;
-}>>;
-/**
- * Properties available on `expectAsync()`; part of {@link ExpectAsync}.
- */
-export interface ExpectAsyncProps<T extends AnyAsyncAssertions, U extends AnySyncAssertions> extends BaseExpect {
-    /**
-     * Tuple of all assertions available in this `expect()`.
-     */
-    assertions: T;
-    /**
-     * Function to add more assertions to this `expect()`, returning a new
-     * `expect()` and `expectAsync()` pair with the combined assertions.
-     */
-    use: UseFn<U, T>;
-}
-/**
- * All function overloads for `expect()`; part of {@link Expect}.
- *
- * @useDeclaredType
- */
-export type ExpectFunction<T extends AnySyncAssertions = BuiltinSyncAssertions> = UnionToIntersection<TupleToUnion<{
-    [K in keyof T]: T[K] extends AnySyncAssertion ? (...args: MutableOrReadonly<InferredExpectSlots<T[K]['parts']>>) => void : never;
-}>>;
-/**
- * Properties for `expect()`; part of {@link Expect}.
- */
-export interface ExpectSyncProps<T extends AnySyncAssertions, U extends AnyAsyncAssertions> extends BaseExpect {
-    /**
-     * Tuple of all assertions available in this `expect()`.
-     */
-    assertions: T;
-    /**
-     * Function to add more assertions to this `expect()`, returning a new
-     * `expect()` and `expectAsync()` pair with the combined assertions.
-     */
-    use: UseFn<T, U>;
-}
-//# sourceMappingURL=api.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEnE,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,KAAK,EACX,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,eAAe,EAAE,OAAO,eAAe,CAAC;IACxC;;OAEG;IACH,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC1C;AAED;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,MAAM,CAChB,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,EACnD,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,IACnD,cAAc,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE9C;;;;;;;GAOG;AAEH,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,EACrD,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,IACjD,mBAAmB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEpD;;GAEG;AAEH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,IACnD,mBAAmB,CACrB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,iBAAiB,GAC1C,CACE,GAAG,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAC3D,OAAO,CAAC,IAAI,CAAC,GAClB,KAAK;CACV,CAAC,CACH,CAAC;AAEF;;GAEG;AAEH,MAAM,WAAW,gBAAgB,CAC/B,CAAC,SAAS,kBAAkB,EAC5B,CAAC,SAAS,iBAAiB,CAC3B,SAAQ,UAAU;IAClB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC;IACd;;;OAGG;IACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,IACjD,mBAAmB,CACrB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,gBAAgB,GACzC,CAAC,GAAG,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,GACxE,KAAK;CACV,CAAC,CACH,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,CAC5B,SAAQ,UAAU;IAClB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC;IAEd;;;OAGG;IACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB"}

package/dist/commonjs/api.js

@@ -1,8 +0,0 @@
-"use strict";
-/**
- * Contains the main API types
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=api.js.map

package/dist/commonjs/api.js.map

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

package/dist/esm/api.d.ts

@@ -1,93 +0,0 @@
-/**
- * Contains the main API types
- *
- * @packageDocumentation
- */
-import type { TupleToUnion, UnionToIntersection } from 'type-fest';
-import type { AnyAsyncAssertion, AnyAsyncAssertions, AnySyncAssertion, AnySyncAssertions, BuiltinAsyncAssertions, BuiltinSyncAssertions } from './assertion/assertion-types.js';
-import type { createAssertion, createAsyncAssertion } from './assertion/create.js';
-import { type InferredExpectSlots, type MutableOrReadonly, type UseFn } from './types.js';
-/**
- * Base set of properties included in both {@link Expect} and {@link ExpectAsync}.
- */
-export interface BaseExpect {
-    /**
-     * Creates a new synchronous assertion.
-     */
-    createAssertion: typeof createAssertion;
-    /**
-     * Creates a new asynchronous assertion.
-     */
-    createAsyncAssertion: typeof createAsyncAssertion;
-    /**
-     * Fails immediately with optional `reason`.
-     *
-     * @param reason Reason for failure
-     * @throws {AssertionError}
-     */
-    fail(this: void, reason?: string): never;
-}
-/**
- * The main synchronous assertion function.
- *
- * Contains properties in {@link ExpectSyncProps}.
- *
- * @template T All synchronous assertions available
- * @template U All asynchronous assertions available; for use in
- *   {@link ExpectSyncProps.use}
- * @useDeclaredType
- * @see {@link expect}
- */
-export type Expect<T extends AnySyncAssertions = BuiltinSyncAssertions, U extends AnyAsyncAssertions = BuiltinAsyncAssertions> = ExpectFunction<T> & ExpectSyncProps<T, U>;
-/**
- * The main asynchronous assertion function.
- *
- * Contains properties in {@link ExpectSyncProps}.
- *
- * @useDeclaredType
- * @see {@link expectAsync}
- */
-export type ExpectAsync<T extends AnyAsyncAssertions = BuiltinAsyncAssertions, U extends AnySyncAssertions = BuiltinSyncAssertions> = ExpectAsyncFunction<T> & ExpectAsyncProps<T, U>;
-/**
- * All function overloads for `expectAsync()`; part of {@link ExpectAsync}.
- */
-export type ExpectAsyncFunction<T extends AnyAsyncAssertions = BuiltinAsyncAssertions> = UnionToIntersection<TupleToUnion<{
-    [K in keyof T]: T[K] extends AnyAsyncAssertion ? (...args: MutableOrReadonly<InferredExpectSlots<T[K]['parts']>>) => Promise<void> : never;
-}>>;
-/**
- * Properties available on `expectAsync()`; part of {@link ExpectAsync}.
- */
-export interface ExpectAsyncProps<T extends AnyAsyncAssertions, U extends AnySyncAssertions> extends BaseExpect {
-    /**
-     * Tuple of all assertions available in this `expect()`.
-     */
-    assertions: T;
-    /**
-     * Function to add more assertions to this `expect()`, returning a new
-     * `expect()` and `expectAsync()` pair with the combined assertions.
-     */
-    use: UseFn<U, T>;
-}
-/**
- * All function overloads for `expect()`; part of {@link Expect}.
- *
- * @useDeclaredType
- */
-export type ExpectFunction<T extends AnySyncAssertions = BuiltinSyncAssertions> = UnionToIntersection<TupleToUnion<{
-    [K in keyof T]: T[K] extends AnySyncAssertion ? (...args: MutableOrReadonly<InferredExpectSlots<T[K]['parts']>>) => void : never;
-}>>;
-/**
- * Properties for `expect()`; part of {@link Expect}.
- */
-export interface ExpectSyncProps<T extends AnySyncAssertions, U extends AnyAsyncAssertions> extends BaseExpect {
-    /**
-     * Tuple of all assertions available in this `expect()`.
-     */
-    assertions: T;
-    /**
-     * Function to add more assertions to this `expect()`, returning a new
-     * `expect()` and `expectAsync()` pair with the combined assertions.
-     */
-    use: UseFn<T, U>;
-}
-//# sourceMappingURL=api.d.ts.map

package/dist/esm/api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEnE,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,KAAK,EACX,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,eAAe,EAAE,OAAO,eAAe,CAAC;IACxC;;OAEG;IACH,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC1C;AAED;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,MAAM,CAChB,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,EACnD,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,IACnD,cAAc,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE9C;;;;;;;GAOG;AAEH,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,EACrD,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,IACjD,mBAAmB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEpD;;GAEG;AAEH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,IACnD,mBAAmB,CACrB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,iBAAiB,GAC1C,CACE,GAAG,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAC3D,OAAO,CAAC,IAAI,CAAC,GAClB,KAAK;CACV,CAAC,CACH,CAAC;AAEF;;GAEG;AAEH,MAAM,WAAW,gBAAgB,CAC/B,CAAC,SAAS,kBAAkB,EAC5B,CAAC,SAAS,iBAAiB,CAC3B,SAAQ,UAAU;IAClB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC;IACd;;;OAGG;IACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,IACjD,mBAAmB,CACrB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,gBAAgB,GACzC,CAAC,GAAG,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,GACxE,KAAK;CACV,CAAC,CACH,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,CAC5B,SAAQ,UAAU;IAClB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC;IAEd;;;OAGG;IACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB"}

package/dist/esm/api.js

@@ -1,7 +0,0 @@
-/**
- * Contains the main API types
- *
- * @packageDocumentation
- */
-export {};
-//# sourceMappingURL=api.js.map

package/dist/esm/api.js.map

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