@augment-vir/assert 30.0.4 → 30.1.0

package/dist/assertions/boolean.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise, NarrowToExpected } from '@augment-vir/core';
+import { type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 /**
  * All falsy values in JavaScript. This does not include `NaN` because there is no dedicated type
  * for it in TypeScript.

package/dist/assertions/boundary.d.ts

@@ -1,5 +1,5 @@
-import { MaybePromise } from '@augment-vir/core';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type MaybePromise } from '@augment-vir/core';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function endsWith<const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
 declare function endsWith(parent: string, child: string, failureMessage?: string | undefined): void;
 declare function endsWith(parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;

package/dist/assertions/enum.d.ts

@@ -1,6 +1,6 @@
 import type { NarrowToExpected } from '@augment-vir/core';
-import { EnumBaseType, MaybePromise } from '@augment-vir/core';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type EnumBaseType, type MaybePromise } from '@augment-vir/core';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 export declare function isEnumValue<const Expected extends EnumBaseType>(child: unknown, checkEnum: Expected, failureMessage?: string | undefined): asserts child is Expected[keyof Expected];
 declare function isNotEnumValue<const Actual, const Expected extends EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined): asserts child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
 export declare const enumGuards: {

package/dist/assertions/equality/entry-equality.d.ts

@@ -1,7 +1,7 @@
 import type { NarrowToExpected } from '@augment-vir/core';
-import { MaybePromise } from '@augment-vir/core';
+import { type MaybePromise } from '@augment-vir/core';
 import { autoGuardSymbol } from '../../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
 declare function entriesEqual<const Actual extends object, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined): asserts actual is Expected;
 declare function notEntriesEqual(actual: object, expected: object, failureMessage?: string | undefined): void;
 export declare const entryEqualityGuards: {

package/dist/assertions/equality/json-equality.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise, NarrowToExpected } from '@augment-vir/core';
+import { type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
 import { autoGuardSymbol } from '../../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
 declare function jsonEquals<const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined): asserts actual is Expected;
 declare function notJsonEquals(actual: unknown, expected: unknown, failureMessage?: string | undefined): void;
 export declare const jsonEqualityGuards: {

package/dist/assertions/equality/json-equality.js

@@ -1,4 +1,4 @@
-import { extractErrorMessage } from '@augment-vir/core';
+import { extractErrorMessage, } from '@augment-vir/core';
 import { AssertionError } from '../../augments/assertion.error.js';
 import { autoGuard, autoGuardSymbol } from '../../guard-types/guard-override.js';
 function baseJsonEquals(a, b) {

package/dist/assertions/equality/simple-equality.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise, NarrowToExpected } from '@augment-vir/core';
+import { type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
 import { autoGuardSymbol } from '../../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
 export declare function strictEquals<const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined): asserts actual is Expected;
 declare function notStrictEquals(actual: unknown, expected: unknown, failureMessage?: string | undefined): void;
 declare function looseEquals(actual: unknown, expected: unknown, failureMessage?: string | undefined): void;

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

@@ -1,4 +1,4 @@
-import { ExpectTypeOf } from 'expect-type';
+import { type ExpectTypeOf } from 'expect-type';
 type AssertTypeOf<TestingType> = {
     equals: ExpectTypeOf<TestingType, {
         positive: true;
@@ -6,6 +6,9 @@ type AssertTypeOf<TestingType> = {
     notEquals: ExpectTypeOf<TestingType, {
         positive: false;
     }>['toEqualTypeOf'];
+    slowEquals: ExpectTypeOf<TestingType, {
+        positive: true;
+    }>['branded']['toEqualTypeOf'];
     matches: ExpectTypeOf<TestingType, {
         positive: true;
     }>['toMatchTypeOf'];
@@ -20,22 +23,6 @@ input: Actual): AssertTypeOf<Actual>;
 declare function tsType<Actual>(): AssertTypeOf<Actual>;
 export declare const tsTypeGuards: {
     assert: {
-        /**
-         * Check if a value or type matches type expectations. Use this to write type tests.
-         *
-         * This should not be used in production code. It won't cause any issues there, but it also
-         * provides no value there.
-         *
-         * Performs no type guarding.
-         *
-         * @example
-         *
-         * ```ts
-         * import {assert} from '@augment-vir/assert';
-         *
-         * assert.tsType('hello').equals<string>();
-         * ```
-         */
         /**
          * Asserts within the TypeScript type system that a given type or value matches type
          * expectations (using the [`expect-type`](https://www.npmjs.com/package/expect-type) package.

package/dist/assertions/equality/ts-type-equality.js

@@ -8,6 +8,7 @@ input) {
         notEquals: () => { },
         matches: () => { },
         notMatches: () => { },
+        slowEquals: () => { },
     };
 }
 const assertions = {