@augment-vir/assert 30.0.0

package/dist/assertions/extendable-assertions.js

@@ -0,0 +1,108 @@
+import { booleanGuards } from './boolean.js';
+import { boundaryGuards } from './boundary.js';
+import { enumGuards } from './enum.js';
+import { entryEqualityGuards } from './equality/entry-equality.js';
+import { jsonEqualityGuards } from './equality/json-equality.js';
+import { simpleEqualityGuards } from './equality/simple-equality.js';
+import { httpGuards } from './http.js';
+import { instanceGuards } from './instance.js';
+import { keyGuards } from './keys.js';
+import { lengthGuards } from './length.js';
+import { nullishGuards } from './nullish.js';
+import { numericGuards } from './numeric.js';
+import { outputGuards } from './output.js';
+import { primitiveGuards } from './primitive.js';
+import { promiseGuards } from './promise.js';
+import { regexpGuards } from './regexp.js';
+import { runtimeTypeGuards } from './runtime-type.js';
+import { throwGuards } from './throws.js';
+import { uuidGuards } from './uuid.js';
+import { valueGuards } from './values.js';
+export const extendableAssertions = {
+    ...booleanGuards.assertions,
+    ...boundaryGuards.assertions,
+    ...entryEqualityGuards.assertions,
+    ...enumGuards.assertions,
+    ...instanceGuards.assertions,
+    ...jsonEqualityGuards.assertions,
+    ...keyGuards.assertions,
+    ...lengthGuards.assertions,
+    ...nullishGuards.assertions,
+    ...numericGuards.assertions,
+    ...primitiveGuards.assertions,
+    ...promiseGuards.assertions,
+    ...regexpGuards.assertions,
+    ...runtimeTypeGuards.assertions,
+    ...simpleEqualityGuards.assertions,
+    ...throwGuards.assertions,
+    ...uuidGuards.assertions,
+    ...valueGuards.assertions,
+    ...httpGuards.assertions,
+    ...outputGuards.assertions,
+};
+/**
+ * These overrides are required for more complex guards because TypeScript won't allow us to
+ * maintain function type parameters when mapping such functions.
+ */
+export const guardOverrides = [
+    booleanGuards,
+    boundaryGuards,
+    entryEqualityGuards,
+    enumGuards,
+    instanceGuards,
+    jsonEqualityGuards,
+    keyGuards,
+    lengthGuards,
+    nullishGuards,
+    numericGuards,
+    primitiveGuards,
+    promiseGuards,
+    regexpGuards,
+    runtimeTypeGuards,
+    simpleEqualityGuards,
+    throwGuards,
+    uuidGuards,
+    valueGuards,
+    httpGuards,
+    outputGuards,
+];
+export const checkOverrides = Object.assign({}, ...guardOverrides
+    .map((entry) => {
+    if ('checkOverrides' in entry) {
+        return entry.checkOverrides;
+    }
+    else {
+        return undefined;
+    }
+})
+    .filter((entry) => !!entry));
+export const assertWrapOverrides = Object.assign({}, ...guardOverrides
+    .map((entry) => {
+    if ('assertWrapOverrides' in entry) {
+        return entry.assertWrapOverrides;
+    }
+    else {
+        return undefined;
+    }
+})
+    .filter((entry) => !!entry));
+export const checkWrapOverrides = Object.assign({}, ...guardOverrides
+    .map((entry) => {
+    if ('checkWrapOverrides' in entry) {
+        return entry.checkWrapOverrides;
+    }
+    else {
+        return undefined;
+    }
+})
+    .filter((entry) => !!entry));
+export const waitUntilOverrides = Object.assign({}, ...guardOverrides
+    .map((entry) => {
+    if ('waitUntilOverrides' in entry) {
+        return entry.waitUntilOverrides;
+    }
+    else {
+        return undefined;
+    }
+})
+    .filter((entry) => !!entry));

package/dist/assertions/http.d.ts

@@ -0,0 +1,36 @@
+import { HttpStatus, type HttpStatusByCategory, type HttpStatusCategory, type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
+import type { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+declare function isHttpStatus(actual: unknown, failureMessage?: string | undefined): asserts actual is HttpStatus;
+declare function isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined): asserts actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
+export declare const httpGuards: {
+    assertions: {
+        /**
+         * Checks that a value is a standardized HTTP status code. See {@link HttpStatus} for the
+         * statuses.
+         *
+         * Type guards the value.
+         */
+        isHttpStatus: typeof isHttpStatus;
+        /**
+         * Checks that a value is a standardized HTTP status code within the given category of HTTP
+         * status codes. See {@link HttpStatus} for the statuses and {@link HttpStatusCategory} for the
+         * categories.
+         *
+         * Type guards the value.
+         */
+        isHttpStatusCategory: typeof isHttpStatusCategory;
+    };
+    checkOverrides: {
+        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
+    };
+    assertWrapOverrides: {
+        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
+    };
+    checkWrapOverrides: {
+        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => NarrowToExpected<Actual, HttpStatusByCategory<Category>> | undefined;
+    };
+    waitUntilOverrides: {
+        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(category: Category, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, HttpStatusByCategory<Category>>>;
+    };
+};
+export {};

package/dist/assertions/http.js

@@ -0,0 +1,41 @@
+import { HttpStatus, httpStatusByCategory, stringify, } from '@augment-vir/core';
+import { AssertionError } from '../augments/assertion.error.js';
+import { autoGuard } from '../guard-types/guard-override.js';
+import { isEnumValue } from './enum.js';
+import { isIn } from './values.js';
+function isHttpStatus(actual, failureMessage) {
+    try {
+        isEnumValue(actual, HttpStatus);
+    }
+    catch {
+        throw new AssertionError(`${stringify(actual)} is not a valid http status.`, failureMessage);
+    }
+}
+function isHttpStatusCategory(actual, category, failureMessage) {
+    try {
+        isEnumValue(actual, HttpStatus);
+        isIn(actual, httpStatusByCategory[category]);
+    }
+    catch {
+        throw new AssertionError(`${stringify(actual)} is not a '${category}' http status.`, failureMessage);
+    }
+}
+const assertions = {
+    isHttpStatus,
+    isHttpStatusCategory,
+};
+export const httpGuards = {
+    assertions,
+    checkOverrides: {
+        isHttpStatusCategory: autoGuard(),
+    },
+    assertWrapOverrides: {
+        isHttpStatusCategory: autoGuard(),
+    },
+    checkWrapOverrides: {
+        isHttpStatusCategory: autoGuard(),
+    },
+    waitUntilOverrides: {
+        isHttpStatusCategory: autoGuard(),
+    },
+};

package/dist/assertions/instance.d.ts

@@ -0,0 +1,43 @@
+import { MaybePromise } from '@augment-vir/core';
+import { Constructor } from 'type-fest';
+import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+/** Wraps the JavaScript built-in "instanceof" in a type guard assertion. */
+declare function instanceOf<const Instance>(instance: unknown, 
+/** The constructor that the "instance" input will be checked against. */
+constructor: Constructor<Instance>, 
+/** Message to include in error message if this assertion fails. */
+failureMessage?: string | undefined): asserts instance is Instance;
+declare function notInstanceOf<const Actual, const Instance>(instance: Actual, constructor: Constructor<Instance>, failureMessage?: string | undefined): asserts instance is Exclude<Actual, Instance>;
+export declare const instanceGuards: {
+    assertions: {
+        /**
+         * Check if a value is an instance of the given class constructor.
+         *
+         * Type guards the value.
+         */
+        instanceOf: typeof instanceOf;
+        /**
+         * Check if a value is _not_ an instance of the given class constructor.
+         *
+         * Type guards the value when possible.
+         */
+        notInstanceOf: typeof notInstanceOf;
+    };
+    checkOverrides: {
+        instanceOf: <const Instance>(instance: unknown, constructor: Constructor<Instance>) => instance is Instance;
+        notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: Constructor<Instance>) => instance is Exclude<Actual, Instance>;
+    };
+    assertWrapOverrides: {
+        instanceOf: <const Instance>(instance: unknown, constructor: Constructor<Instance>, failureMessage?: string | undefined) => Instance;
+        notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: Constructor<Instance>, failureMessage?: string | undefined) => Exclude<Actual, Instance>;
+    };
+    checkWrapOverrides: {
+        instanceOf: <const Instance>(instance: unknown, constructor: Constructor<Instance>) => Instance | undefined;
+        notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: Constructor<Instance>) => Exclude<Actual, Instance> | undefined;
+    };
+    waitUntilOverrides: {
+        instanceOf: <const Instance>(constructor: Constructor<Instance>, callback: () => MaybePromise<unknown>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Instance>;
+        notInstanceOf: <const Actual, const Instance>(constructor: Constructor<Instance>, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Instance>>;
+    };
+};
+export {};

package/dist/assertions/instance.js

@@ -0,0 +1,41 @@
+import { stringify } from '@augment-vir/core';
+import { AssertionError } from '../augments/assertion.error.js';
+import { autoGuard } from '../guard-types/guard-override.js';
+/** Wraps the JavaScript built-in "instanceof" in a type guard assertion. */
+function instanceOf(instance, 
+/** The constructor that the "instance" input will be checked against. */
+constructor, 
+/** Message to include in error message if this assertion fails. */
+failureMessage) {
+    if (!(instance instanceof constructor)) {
+        throw new AssertionError(`'${stringify(instance)}' is not an instance of '${constructor.name}'`, failureMessage);
+    }
+}
+function notInstanceOf(instance, constructor, failureMessage) {
+    if (instance instanceof constructor) {
+        throw new AssertionError(`'${stringify(instance)}' is an instance of '${constructor.name}'`, failureMessage);
+    }
+}
+const assertions = {
+    instanceOf,
+    notInstanceOf,
+};
+export const instanceGuards = {
+    assertions,
+    checkOverrides: {
+        instanceOf: autoGuard(),
+        notInstanceOf: autoGuard(),
+    },
+    assertWrapOverrides: {
+        instanceOf: autoGuard(),
+        notInstanceOf: autoGuard(),
+    },
+    checkWrapOverrides: {
+        instanceOf: autoGuard(),
+        notInstanceOf: autoGuard(),
+    },
+    waitUntilOverrides: {
+        instanceOf: autoGuard(),
+        notInstanceOf: autoGuard(),
+    },
+};

package/dist/assertions/keys.d.ts

@@ -0,0 +1,90 @@
+import { MaybePromise, NarrowToExpected, type RequiredKeysOf } from '@augment-vir/core';
+import { SetRequired } from 'type-fest';
+import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+declare function isKeyOf<const Parent>(key: PropertyKey, parent: Parent, failureMessage?: string | undefined): asserts key is keyof Parent;
+declare function isNotKeyOf<const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined): asserts key is Exclude<Key, RequiredKeysOf<Parent>>;
+/** Helper type for `hasKey`. */
+type ExtractValue<Key extends PropertyKey, Parent> = Key extends keyof Parent ? SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never;
+/** Helper type for `hasKey`. */
+type CombinedParentValue<Key extends PropertyKey, Parent> = ExtractValue<Key, Parent> extends never ? unknown : ExtractValue<Key, Parent>;
+/** Helper type for `hasKey`. */
+type CombineTypeWithKey<Key extends PropertyKey, Parent> = Parent & Record<Key, CombinedParentValue<Key, Parent>>;
+/** Check if an object has the given property. */
+declare function hasKey<const Key extends PropertyKey, const Parent>(parent: Parent, key: Key, failureMessage?: string | undefined): asserts parent is CombineTypeWithKey<Key, Parent>;
+declare function lacksKey<const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined): asserts parent is Exclude<Parent, Record<Key, any>>;
+/** Check if an object has all the given properties. */
+declare function hasKeys<const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined): asserts parent is CombineTypeWithKey<Keys, Parent>;
+declare function lacksKeys<const Parent, const Key extends PropertyKey>(parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined): asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
+export declare const keyGuards: {
+    assertions: {
+        /**
+         * Check if a key (or property) is contained within a parent value.
+         *
+         * Type guards the key.
+         */
+        isKeyOf: typeof isKeyOf;
+        /**
+         * Check if a key (or property) is _not_ contained within a parent value.
+         *
+         * Type guards the key.
+         */
+        isNotKeyOf: typeof isNotKeyOf;
+        /**
+         * Check if a parent value has a key (or property).
+         *
+         * Type guards the parent value.
+         */
+        hasKey: typeof hasKey;
+        /**
+         * Check if a parent value does _not_ have a key (or property).
+         *
+         * Type guards the parent value when possible.
+         */
+        lacksKey: typeof lacksKey;
+        /**
+         * Check if a parent value has multiple keys (or properties).
+         *
+         * Type guards the parent value.
+         */
+        hasKeys: typeof hasKeys;
+        /**
+         * Check if a parent value does _not_ have multiple keys (or properties).
+         *
+         * Type guards the parent value when possible.
+         */
+        lacksKeys: typeof lacksKeys;
+    };
+    checkOverrides: {
+        isKeyOf: <const Parent>(key: PropertyKey, parent: Parent) => key is keyof Parent;
+        isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => key is Exclude<Key, RequiredKeysOf<Parent>>;
+        hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => parent is CombineTypeWithKey<Key, Parent>;
+        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => parent is Exclude<Parent, Record<Key, any>>;
+        hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => parent is CombineTypeWithKey<Keys, Parent>;
+        lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => parent is Exclude<Parent, Partial<Record<Key, any>>>;
+    };
+    assertWrapOverrides: {
+        isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => NarrowToExpected<Key, keyof Parent>;
+        isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, RequiredKeysOf<Parent>>;
+        hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => CombineTypeWithKey<Key, Parent>;
+        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>>;
+        hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => CombineTypeWithKey<Keys, Parent>;
+        lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>, failureMessage?: string | undefined) => Exclude<Parent, Partial<Record<Key, any>>>;
+    };
+    checkWrapOverrides: {
+        isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent) => NarrowToExpected<Key, keyof Parent> | undefined;
+        isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, RequiredKeysOf<Parent>> | undefined;
+        hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => CombineTypeWithKey<Key, Parent> | undefined;
+        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>> | undefined;
+        hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => CombineTypeWithKey<Keys, Parent> | undefined;
+        lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => Exclude<Parent, Partial<Record<Key, any>>> | undefined;
+    };
+    waitUntilOverrides: {
+        isKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Key, keyof Parent>>;
+        isNotKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Key, RequiredKeysOf<Parent>>>;
+        hasKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<CombineTypeWithKey<Key, Parent>>;
+        lacksKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Record<Key, any>>>;
+        hasKeys: <const Keys extends PropertyKey, const Parent>(keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<CombineTypeWithKey<Keys, Parent>>;
+        lacksKeys: <const Parent, const Keys extends PropertyKey>(keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Partial<Record<Keys, any>>>>;
+    };
+};
+export {};

package/dist/assertions/keys.js

@@ -0,0 +1,111 @@
+import { stringify } from '@augment-vir/core';
+import { AssertionError } from '../augments/assertion.error.js';
+import { createCheck } from '../guard-types/check-function.js';
+import { autoGuard } from '../guard-types/guard-override.js';
+function isKeyOf(key, parent, failureMessage) {
+    try {
+        hasKey(parent, key);
+    }
+    catch {
+        throw new AssertionError(`'${String(key)}' is not a key of '${stringify(parent)}'.`, failureMessage);
+    }
+}
+function isNotKeyOf(key, parent, failureMessage) {
+    try {
+        isKeyOf(key, parent);
+    }
+    catch {
+        return;
+    }
+    throw new AssertionError(`'${String(key)}' is a key of '${stringify(parent)}'.`, failureMessage);
+}
+const hasKeyAttempts = [
+    (object, key) => {
+        return key in object;
+    },
+    (object, key) => {
+        /** This handles cases where the input object can't use `in` directly, like string literals */
+        return key in object.constructor.prototype;
+    },
+];
+/** Check if an object has the given property. */
+function hasKey(parent, key, failureMessage) {
+    const message = `'${stringify(parent)}' does not have key '${String(key)}'.`;
+    const doesHaveKey = hasKeyAttempts.some((attemptCallback) => {
+        try {
+            return attemptCallback(parent, key);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!doesHaveKey) {
+        throw new AssertionError(message, failureMessage);
+    }
+}
+function lacksKey(parent, key, failureMessage) {
+    try {
+        hasKey(parent, key);
+    }
+    catch {
+        return;
+    }
+    throw new AssertionError(`'${stringify(parent)}' has key '${String(key)}'.`, failureMessage);
+}
+const checkHasKey = createCheck(hasKey);
+/** Check if an object has all the given properties. */
+function hasKeys(parent, keys, failureMessage) {
+    const missingKeys = keys.filter((key) => !checkHasKey(parent, key));
+    if (missingKeys.length) {
+        throw new AssertionError(`'${stringify(parent)}' does not have keys '${missingKeys.join(',')}'.`, failureMessage);
+    }
+}
+function lacksKeys(parent, keys, failureMessage) {
+    const existingKeys = keys.filter((key) => checkHasKey(parent, key));
+    if (existingKeys.length) {
+        throw new AssertionError(`'${stringify(parent)}' does not lack keys '${existingKeys.join(',')}'.`, failureMessage);
+    }
+}
+const assertions = {
+    isKeyOf,
+    isNotKeyOf,
+    hasKey,
+    lacksKey,
+    hasKeys,
+    lacksKeys,
+};
+export const keyGuards = {
+    assertions,
+    checkOverrides: {
+        isKeyOf: autoGuard(),
+        isNotKeyOf: autoGuard(),
+        hasKey: autoGuard(),
+        lacksKey: autoGuard(),
+        hasKeys: autoGuard(),
+        lacksKeys: autoGuard(),
+    },
+    assertWrapOverrides: {
+        isKeyOf: autoGuard(),
+        isNotKeyOf: autoGuard(),
+        hasKey: autoGuard(),
+        lacksKey: autoGuard(),
+        hasKeys: autoGuard(),
+        lacksKeys: autoGuard(),
+    },
+    checkWrapOverrides: {
+        isKeyOf: autoGuard(),
+        isNotKeyOf: autoGuard(),
+        hasKey: autoGuard(),
+        lacksKey: autoGuard(),
+        hasKeys: autoGuard(),
+        lacksKeys: autoGuard(),
+    },
+    waitUntilOverrides: {
+        isKeyOf: autoGuard(),
+        isNotKeyOf: autoGuard(),
+        hasKey: autoGuard(),
+        lacksKey: autoGuard(),
+        hasKeys: autoGuard(),
+        lacksKeys: autoGuard(),
+    },
+};

package/dist/assertions/length.d.ts

@@ -0,0 +1,56 @@
+import { MaybePromise, Tuple, type AnyObject, type AtLeastTuple } from '@augment-vir/core';
+import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+declare function isLengthAtLeast<const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is AtLeastTuple<Element, Length>;
+declare function isLengthAtLeast(actual: string | AnyObject, length: number, failureMessage?: string | undefined): void;
+declare function isLengthExactly<const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is Tuple<Element, Length>;
+declare function isLengthExactly(actual: string | AnyObject, length: number, failureMessage?: string | undefined): void;
+/** These functions are not used at run time, they're only here for types. */
+declare function checkIsLengthAtLeast<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is AtLeastTuple<Element, Length>;
+declare function checkIsLengthAtLeast(actual: string | AnyObject, length: number): boolean;
+declare function assertWrapIsLengthAtLeast<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): AtLeastTuple<Element, Length>;
+declare function assertWrapIsLengthAtLeast<Actual extends string | AnyObject>(actual: Actual, length: number): Actual;
+declare function checkWrapIsLengthAtLeast<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): AtLeastTuple<Element, Length> | undefined;
+declare function checkWrapIsLengthAtLeast<Actual extends string | AnyObject>(actual: Actual, length: number): Actual | undefined;
+declare function waitUntilIsLengthAtLeast<Element, Length extends number>(length: Length, callback: () => MaybePromise<ReadonlyArray<Element | undefined>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<AtLeastTuple<Element, Length>>;
+declare function waitUntilIsLengthAtLeast<Actual extends string | AnyObject>(length: number, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
+declare function checkIsLengthExactly<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is Tuple<Element, Length>;
+declare function checkIsLengthExactly(actual: string | AnyObject, length: number): boolean;
+declare function assertWrapIsLengthExactly<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): Tuple<Element, Length>;
+declare function assertWrapIsLengthExactly<Actual extends string | AnyObject>(actual: Actual, length: number): Actual;
+declare function checkWrapIsLengthExactly<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): Tuple<Element, Length> | undefined;
+declare function checkWrapIsLengthExactly<Actual extends string | AnyObject>(actual: Actual, length: number): Actual | undefined;
+declare function waitUntilIsLengthExactly<Element, Length extends number>(length: Length, callback: () => MaybePromise<ReadonlyArray<Element | undefined>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Tuple<Element, Length>>;
+declare function waitUntilIsLengthExactly<Actual extends string | AnyObject>(length: number, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
+export declare const lengthGuards: {
+    assertions: {
+        /**
+         * Check if an array has at least the given length.
+         *
+         * Type guards the array into an {@link AtLeastTuple}.
+         */
+        isLengthAtLeast: typeof isLengthAtLeast;
+        /**
+         * Check if an array has exactly the given length.
+         *
+         * Type guards the array into a {@link Tuple}.
+         */
+        isLengthExactly: typeof isLengthExactly;
+    };
+    checkOverrides: {
+        isLengthAtLeast: typeof checkIsLengthAtLeast;
+        isLengthExactly: typeof checkIsLengthExactly;
+    };
+    assertWrapOverrides: {
+        isLengthAtLeast: typeof assertWrapIsLengthAtLeast;
+        isLengthExactly: typeof assertWrapIsLengthExactly;
+    };
+    checkWrapOverrides: {
+        isLengthAtLeast: typeof checkWrapIsLengthAtLeast;
+        isLengthExactly: typeof checkWrapIsLengthExactly;
+    };
+    waitUntilOverrides: {
+        isLengthAtLeast: typeof waitUntilIsLengthAtLeast;
+        isLengthExactly: typeof waitUntilIsLengthExactly;
+    };
+};
+export {};

package/dist/assertions/length.js

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { getObjectTypedKeys, } from '@augment-vir/core';
+import { AssertionError } from '../augments/assertion.error.js';
+import { autoGuard } from '../guard-types/guard-override.js';
+function isLengthAtLeast(actual, length, failureMessage) {
+    const actualLength = Array.isArray(actual) || typeof actual === 'string'
+        ? actual.length
+        : getObjectTypedKeys(actual).length;
+    if (actualLength < length) {
+        throw new AssertionError(`Length '${actual.length}' is not at least '${length}'.`, failureMessage);
+    }
+}
+function isLengthExactly(actual, length, failureMessage) {
+    const actualLength = Array.isArray(actual) || typeof actual === 'string'
+        ? actual.length
+        : getObjectTypedKeys(actual).length;
+    if (actualLength !== length) {
+        throw new AssertionError(`Length '${actual.length}' is not exactly '${length}'.`, failureMessage);
+    }
+}
+function checkIsLengthAtLeast(actual, length) {
+    return false;
+}
+function assertWrapIsLengthAtLeast(actual, length) {
+    return false;
+}
+function checkWrapIsLengthAtLeast(actual, length) {
+    return false;
+}
+function waitUntilIsLengthAtLeast(length, callback, options, failureMessage) {
+    return false;
+}
+function checkIsLengthExactly(actual, length) {
+    return false;
+}
+function assertWrapIsLengthExactly(actual, length) {
+    return false;
+}
+function checkWrapIsLengthExactly(actual, length) {
+    return false;
+}
+function waitUntilIsLengthExactly(length, callback, options, failureMessage) {
+    return false;
+}
+/* node:coverage enable */
+const assertions = {
+    isLengthAtLeast,
+    isLengthExactly,
+};
+export const lengthGuards = {
+    assertions,
+    checkOverrides: {
+        isLengthAtLeast: autoGuard(),
+        isLengthExactly: autoGuard(),
+    },
+    assertWrapOverrides: {
+        isLengthAtLeast: autoGuard(),
+        isLengthExactly: autoGuard(),
+    },
+    checkWrapOverrides: {
+        isLengthAtLeast: autoGuard(),
+        isLengthExactly: autoGuard(),
+    },
+    waitUntilOverrides: {
+        isLengthAtLeast: autoGuard(),
+        isLengthExactly: autoGuard(),
+    },
+};

package/dist/assertions/nullish.d.ts

@@ -0,0 +1,43 @@
+import { MaybePromise } from '@augment-vir/core';
+import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+declare function isDefined<const Actual>(
+/** The value to check. */
+input: Actual, 
+/** Message to include in error message if this assertion fails. */
+failureMessage?: string | undefined): asserts input is Exclude<Actual, undefined | null>;
+declare function isNullish(
+/** The value to check. */
+input: unknown, 
+/** Message to include in error message if this assertion fails. */
+failureMessage?: string | undefined): asserts input is null | undefined;
+export declare const nullishGuards: {
+    assertions: {
+        /**
+         * Checks that a value is defined (not `null` and not `undefined`).
+         *
+         * Type guards the value.
+         */
+        isDefined: typeof isDefined;
+        /**
+         * Checks that a value is nullish (`null` or `undefined`).
+         *
+         * Type guards the value.
+         */
+        isNullish: typeof isNullish;
+    };
+    checkOverrides: {
+        isDefined: <Actual>(input: Actual) => input is Exclude<Actual, undefined | null>;
+    };
+    assertWrapOverrides: {
+        isDefined: <Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined | null>;
+    };
+    /** Nullish checks don't make any sense on `checkWrap`. */
+    checkWrapOverrides: {
+        isDefined: undefined;
+        isNullish: undefined;
+    };
+    waitUntilOverrides: {
+        isDefined: <Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined | null>>;
+    };
+};
+export {};