@augment-vir/assert 31.0.0 → 31.0.1

package/dist/assertions/keys.d.ts

@@ -1,20 +1,13 @@
 import { type MaybePromise, type NarrowToExpected, type RequiredKeysOf } from '@augment-vir/core';
 import { type SetRequired } from 'type-fest';
 import { type 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>>>;
+declare function hasKey<const Key extends PropertyKey, const Parent>(this: void, parent: Parent, key: Key): parent is CombineTypeWithKey<Key, Parent>;
 export declare const keyGuards: {
     assert: {
         /**
@@ -35,7 +28,7 @@ export declare const keyGuards: {
          * @see
          * - {@link assert.isNotKeyOf} : the opposite assertion.
          */
-        isKeyOf: typeof isKeyOf;
+        isKeyOf<const Parent>(this: void, key: PropertyKey, parent: Parent, failureMessage?: string | undefined): asserts key is keyof Parent;
         /**
          * Asserts that a key is _not_ contained within a parent value.
          *
@@ -54,7 +47,7 @@ export declare const keyGuards: {
          * @see
          * - {@link assert.isKeyOf} : the opposite assertion.
          */
-        isNotKeyOf: typeof isNotKeyOf;
+        isNotKeyOf<const Key extends PropertyKey, const Parent>(this: void, key: Key, parent: Parent, failureMessage?: string | undefined): asserts key is Exclude<Key, RequiredKeysOf<Parent>>;
         /**
          * Asserts that a parent value has the key.
          *
@@ -74,7 +67,7 @@ export declare const keyGuards: {
          * - {@link assert.lacksKey} : the opposite assertion.
          * - {@link assert.hasKeys} : the multi-key assertion.
          */
-        hasKey: typeof hasKey;
+        hasKey<const Key extends PropertyKey, const Parent>(this: void, parent: Parent, key: Key, failureMessage?: string | undefined): asserts parent is CombineTypeWithKey<Key, Parent>;
         /**
          * Asserts that a parent value does not have the key.
          *
@@ -94,7 +87,7 @@ export declare const keyGuards: {
          * - {@link assert.hasKey} : the opposite assertion.
          * - {@link assert.lacksKeys} : the multi-key assertion.
          */
-        lacksKey: typeof lacksKey;
+        lacksKey<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, key: Key, failureMessage?: string | undefined): asserts parent is Exclude<Parent, Record<Key, any>>;
         /**
          * Asserts that a parent value has all the keys.
          *
@@ -105,14 +98,8 @@ export declare const keyGuards: {
          * ```ts
          * import {assert} from '@augment-vir/assert';
          *
-         * assert.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // passes
-         * assert.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // fails
+         * assert.hasKeys({a: 0, b: 1}, ['a', 'b']); // passes
+         * assert.hasKeys({a: 0, b: 1}, ['b', 'c']); // fails
          * ```
          *
          * @throws {@link AssertionError} If the parent does not have all the keys.
@@ -120,7 +107,7 @@ export declare const keyGuards: {
          * - {@link assert.lacksKeys} : the opposite assertion.
          * - {@link assert.hasKey} : the single-key assertion.
          */
-        hasKeys: typeof hasKeys;
+        hasKeys<const Keys extends PropertyKey, const Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined): asserts parent is CombineTypeWithKey<Keys, Parent>;
         /**
          * Asserts that a parent value none of the keys.
          *
@@ -131,14 +118,8 @@ export declare const keyGuards: {
          * ```ts
          * import {assert} from '@augment-vir/assert';
          *
-         * assert.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // fails
-         * assert.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // passes
+         * assert.lacksKeys({a: 0, b: 1}, ['b', 'c']); // fails
+         * assert.lacksKeys({a: 0, b: 1}, ['c', 'd']); // passes
          * ```
          *
          * @throws {@link AssertionError} If the parent has any of the keys.
@@ -146,7 +127,7 @@ export declare const keyGuards: {
          * - {@link assert.hasKeys} : the opposite assertion.
          * - {@link assert.lacksKey} : the single-key assertion.
          */
-        lacksKeys: typeof lacksKeys;
+        lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined): asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
     };
     check: {
         /**
@@ -166,7 +147,7 @@ export declare const keyGuards: {
          * @see
          * - {@link check.isNotKeyOf} : the opposite check.
          */
-        isKeyOf: <const Parent>(key: PropertyKey, parent: Parent) => key is keyof Parent;
+        isKeyOf<const Parent>(this: void, key: PropertyKey, parent: Parent): key is keyof Parent;
         /**
          * Checks that a key is _not_ contained within a parent value.
          *
@@ -184,7 +165,7 @@ export declare const keyGuards: {
          * @see
          * - {@link check.isKeyOf} : the opposite check.
          */
-        isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => key is Exclude<Key, RequiredKeysOf<Parent>>;
+        isNotKeyOf<const Key extends PropertyKey, const Parent>(this: void, key: Key, parent: Parent): key is Exclude<Key, RequiredKeysOf<Parent>>;
         /**
          * Checks that a parent value has the key.
          *
@@ -203,7 +184,7 @@ export declare const keyGuards: {
          * - {@link check.lacksKey} : the opposite check.
          * - {@link check.hasKeys} : the multi-key check.
          */
-        hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => parent is CombineTypeWithKey<Key, Parent>;
+        hasKey: typeof hasKey;
         /**
          * Checks that a parent value does not have the key.
          *
@@ -222,7 +203,7 @@ export declare const keyGuards: {
          * - {@link check.hasKey} : the opposite check.
          * - {@link check.lacksKeys} : the multi-key check.
          */
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => parent is Exclude<Parent, Record<Key, any>>;
+        lacksKey<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, key: Key): parent is Exclude<Parent, Record<Key, any>>;
         /**
          * Checks that a parent value has all the keys.
          *
@@ -233,21 +214,15 @@ export declare const keyGuards: {
          * ```ts
          * import {check} from '@augment-vir/assert';
          *
-         * check.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // returns `true`
-         * check.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `false`
+         * check.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `true`
+         * check.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
          * ```
          *
          * @see
          * - {@link check.lacksKeys} : the opposite check.
          * - {@link check.hasKey} : the single-key check.
          */
-        hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => parent is CombineTypeWithKey<Keys, Parent>;
+        hasKeys<const Keys extends PropertyKey, const Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>): parent is CombineTypeWithKey<Keys, Parent>;
         /**
          * Checks that a parent value none of the keys.
          *
@@ -258,21 +233,15 @@ export declare const keyGuards: {
          * ```ts
          * import {check} from '@augment-vir/assert';
          *
-         * check.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `false`
-         * check.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // returns `true`
+         * check.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
+         * check.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `true`
          * ```
          *
          * @see
          * - {@link check.hasKeys} : the opposite check.
          * - {@link check.lacksKey} : the single-key check.
          */
-        lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => parent is Exclude<Parent, Partial<Record<Key, any>>>;
+        lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>): parent is Exclude<Parent, Partial<Record<Key, any>>>;
     };
     assertWrap: {
         /**
@@ -295,7 +264,7 @@ export declare const keyGuards: {
          * @see
          * - {@link assertWrap.isNotKeyOf} : the opposite assertion.
          */
-        isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => NarrowToExpected<Key, keyof Parent>;
+        isKeyOf<const Key extends PropertyKey, const Parent>(this: void, key: Key, parent: Parent, failureMessage?: string | undefined): NarrowToExpected<Key, keyof Parent>;
         /**
          * Asserts that a key is _not_ contained within a parent value. Returns the key if the
          * assertion passes.
@@ -316,7 +285,7 @@ export declare const keyGuards: {
          * @see
          * - {@link assertWrap.isKeyOf} : the opposite assertion.
          */
-        isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, RequiredKeysOf<Parent>>;
+        isNotKeyOf<const Key extends PropertyKey, const Parent>(this: void, key: Key, parent: Parent, failureMessage?: string | undefined): Exclude<Key, RequiredKeysOf<Parent>>;
         /**
          * Asserts that a parent value has the key. Returns the parent if the assertion passes.
          *
@@ -337,7 +306,7 @@ export declare const keyGuards: {
          * - {@link assertWrap.lacksKey} : the opposite assertion.
          * - {@link assertWrap.hasKeys} : the multi-key assertion.
          */
-        hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => CombineTypeWithKey<Key, Parent>;
+        hasKey<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, key: Key, failureMessage?: string | undefined): CombineTypeWithKey<Key, Parent>;
         /**
          * Asserts that a parent value does not have the key. Returns the parent if the assertion
          * passes.
@@ -359,7 +328,7 @@ export declare const keyGuards: {
          * - {@link assertWrap.hasKey} : the opposite assertion.
          * - {@link assertWrap.lacksKeys} : the multi-key assertion.
          */
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>>;
+        lacksKey<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, key: Key, failureMessage?: string | undefined): Exclude<Parent, Record<Key, any>>;
         /**
          * Asserts that a parent value has all the keys. Returns the parent if the assertion passes.
          *
@@ -370,14 +339,8 @@ export declare const keyGuards: {
          * ```ts
          * import {assertWrap} from '@augment-vir/assert';
          *
-         * assertWrap.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // returns `{a: 0, b: 1}`
-         * assertWrap.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // throws an error
+         * assertWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
+         * assertWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
          * ```
          *
          * @returns The parent if it has all the keys.
@@ -386,7 +349,7 @@ export declare const keyGuards: {
          * - {@link assertWrap.lacksKeys} : the opposite assertion.
          * - {@link assertWrap.hasKey} : the single-key assertion.
          */
-        hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => CombineTypeWithKey<Keys, Parent>;
+        hasKeys<const Keys extends PropertyKey, const Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined): CombineTypeWithKey<Keys, Parent>;
         /**
          * Asserts that a parent value none of the keys. Returns the parent if the assertion passes.
          *
@@ -397,14 +360,8 @@ export declare const keyGuards: {
          * ```ts
          * import {assertWrap} from '@augment-vir/assert';
          *
-         * assertWrap.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // throws an error
-         * assertWrap.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // returns `{a: 0, b: 1}`
+         * assertWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
+         * assertWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
          * ```
          *
          * @returns The parent if it does not have any of the keys.
@@ -413,7 +370,7 @@ export declare const keyGuards: {
          * - {@link assertWrap.hasKeys} : the opposite assertion.
          * - {@link assertWrap.lacksKey} : the single-key assertion.
          */
-        lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>, failureMessage?: string | undefined) => Exclude<Parent, Partial<Record<Key, any>>>;
+        lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined): Exclude<Parent, Partial<Record<Key, any>>>;
     };
     checkWrap: {
         /**
@@ -435,7 +392,7 @@ export declare const keyGuards: {
          * @see
          * - {@link checkWrap.isNotKeyOf} : the opposite check.
          */
-        isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent) => NarrowToExpected<Key, keyof Parent> | undefined;
+        isKeyOf<const Key extends PropertyKey, const Parent>(this: void, key: Key, parent: Parent): NarrowToExpected<Key, keyof Parent> | undefined;
         /**
          * Checks that a key is _not_ contained within a parent value. Returns the key if the check
          * passes, otherwise `undefined`.
@@ -455,7 +412,7 @@ export declare const keyGuards: {
          * @see
          * - {@link checkWrap.isKeyOf} : the opposite check.
          */
-        isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, RequiredKeysOf<Parent>> | undefined;
+        isNotKeyOf<const Key extends PropertyKey, const Parent>(this: void, key: Key, parent: Parent): Exclude<Key, RequiredKeysOf<Parent>> | undefined;
         /**
          * Checks that a parent value has the key. Returns the parent value if the check passes,
          * otherwise `undefined`.
@@ -476,7 +433,7 @@ export declare const keyGuards: {
          * - {@link checkWrap.lacksKey} : the opposite check.
          * - {@link checkWrap.hasKeys} : the multi-key check.
          */
-        hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => CombineTypeWithKey<Key, Parent> | undefined;
+        hasKey<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, key: Key): CombineTypeWithKey<Key, Parent> | undefined;
         /**
          * Checks that a parent value does not have the key. Returns the parent value if the check
          * passes, otherwise `undefined`.
@@ -497,7 +454,7 @@ export declare const keyGuards: {
          * - {@link checkWrap.hasKey} : the opposite check.
          * - {@link checkWrap.lacksKeys} : the multi-key check.
          */
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>> | undefined;
+        lacksKey<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, key: Key): Exclude<Parent, Record<Key, any>> | undefined;
         /**
          * Checks that a parent value has all the keys. Returns the parent value if the check
          * passes, otherwise `undefined`.
@@ -509,14 +466,8 @@ export declare const keyGuards: {
          * ```ts
          * import {checkWrap} from '@augment-vir/assert';
          *
-         * checkWrap.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // returns `{a: 0, b: 1}`
-         * checkWrap.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `undefined`
+         * checkWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
+         * checkWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
          * ```
          *
          * @returns The parent value if the check passes, otherwise `undefined`.
@@ -524,7 +475,7 @@ export declare const keyGuards: {
          * - {@link checkWrap.lacksKeys} : the opposite check.
          * - {@link checkWrap.hasKey} : the single-key check.
          */
-        hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => CombineTypeWithKey<Keys, Parent> | undefined;
+        hasKeys<const Keys extends PropertyKey, const Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>): CombineTypeWithKey<Keys, Parent> | undefined;
         /**
          * Checks that a parent value none of the keys. Returns the parent value if the check
          * passes, otherwise `undefined`.
@@ -536,14 +487,8 @@ export declare const keyGuards: {
          * ```ts
          * import {checkWrap} from '@augment-vir/assert';
          *
-         * checkWrap.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `undefined`
-         * checkWrap.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // returns `{a: 0, b: 1}`
+         * checkWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
+         * checkWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
          * ```
          *
          * @returns The parent value if the check passes, otherwise `undefined`.
@@ -551,7 +496,7 @@ export declare const keyGuards: {
          * - {@link checkWrap.hasKeys} : the opposite check.
          * - {@link checkWrap.lacksKey} : the single-key check.
          */
-        lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => Exclude<Parent, Partial<Record<Key, any>>> | undefined;
+        lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>): Exclude<Parent, Partial<Record<Key, any>>> | undefined;
     };
     waitUntil: {
         /**
@@ -575,7 +520,7 @@ export declare const keyGuards: {
          * @see
          * - {@link waitUntil.isNotKeyOf} : the opposite assertion.
          */
-        isKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Key, keyof Parent>>;
+        isKeyOf: <const Key extends PropertyKey, const Parent>(this: void, parent: Parent, callback: () => MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Key, keyof Parent>>;
         /**
          * Repeatedly calls a callback until its output is a key that is _not_ contained within the
          * first, parent value. Once the callback output passes, it is returned. If the attempts
@@ -597,7 +542,7 @@ export declare const keyGuards: {
          * @see
          * - {@link waitUntil.isNotKeyOf} : the opposite assertion.
          */
-        isNotKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Key, RequiredKeysOf<Parent>>>;
+        isNotKeyOf: <const Key extends PropertyKey, const Parent>(this: void, parent: Parent, callback: () => MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Key, RequiredKeysOf<Parent>>>;
         /**
          * Repeatedly calls a callback until its output is a parent value that has the first, key
          * input. Once the callback output passes, it is returned. If the attempts time out, an
@@ -624,7 +569,7 @@ export declare const keyGuards: {
          * - {@link waitUntil.lacksKey} : the opposite assertion.
          * - {@link waitUntil.hasKeys} : the multi-key assertion.
          */
-        hasKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<CombineTypeWithKey<Key, Parent>>;
+        hasKey: <const Parent, const Key extends PropertyKey>(this: void, key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<CombineTypeWithKey<Key, Parent>>;
         /**
          * Repeatedly calls a callback until its output is a parent value that does not have the
          * first, key input. Once the callback output passes, it is returned. If the attempts time
@@ -651,7 +596,7 @@ export declare const keyGuards: {
          * - {@link waitUntil.hasKey} : the opposite assertion.
          * - {@link waitUntil.lacksKeys} : the multi-key assertion.
          */
-        lacksKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Record<Key, any>>>;
+        lacksKey: <const Parent, const Key extends PropertyKey>(this: void, key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Record<Key, any>>>;
         /**
          * Repeatedly calls a callback until its output is a parent value that has all of the first,
          * keys input. Once the callback output passes, it is returned. If the attempts time out, an
@@ -664,24 +609,12 @@ export declare const keyGuards: {
          * ```ts
          * import {waitUntil} from '@augment-vir/assert';
          *
-         * await waitUntil.hasKeys(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // returns `{a: 0, b: 1}`
-         * await waitUntil.hasKeys(
-         *     [
-         *         'b',
-         *         'c',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // throws an error
+         * await waitUntil.hasKeys(['a', 'b'], () => {
+         *     return {a: 0, b: 1};
+         * }); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasKeys(['b', 'c'], () => {
+         *     return {a: 0, b: 1};
+         * }); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -690,7 +623,7 @@ export declare const keyGuards: {
          * - {@link waitUntil.lacksKeys} : the opposite assertion.
          * - {@link waitUntil.hasKey} : the single-key assertion.
          */
-        hasKeys: <const Keys extends PropertyKey, const Parent>(keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<CombineTypeWithKey<Keys, Parent>>;
+        hasKeys: <const Keys extends PropertyKey, const Parent>(this: void, keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<CombineTypeWithKey<Keys, Parent>>;
         /**
          * Repeatedly calls a callback until its output is a parent value that does not have any of
          * the first, keys input. Once the callback output passes, it is returned. If the attempts
@@ -703,24 +636,12 @@ export declare const keyGuards: {
          * ```ts
          * import {waitUntil} from '@augment-vir/assert';
          *
-         * await waitUntil.hasKeys(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // throws an error
-         * await waitUntil.hasKeys(
-         *     [
-         *         'b',
-         *         'c',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasKeys(['a', 'b'], () => {
+         *     return {a: 0, b: 1};
+         * }); // throws an error
+         * await waitUntil.hasKeys(['b', 'c'], () => {
+         *     return {a: 0, b: 1};
+         * }); // returns `{a: 0, b: 1}`
          * ```
          *
          * @returns The callback output once it passes.
@@ -729,7 +650,7 @@ export declare const keyGuards: {
          * - {@link waitUntil.hasKeys} : the opposite assertion.
          * - {@link waitUntil.lacksKey} : the single-key assertion.
          */
-        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>>>>;
+        lacksKeys: <const Parent, const Keys extends PropertyKey>(this: void, keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Partial<Record<Keys, any>>>>;
     };
 };
 export {};