@augment-vir/assert 31.47.0 → 31.49.0

package/dist/assertions/runtime-type.d.ts

@@ -95,7 +95,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNotNull} : the opposite assertion.
          */
         isNull(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is null;
         /**
@@ -114,7 +114,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNotNumber} : the opposite assertion.
          */
         isNumber(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is number;
         /**
@@ -133,9 +133,33 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNotObject} : the opposite assertion.
          */
         isObject(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is UnknownObject;
+        /**
+         * Asserts that a value is a plain object. This excludes arrays and class instances.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isPlainObject({}); // passes
+         * assert.isPlainObject({value: 'key'}); // passes
+         * assert.isPlainObject(null); // fails
+         * assert.isPlainObject(new RegExp()); // fails
+         * assert.isPlainObject(new Date()); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link assert.isNotPlainObject} : the opposite assertion.
+         * - {@link assert.isObject} : a more generic object assertion.
+         */
+        isPlainObject(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is UnknownObject;
         /**
          * Asserts that a value is a string.
          *
@@ -152,7 +176,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNotString} : the opposite assertion.
          */
         isString(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is string;
         /**
@@ -171,7 +195,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNotSymbol} : the opposite assertion.
          */
         isSymbol(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is symbol;
         /**
@@ -190,7 +214,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNotUndefined} : the opposite assertion.
          */
         isUndefined(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is undefined;
         /**
@@ -304,7 +328,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assert.isNotFunction} : the opposite assertion.
+         * - {@link assert.isNumber} : the opposite assertion.
          */
         isNotNumber<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, number>;
         /**
@@ -326,6 +350,27 @@ export declare const runtimeTypeGuards: {
          * - {@link assert.isFunction} : the opposite assertion.
          */
         isNotObject<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, UnknownObject>;
+        /**
+         * Asserts that a value is not a plain object. This includes arrays and class instances.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isNotPlainObject({}); // fails
+         * assert.isNotPlainObject({value: 'key'}); // fails
+         * assert.isNotPlainObject(null); // passes
+         * assert.isNotPlainObject(new RegExp()); // passes
+         * assert.isNotPlainObject(new Date()); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link assert.isPlainObject} : the opposite assertion.
+         * - {@link assert.isNotObject} : a more generic non-object assertion.
+         */
+        isNotPlainObject(this: void, actual: unknown, failureMessage?: string | undefined): void;
         /**
          * Asserts that a value is _not_ a string.
          *
@@ -472,7 +517,7 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotNull} : the opposite check.
          */
         isNull<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, null>;
         /**
@@ -490,7 +535,7 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotNumber} : the opposite check.
          */
         isNumber<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, number>;
         /**
@@ -508,9 +553,32 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotObject} : the opposite check.
          */
         isObject<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, UnknownObject>;
+        /**
+         * Checks that a value is a plain object. This excludes arrays and class instances.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isPlainObject({}); // returns `true`
+         * check.isPlainObject({value: 'key'}); // returns `true`
+         * check.isPlainObject(null); // returns `false`
+         * check.isPlainObject(new RegExp()); // returns `false`
+         * check.isPlainObject(new Date()); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isNotPlainObject} : the opposite check.
+         * - {@link check.isObject} : a more generic object check.
+         */
+        isPlainObject<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, UnknownObject>;
         /**
          * Checks that a value is a string.
          *
@@ -526,7 +594,7 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotString} : the opposite check.
          */
         isString<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, string>;
         /**
@@ -544,7 +612,7 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotSymbol} : the opposite check.
          */
         isSymbol<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, symbol>;
         /**
@@ -562,7 +630,7 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotUndefined} : the opposite check.
          */
         isUndefined<Actual>(this: void, actual: Actual): actual is NarrowToActual<Actual, undefined>;
         /**
@@ -670,7 +738,7 @@ export declare const runtimeTypeGuards: {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNumber} : the opposite check.
          */
         isNotNumber<Actual>(this: void, actual: Actual): actual is Exclude<Actual, number>;
         /**
@@ -691,6 +759,26 @@ export declare const runtimeTypeGuards: {
          * - {@link check.isFunction} : the opposite check.
          */
         isNotObject<Actual>(this: void, actual: Actual): actual is Exclude<Actual, UnknownObject>;
+        /**
+         * Checks that a value is not a plain object. This includes arrays and class instances.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * check.isNotPlainObject({}); // returns `false`
+         * check.isNotPlainObject({value: 'key'}); // returns `false`
+         * check.isNotPlainObject(null); // returns `true`
+         * check.isNotPlainObject(new RegExp()); // returns `true`
+         * check.isNotPlainObject(new Date()); // returns `true`
+         * ```
+         *
+         * @see
+         * - {@link check.isPlainObject} : the opposite check.
+         * - {@link check.isNotObject} : a more generic non-object check.
+         */
+        isNotPlainObject(this: void, actual: unknown): boolean;
         /**
          * Checks that a value is _not_ a string.
          *
@@ -844,7 +932,7 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotNull} : the opposite assertion.
          */
         isNull<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, null>;
         /**
@@ -865,7 +953,7 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotNumber} : the opposite assertion.
          */
         isNumber<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, number>;
         /**
@@ -886,9 +974,34 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotObject} : the opposite assertion.
          */
         isObject<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, UnknownObject>;
+        /**
+         * Asserts that a value is a plain object. This excludes arrays and class instances. Returns
+         * the value if the assertion passes.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isPlainObject({}); // returns `{}`
+         * assertWrap.isPlainObject({value: 'key'}); // returns `{value: 'key'}`
+         * assertWrap.isPlainObject(null); // throws an error
+         * assertWrap.isPlainObject(new RegExp()); // throws an error
+         * assertWrap.isPlainObject(new Date()); // throws an error
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link assertWrap.isNotPlainObject} : the opposite assertion.
+         * - {@link assertWrap.isObject} : a more generic object assertion.
+         */
+        isPlainObject<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, UnknownObject>;
         /**
          * Asserts that a value is a string. Returns the value if the assertion passes.
          *
@@ -906,7 +1019,7 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotString} : the opposite assertion.
          */
         isString<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, string>;
         /**
@@ -935,7 +1048,7 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotSymbol} : the opposite assertion.
          */
         isSymbol<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, symbol>;
         /**
@@ -955,7 +1068,7 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotUndefined} : the opposite assertion.
          */
         isUndefined<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, undefined>;
         /**
@@ -1076,7 +1189,7 @@ export declare const runtimeTypeGuards: {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNumber} : the opposite assertion.
          */
         isNotNumber<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): Exclude<Actual, number>;
         /**
@@ -1100,6 +1213,31 @@ export declare const runtimeTypeGuards: {
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
         isNotObject<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): Exclude<Actual, UnknownObject>;
+        /**
+         * Asserts that a value is a not plain object. This includes arrays and class instances.
+         * Returns the value if the assertion passes.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isNotPlainObject({}); // throws an error
+         * assertWrap.isNotPlainObject({value: 'key'}); // throws an error
+         * assertWrap.isNotPlainObject(null); // returns `null`
+         * assertWrap.isNotPlainObject(new RegExp()); // returns the RegExp instance
+         * assertWrap.isNotPlainObject(new Date()); // returns the Date instance
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link assertWrap.isPlainObject} : the opposite assertion.
+         * - {@link assertWrap.isObject} : a more generic non-object assertion.
+         */
+        isNotPlainObject(this: void, actual: unknown, failureMessage?: string | undefined): unknown;
         /**
          * Asserts that a value is _not_ a string. Returns the value if the assertion passes.
          *
@@ -1260,7 +1398,7 @@ export declare const runtimeTypeGuards: {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotNull} : the opposite check.
          */
         isNull<Actual>(this: void, actual: Actual): NarrowToActual<Actual, null> | undefined;
         /**
@@ -1280,7 +1418,7 @@ export declare const runtimeTypeGuards: {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotNumber} : the opposite check.
          */
         isNumber<Actual>(this: void, actual: Actual): NarrowToActual<Actual, number> | undefined;
         /**
@@ -1300,9 +1438,34 @@ export declare const runtimeTypeGuards: {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotObject} : the opposite check.
          */
         isObject<Actual>(this: void, actual: Actual): NarrowToActual<Actual, UnknownObject> | undefined;
+        /**
+         * Checks that a value is a plain object. This excludes arrays and class instances. Returns
+         * the value if the check passes, otherwise `undefined`.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isPlainObject({}); // returns `{}`
+         * checkWrap.isPlainObject({value: 'key'}); // returns `{value: 'key'}`
+         * checkWrap.isPlainObject(null); // returns `undefined`
+         * checkWrap.isPlainObject(new RegExp()); // returns `undefined`
+         * checkWrap.isPlainObject(new Date()); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes. Otherwise, `undefined`.
+         * @see
+         * - {@link checkWrap.isNotPlainObject} : the opposite check.
+         * - {@link checkWrap.isObject} : a more generic object check.
+         */
+        isPlainObject<Actual>(this: void, actual: Actual): NarrowToActual<Actual, UnknownObject> | undefined;
         /**
          * Checks that a value is a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1320,7 +1483,7 @@ export declare const runtimeTypeGuards: {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotString} : the opposite check.
          */
         isString<Actual>(this: void, actual: Actual): NarrowToActual<Actual, string> | undefined;
         /**
@@ -1340,7 +1503,7 @@ export declare const runtimeTypeGuards: {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotSymbol} : the opposite check.
          */
         isSymbol<Actual>(this: void, actual: Actual): NarrowToActual<Actual, symbol> | undefined;
         /**
@@ -1460,7 +1623,7 @@ export declare const runtimeTypeGuards: {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNumber} : the opposite check.
          */
         isNotNumber<Actual>(this: void, actual: Actual): Exclude<Actual, number> | undefined;
         /**
@@ -1483,6 +1646,31 @@ export declare const runtimeTypeGuards: {
          * - {@link checkWrap.isFunction} : the opposite check.
          */
         isNotObject<Actual>(this: void, actual: Actual): Exclude<Actual, UnknownObject> | undefined;
+        /**
+         * Checks that a value is not a plain object. This includes arrays and class instances.
+         * Returns the value if the check passes, otherwise `undefined`.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isNotPlainObject({}); // returns `undefined`
+         * checkWrap.isNotPlainObject({value: 'key'}); // returns `undefined`
+         * checkWrap.isNotPlainObject(null); // returns `null`
+         * checkWrap.isNotPlainObject(new RegExp()); // returns the RegExp instance
+         * checkWrap.isNotPlainObject(new Date()); // returns the Date instance
+         * ```
+         *
+         * @returns The value if the check passes. Otherwise, `undefined`.
+         * @see
+         * - {@link checkWrap.isPlainObject} : the opposite check.
+         * - {@link checkWrap.isNotObject} : a more generic non-object check.
+         */
+        isNotPlainObject(this: void, actual: unknown): unknown;
         /**
          * Checks that a value is _not_ a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1628,7 +1816,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotNull} : the opposite assertion.
          */
         isNull: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, null>>;
         /**
@@ -1648,7 +1836,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotNumber} : the opposite assertion.
          */
         isNumber: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, number>>;
         /**
@@ -1670,9 +1858,35 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotObject} : the opposite assertion.
          */
         isObject: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, UnknownObject>>;
+        /**
+         * Repeatedly calls a callback until its output is a plain object. This excludes arrays and
+         * class instances. Once the callback output passes, it is returned. If the attempts time
+         * out, an error is thrown.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isPlainObject({}); // returns `{}`
+         * waitUntil.isPlainObject({value: 'key'}); // returns `{value: 'key'}`
+         * waitUntil.isPlainObject(null); // throws an error
+         * waitUntil.isPlainObject(new RegExp()); // throws an error
+         * waitUntil.isPlainObject(new Date()); // throws an error
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link waitUntil.isNotPlainObject} : the opposite assertion.
+         * - {@link waitUntil.isObject} : a more generic object assertion.
+         */
+        isPlainObject: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, UnknownObject>>;
         /**
          * Repeatedly calls a callback until its output is a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1690,7 +1904,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotString} : the opposite assertion.
          */
         isString: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, string>>;
         /**
@@ -1710,7 +1924,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotSymbol} : the opposite assertion.
          */
         isSymbol: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, symbol>>;
         /**
@@ -1730,7 +1944,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotUndefined} : the opposite assertion.
          */
         isUndefined: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, undefined>>;
         /**
@@ -1857,7 +2071,7 @@ export declare const runtimeTypeGuards: {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNumber} : the opposite assertion.
          */
         isNotNumber: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, number>>;
         /**
@@ -1883,6 +2097,32 @@ export declare const runtimeTypeGuards: {
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
         isNotObject: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, UnknownObject>>;
+        /**
+         * Repeatedly calls a callback until its output is not a plain object. This includes arrays
+         * and class instances. Once the callback output passes, it is returned. If the attempts
+         * time out, an error is thrown.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isNotPlainObject({}); // throws an error
+         * waitUntil.isNotPlainObject({value: 'key'}); // throws an error
+         * waitUntil.isNotPlainObject(null); // returns `null`
+         * waitUntil.isNotPlainObject(new RegExp()); // returns the RegExp instance
+         * waitUntil.isNotPlainObject(new Date()); // returns the Date instance
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link waitUntil.isPlainObject} : the opposite assertion.
+         * - {@link waitUntil.isNotObject} : a more generic non-object assertion.
+         */
+        isNotPlainObject: <Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, UnknownObject>>;
         /**
          * Repeatedly calls a callback until its output is _not_ a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.

package/dist/assertions/runtime-type.js

@@ -110,7 +110,7 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNotNull} : the opposite assertion.
      */
     isNull(actual, failureMessage) {
         if (actual !== null) {
@@ -133,7 +133,7 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNotNumber} : the opposite assertion.
      */
     isNumber(actual, failureMessage) {
         if (typeof actual !== 'number' || isNaN(actual)) {
@@ -156,13 +156,48 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNotObject} : the opposite assertion.
      */
     isObject(actual, failureMessage) {
         if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
             throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
         }
     },
+    /**
+     * Asserts that a value is a plain object. This excludes arrays and class instances.
+     *
+     * Type guards the value but does not exclude class instances from the type guard (because
+     * that's impossible).
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isPlainObject({}); // passes
+     * assert.isPlainObject({value: 'key'}); // passes
+     * assert.isPlainObject(null); // fails
+     * assert.isPlainObject(new RegExp()); // fails
+     * assert.isPlainObject(new Date()); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotPlainObject} : the opposite assertion.
+     * - {@link assert.isObject} : a more generic object assertion.
+     */
+    isPlainObject(actual, failureMessage) {
+        const prototype = Object.getPrototypeOf(actual);
+        if (typeof actual !== 'object' ||
+            actual == undefined ||
+            !((prototype == undefined ||
+                prototype === Object.prototype ||
+                Object.getPrototypeOf(prototype) == undefined) &&
+                !(Symbol.toStringTag in actual) &&
+                !(Symbol.iterator in actual))) {
+            throw new AssertionError(`'${stringify(actual)}' is not a plain object.`, failureMessage);
+        }
+    },
     /**
      * Asserts that a value is a string.
      *
@@ -179,7 +214,7 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNotString} : the opposite assertion.
      */
     isString(actual, failureMessage) {
         if (typeof actual !== 'string') {
@@ -202,7 +237,7 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNotSymbol} : the opposite assertion.
      */
     isSymbol(actual, failureMessage) {
         if (typeof actual !== 'symbol') {
@@ -225,7 +260,7 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNotUndefined} : the opposite assertion.
      */
     isUndefined(actual, failureMessage) {
         if (typeof actual !== 'undefined') {
@@ -363,7 +398,7 @@ const assertions = {
      *
      * @throws {@link AssertionError} If the assertion failed.
      * @see
-     * - {@link assert.isNotFunction} : the opposite assertion.
+     * - {@link assert.isNumber} : the opposite assertion.
      */
     isNotNumber(actual, failureMessage) {
         if (typeof actual === 'number') {
@@ -393,6 +428,39 @@ const assertions = {
             throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
         }
     },
+    /**
+     * Asserts that a value is not a plain object. This includes arrays and class instances.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotPlainObject({}); // fails
+     * assert.isNotPlainObject({value: 'key'}); // fails
+     * assert.isNotPlainObject(null); // passes
+     * assert.isNotPlainObject(new RegExp()); // passes
+     * assert.isNotPlainObject(new Date()); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isPlainObject} : the opposite assertion.
+     * - {@link assert.isNotObject} : a more generic non-object assertion.
+     */
+    isNotPlainObject(actual, failureMessage) {
+        const prototype = Object.getPrototypeOf(actual);
+        if (typeof actual !== 'object' ||
+            actual == undefined ||
+            !((prototype == undefined ||
+                prototype === Object.prototype ||
+                Object.getPrototypeOf(prototype) == undefined) &&
+                !(Symbol.toStringTag in actual) &&
+                !(Symbol.iterator in actual))) {
+            return;
+        }
+        throw new AssertionError(`'${stringify(actual)}' is a plain object.`, failureMessage);
+    },
     /**
      * Asserts that a value is _not_ a string.
      *
@@ -561,7 +629,7 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotNull} : the opposite check.
          */
         isNull(actual) {
             return actual === null;
@@ -581,7 +649,7 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotNumber} : the opposite check.
          */
         isNumber(actual) {
             return typeof actual === 'number';
@@ -601,11 +669,44 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotObject} : the opposite check.
          */
         isObject(actual) {
             return !Array.isArray(actual) && typeof actual === 'object' && !!actual;
         },
+        /**
+         * Checks that a value is a plain object. This excludes arrays and class instances.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isPlainObject({}); // returns `true`
+         * check.isPlainObject({value: 'key'}); // returns `true`
+         * check.isPlainObject(null); // returns `false`
+         * check.isPlainObject(new RegExp()); // returns `false`
+         * check.isPlainObject(new Date()); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isNotPlainObject} : the opposite check.
+         * - {@link check.isObject} : a more generic object check.
+         */
+        isPlainObject(actual) {
+            if (typeof actual !== 'object' || actual == undefined) {
+                return false;
+            }
+            const prototype = Object.getPrototypeOf(actual);
+            return ((prototype == undefined ||
+                prototype === Object.prototype ||
+                Object.getPrototypeOf(prototype) == undefined) &&
+                !(Symbol.toStringTag in actual) &&
+                !(Symbol.iterator in actual));
+        },
         /**
          * Checks that a value is a string.
          *
@@ -621,7 +722,7 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotString} : the opposite check.
          */
         isString(actual) {
             return typeof actual === 'string';
@@ -641,7 +742,7 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotSymbol} : the opposite check.
          */
         isSymbol(actual) {
             return typeof actual === 'symbol';
@@ -661,7 +762,7 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNotUndefined} : the opposite check.
          */
         isUndefined(actual) {
             return actual === undefined;
@@ -781,7 +882,7 @@ export const runtimeTypeGuards = {
          * ```
          *
          * @see
-         * - {@link check.isNotFunction} : the opposite check.
+         * - {@link check.isNumber} : the opposite check.
          */
         isNotNumber(actual) {
             return typeof actual !== 'number';
@@ -806,6 +907,36 @@ export const runtimeTypeGuards = {
         isNotObject(actual) {
             return Array.isArray(actual) || typeof actual !== 'object' || !actual;
         },
+        /**
+         * Checks that a value is not a plain object. This includes arrays and class instances.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * check.isNotPlainObject({}); // returns `false`
+         * check.isNotPlainObject({value: 'key'}); // returns `false`
+         * check.isNotPlainObject(null); // returns `true`
+         * check.isNotPlainObject(new RegExp()); // returns `true`
+         * check.isNotPlainObject(new Date()); // returns `true`
+         * ```
+         *
+         * @see
+         * - {@link check.isPlainObject} : the opposite check.
+         * - {@link check.isNotObject} : a more generic non-object check.
+         */
+        isNotPlainObject(actual) {
+            if (typeof actual !== 'object' || actual == undefined) {
+                return true;
+            }
+            const prototype = Object.getPrototypeOf(actual);
+            return !((prototype == undefined ||
+                prototype === Object.prototype ||
+                Object.getPrototypeOf(prototype) == undefined) &&
+                !(Symbol.toStringTag in actual) &&
+                !(Symbol.iterator in actual));
+        },
         /**
          * Checks that a value is _not_ a string.
          *
@@ -985,7 +1116,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotNull} : the opposite assertion.
          */
         isNull(actual, failureMessage) {
             if (actual !== null) {
@@ -1011,7 +1142,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotNumber} : the opposite assertion.
          */
         isNumber(actual, failureMessage) {
             if (typeof actual !== 'number' || isNaN(actual)) {
@@ -1037,7 +1168,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotObject} : the opposite assertion.
          */
         isObject(actual, failureMessage) {
             if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
@@ -1045,6 +1176,43 @@ export const runtimeTypeGuards = {
             }
             return actual;
         },
+        /**
+         * Asserts that a value is a plain object. This excludes arrays and class instances. Returns
+         * the value if the assertion passes.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isPlainObject({}); // returns `{}`
+         * assertWrap.isPlainObject({value: 'key'}); // returns `{value: 'key'}`
+         * assertWrap.isPlainObject(null); // throws an error
+         * assertWrap.isPlainObject(new RegExp()); // throws an error
+         * assertWrap.isPlainObject(new Date()); // throws an error
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link assertWrap.isNotPlainObject} : the opposite assertion.
+         * - {@link assertWrap.isObject} : a more generic object assertion.
+         */
+        isPlainObject(actual, failureMessage) {
+            const prototype = Object.getPrototypeOf(actual);
+            if (typeof actual !== 'object' ||
+                actual == undefined ||
+                !((prototype == undefined ||
+                    prototype === Object.prototype ||
+                    Object.getPrototypeOf(prototype) == undefined) &&
+                    !(Symbol.toStringTag in actual) &&
+                    !(Symbol.iterator in actual))) {
+                throw new AssertionError(`'${stringify(actual)}' is not a plain object.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a string. Returns the value if the assertion passes.
          *
@@ -1062,7 +1230,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotString} : the opposite assertion.
          */
         isString(actual, failureMessage) {
             if (typeof actual !== 'string') {
@@ -1096,7 +1264,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotSymbol} : the opposite assertion.
          */
         isSymbol(actual, failureMessage) {
             if (typeof actual !== 'symbol') {
@@ -1121,7 +1289,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNotUndefined} : the opposite assertion.
          */
         isUndefined(actual, failureMessage) {
             if (typeof actual !== 'undefined') {
@@ -1272,7 +1440,7 @@ export const runtimeTypeGuards = {
          * @returns The value if the assertion passes.
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link assertWrap.isNotFunction} : the opposite assertion.
+         * - {@link assertWrap.isNumber} : the opposite assertion.
          */
         isNotNumber(actual, failureMessage) {
             if (typeof actual === 'number') {
@@ -1306,6 +1474,43 @@ export const runtimeTypeGuards = {
             }
             return actual;
         },
+        /**
+         * Asserts that a value is a not plain object. This includes arrays and class instances.
+         * Returns the value if the assertion passes.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isNotPlainObject({}); // throws an error
+         * assertWrap.isNotPlainObject({value: 'key'}); // throws an error
+         * assertWrap.isNotPlainObject(null); // returns `null`
+         * assertWrap.isNotPlainObject(new RegExp()); // returns the RegExp instance
+         * assertWrap.isNotPlainObject(new Date()); // returns the Date instance
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link assertWrap.isPlainObject} : the opposite assertion.
+         * - {@link assertWrap.isObject} : a more generic non-object assertion.
+         */
+        isNotPlainObject(actual, failureMessage) {
+            const prototype = Object.getPrototypeOf(actual);
+            if (typeof actual !== 'object' ||
+                actual == undefined ||
+                !((prototype == undefined ||
+                    prototype === Object.prototype ||
+                    Object.getPrototypeOf(prototype) == undefined) &&
+                    !(Symbol.toStringTag in actual) &&
+                    !(Symbol.iterator in actual))) {
+                return actual;
+            }
+            throw new AssertionError(`'${stringify(actual)}' is a plain object.`, failureMessage);
+        },
         /**
          * Asserts that a value is _not_ a string. Returns the value if the assertion passes.
          *
@@ -1509,7 +1714,7 @@ export const runtimeTypeGuards = {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotNull} : the opposite check.
          */
         isNull(actual) {
             if (actual === null) {
@@ -1536,7 +1741,7 @@ export const runtimeTypeGuards = {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotNumber} : the opposite check.
          */
         isNumber(actual) {
             if (typeof actual === 'number') {
@@ -1563,7 +1768,7 @@ export const runtimeTypeGuards = {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotObject} : the opposite check.
          */
         isObject(actual) {
             if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
@@ -1573,6 +1778,46 @@ export const runtimeTypeGuards = {
                 return undefined;
             }
         },
+        /**
+         * Checks that a value is a plain object. This excludes arrays and class instances. Returns
+         * the value if the check passes, otherwise `undefined`.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isPlainObject({}); // returns `{}`
+         * checkWrap.isPlainObject({value: 'key'}); // returns `{value: 'key'}`
+         * checkWrap.isPlainObject(null); // returns `undefined`
+         * checkWrap.isPlainObject(new RegExp()); // returns `undefined`
+         * checkWrap.isPlainObject(new Date()); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes. Otherwise, `undefined`.
+         * @see
+         * - {@link checkWrap.isNotPlainObject} : the opposite check.
+         * - {@link checkWrap.isObject} : a more generic object check.
+         */
+        isPlainObject(actual) {
+            if (typeof actual !== 'object' || actual == undefined) {
+                return undefined;
+            }
+            const prototype = Object.getPrototypeOf(actual);
+            if ((prototype == undefined ||
+                prototype === Object.prototype ||
+                Object.getPrototypeOf(prototype) == undefined) &&
+                !(Symbol.toStringTag in actual) &&
+                !(Symbol.iterator in actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1590,7 +1835,7 @@ export const runtimeTypeGuards = {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotString} : the opposite check.
          */
         isString(actual) {
             if (typeof actual === 'string') {
@@ -1617,7 +1862,7 @@ export const runtimeTypeGuards = {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNotSymbol} : the opposite check.
          */
         isSymbol(actual) {
             if (typeof actual === 'symbol') {
@@ -1779,7 +2024,7 @@ export const runtimeTypeGuards = {
          *
          * @returns The value if the check passes. Otherwise, `undefined`.
          * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
+         * - {@link checkWrap.isNumber} : the opposite check.
          */
         isNotNumber(actual) {
             if (typeof actual === 'number') {
@@ -1816,6 +2061,46 @@ export const runtimeTypeGuards = {
                 return undefined;
             }
         },
+        /**
+         * Checks that a value is not a plain object. This includes arrays and class instances.
+         * Returns the value if the check passes, otherwise `undefined`.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isNotPlainObject({}); // returns `undefined`
+         * checkWrap.isNotPlainObject({value: 'key'}); // returns `undefined`
+         * checkWrap.isNotPlainObject(null); // returns `null`
+         * checkWrap.isNotPlainObject(new RegExp()); // returns the RegExp instance
+         * checkWrap.isNotPlainObject(new Date()); // returns the Date instance
+         * ```
+         *
+         * @returns The value if the check passes. Otherwise, `undefined`.
+         * @see
+         * - {@link checkWrap.isPlainObject} : the opposite check.
+         * - {@link checkWrap.isNotObject} : a more generic non-object check.
+         */
+        isNotPlainObject(actual) {
+            if (typeof actual !== 'object' || actual == undefined) {
+                return actual;
+            }
+            const prototype = Object.getPrototypeOf(actual);
+            if ((prototype == undefined ||
+                prototype === Object.prototype ||
+                Object.getPrototypeOf(prototype) == undefined) &&
+                !(Symbol.toStringTag in actual) &&
+                !(Symbol.iterator in actual)) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1975,7 +2260,7 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotNull} : the opposite assertion.
          */
         isNull: createWaitUntil(assertions.isNull),
         /**
@@ -1995,7 +2280,7 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotNumber} : the opposite assertion.
          */
         isNumber: createWaitUntil(assertions.isNumber),
         /**
@@ -2017,9 +2302,35 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotObject} : the opposite assertion.
          */
         isObject: createWaitUntil(assertions.isObject),
+        /**
+         * Repeatedly calls a callback until its output is a plain object. This excludes arrays and
+         * class instances. Once the callback output passes, it is returned. If the attempts time
+         * out, an error is thrown.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isPlainObject({}); // returns `{}`
+         * waitUntil.isPlainObject({value: 'key'}); // returns `{value: 'key'}`
+         * waitUntil.isPlainObject(null); // throws an error
+         * waitUntil.isPlainObject(new RegExp()); // throws an error
+         * waitUntil.isPlainObject(new Date()); // throws an error
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link waitUntil.isNotPlainObject} : the opposite assertion.
+         * - {@link waitUntil.isObject} : a more generic object assertion.
+         */
+        isPlainObject: createWaitUntil(assertions.isPlainObject),
         /**
          * Repeatedly calls a callback until its output is a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -2037,7 +2348,7 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotString} : the opposite assertion.
          */
         isString: createWaitUntil(assertions.isString),
         /**
@@ -2057,7 +2368,7 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotSymbol} : the opposite assertion.
          */
         isSymbol: createWaitUntil(assertions.isSymbol),
         /**
@@ -2077,7 +2388,7 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNotUndefined} : the opposite assertion.
          */
         isUndefined: createWaitUntil(assertions.isUndefined),
         /**
@@ -2204,7 +2515,7 @@ export const runtimeTypeGuards = {
          *
          * @throws {@link AssertionError} If the assertion failed.
          * @see
-         * - {@link waitUntil.isNotFunction} : the opposite assertion.
+         * - {@link waitUntil.isNumber} : the opposite assertion.
          */
         isNotNumber: createWaitUntil(assertions.isNotNumber),
         /**
@@ -2230,6 +2541,32 @@ export const runtimeTypeGuards = {
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
         isNotObject: createWaitUntil(assertions.isNotObject),
+        /**
+         * Repeatedly calls a callback until its output is not a plain object. This includes arrays
+         * and class instances. Once the callback output passes, it is returned. If the attempts
+         * time out, an error is thrown.
+         *
+         * Type guards the value but does not exclude class instances from the type guard (because
+         * that's impossible).
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isNotPlainObject({}); // throws an error
+         * waitUntil.isNotPlainObject({value: 'key'}); // throws an error
+         * waitUntil.isNotPlainObject(null); // returns `null`
+         * waitUntil.isNotPlainObject(new RegExp()); // returns the RegExp instance
+         * waitUntil.isNotPlainObject(new Date()); // returns the Date instance
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion failed.
+         * @see
+         * - {@link waitUntil.isPlainObject} : the opposite assertion.
+         * - {@link waitUntil.isNotObject} : a more generic non-object assertion.
+         */
+        isNotPlainObject: createWaitUntil(assertions.isNotPlainObject),
         /**
          * Repeatedly calls a callback until its output is _not_ a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/assert",
-    "version": "31.47.0",
+    "version": "31.49.0",
     "description": "A collection of assertions for test and production code alike.",
     "keywords": [
         "augment",
@@ -42,11 +42,11 @@
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/core": "^31.47.0",
+        "@augment-vir/core": "^31.49.0",
         "@date-vir/duration": "^8.0.0",
         "deep-eql": "^5.0.2",
         "expect-type": "^1.2.2",
-        "type-fest": "^5.1.0"
+        "type-fest": "^5.2.0"
     },
     "devDependencies": {
         "@types/deep-eql": "^4.0.2",