type-plus 8.0.0-beta.2 → 8.0.0-beta.4

package/cjs/string/string.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=string.js.map

package/cjs/string/string.js.map

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

package/cjs/string/string_plus.d.ts

@@ -0,0 +1,27 @@
+import type { StringIncludes, StringSplit } from './string.js';
+export declare namespace StringPlus {
+    /**
+     * Check if `Subject` includes `Search`.
+     * If either of them is not a string, returns `Else`.
+     *
+     * ```ts
+     * type R = StringPlus.Includes<'abc', 'a'> // true
+     *
+     * type R = StringPlus.Includes<'abc', 'd'> // false
+     * ```
+     */
+    type Includes<Subject extends string, Search extends string, Then = true, Else = false> = StringIncludes<Subject, Search, Then, Else>;
+    /**
+     * Split a string into substrings using the specified separator,
+     * and return them as an array.
+     *
+     * ```ts
+     * type R = StringPlus.Split<'abc', ''> // ['a', 'b', 'c']
+     * type R = StringPlus.Split<'abc', 'a'> // ['', 'bc']
+     * type R = StringPlus.Split<'abc', 'b'> // ['a', 'c']
+     * type R = StringPlus.Split<'abc', 'c'> // ['ab', '']
+     * ```
+     */
+    type Split<Subject extends string, Seperator extends string> = StringSplit<Subject, Seperator>;
+}
+//# sourceMappingURL=string_plus.d.ts.map

package/cjs/string/string_plus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_plus.d.ts","sourceRoot":"","sources":["../../src/string/string_plus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9D,yBAAiB,UAAU,CAAC;IAC3B;;;;;;;;;OASG;IACH,KAAY,QAAQ,CAAC,OAAO,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,cAAc,CAC9G,OAAO,EACP,MAAM,EACN,IAAI,EACJ,IAAI,CACJ,CAAA;IAED;;;;;;;;;;OAUG;IACH,KAAY,KAAK,CAAC,OAAO,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM,IAAI,WAAW,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;CACrG"}

package/cjs/string/string_plus.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=string_plus.js.map

package/cjs/string/string_plus.js.map

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

package/cjs/symbol/is_not_symbol.d.ts

@@ -0,0 +1,71 @@
+import type { NotAssignable } from '../predicates/not_assignable.js';
+import type { $Equality } from '../type_plus/$equality.js';
+import type { $MergeOptions } from '../type_plus/$merge_options.js';
+import type { $SpecialType } from '../type_plus/$special_type.js';
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js';
+import type { $Then } from '../type_plus/branch/$selection.js';
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not `symbol`.
+ *
+ * ```ts
+ * type R = IsNotSymbol<symbol> // false
+ *
+ * type R = IsNotSymbol<never> // true
+ * type R = IsNotSymbol<unknown> // true
+ * type R = IsNotSymbol<string | boolean> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not `symbol`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotSymbol<symbol, { selection: 'filter' }> // never
+ *
+ * type R = IsNotSymbol<never, { selection: 'filter' }> // never
+ * type R = IsNotSymbol<unknown, { selection: 'filter' }> // unknown
+ * type R = IsNotSymbol<symbol | string, { selection: 'filter' }> // string
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Disable distribution of union types.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotSymbol<symbol | 1> // boolean
+ * type R = IsNotSymbol<symbol | 1, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotSymbol<string, $SelectionBranch> // $Then
+ * type R = IsNotSymbol<symbol, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsNotSymbol<T, $O extends IsNotSymbol.$Options = {}> = $SpecialType<T, $MergeOptions<$O, {
+    $then: $ResolveBranch<T, $O, [$Then]>;
+    $else: IsNotSymbol.$<T, $O>;
+}>>;
+export declare namespace IsNotSymbol {
+    type $Options = $Equality.$Options;
+    type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>;
+    /**
+     * 🧰 *type util*
+     *
+     * Validate if `T` is `null`.
+     *
+     * This is a type util for building custom types.
+     * It does not check against special types.
+     */
+    type $<T, $O extends $UtilOptions> = NotAssignable.$<T, symbol, $O>;
+    type $UtilOptions = NotAssignable.$UtilOptions;
+}
+//# sourceMappingURL=is_not_symbol.d.ts.map

package/cjs/symbol/is_not_symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_not_symbol.d.ts","sourceRoot":"","sources":["../../src/symbol/is_not_symbol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,EAAE,SAAS,WAAW,CAAC,QAAQ,GAAG,EAAE,IAAI,YAAY,CAC9E,CAAC,EACD,aAAa,CACZ,EAAE,EACF;IACC,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IACrC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;CAC3B,CACD,CACD,CAAA;AAED,yBAAiB,WAAW,CAAC;IAC5B,KAAY,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAA;IACzC,KAAY,OAAO,CAAC,EAAE,SAAS,QAAQ,GAAG,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAErE;;;;;;;OAOG;IACH,KAAY,CAAC,CAAC,CAAC,EAAE,EAAE,SAAS,YAAY,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,CAAA;IAE1E,KAAY,YAAY,GAAG,aAAa,CAAC,YAAY,CAAA;CACrD"}

package/cjs/symbol/is_not_symbol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is_not_symbol.js.map

package/cjs/symbol/is_not_symbol.js.map

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

package/cjs/symbol/is_symbol.d.ts

@@ -0,0 +1,73 @@
+import type { Assignable } from '../predicates/assignable.js';
+import type { $Equality } from '../type_plus/$equality.js';
+import type { $MergeOptions } from '../type_plus/$merge_options.js';
+import type { $SpecialType } from '../type_plus/$special_type.js';
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js';
+import type { $Else } from '../type_plus/branch/$selection.js';
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is `symbol`.
+ *
+ * @example
+ * ```ts
+ * type R = IsSymbol<symbol> // true
+ *
+ * type R = IsSymbol<never> // false
+ * type R = IsSymbol<unknown> // false
+ * type R = IsSymbol<symbol | number> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `symbol`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsSymbol<symbol, { selection: 'filter' }> // symbol
+ *
+ * type R = IsSymbol<never, { selection: 'filter' }> // never
+ * type R = IsSymbol<unknown, { selection: 'filter' }> // never
+ * type R = IsSymbol<string | boolean, { selection: 'filter' }> // never
+ *
+ * type R = IsSymbol<symbol | null> // symbol
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsSymbol<symbol | 1> // boolean
+ * type R = IsSymbol<symbol | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsSymbol<symbol, $SelectionBranch> // $Then
+ * type R = IsSymbol<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsSymbol<T, $O extends IsSymbol.$Options = {}> = $SpecialType<T, $MergeOptions<$O, {
+    $then: $ResolveBranch<T, $O, [$Else]>;
+    $else: IsSymbol.$<T, $O>;
+}>>;
+export declare namespace IsSymbol {
+    type $Options = $Equality.$Options;
+    type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>;
+    /**
+     * 🧰 *type util*
+     *
+     * Validate if `T` is `symbol`.
+     *
+     * This is a type util for building custom types.
+     * It does not check against special types.
+     */
+    type $<T, $O extends $UtilOptions> = Assignable.$<T, symbol, $O>;
+    type $UtilOptions = Assignable.$UtilOptions;
+}
+//# sourceMappingURL=is_symbol.d.ts.map

package/cjs/symbol/is_symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_symbol.d.ts","sourceRoot":"","sources":["../../src/symbol/is_symbol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,EAAE,SAAS,QAAQ,CAAC,QAAQ,GAAG,EAAE,IAAI,YAAY,CACxE,CAAC,EACD,aAAa,CACZ,EAAE,EACF;IACC,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IACrC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;CACxB,CACD,CACD,CAAA;AAED,yBAAiB,QAAQ,CAAC;IACzB,KAAY,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAA;IACzC,KAAY,OAAO,CAAC,EAAE,SAAS,QAAQ,GAAG,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAErE;;;;;;;OAOG;IACH,KAAY,CAAC,CAAC,CAAC,EAAE,EAAE,SAAS,YAAY,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,CAAA;IAEvE,KAAY,YAAY,GAAG,UAAU,CAAC,YAAY,CAAA;CAClD"}

package/cjs/symbol/is_symbol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is_symbol.js.map

package/cjs/symbol/is_symbol.js.map

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

package/cjs/testing/stub.d.ts

@@ -0,0 +1,31 @@
+import type { AnyFunction } from '../function/any_function.js';
+import type { RecursivePartial } from '../object/recursive_partial.js';
+import type { NoInfer } from '../type/no_infer.js';
+/**
+ * stub a value.
+ *
+ * If the value is a function, it will be passed through as-is.
+ *
+ * 🦴 `utilities`
+ */
+export declare function stub<T extends AnyFunction>(stub: T): T;
+export declare function stub<T>(stub: RecursivePartial<NoInfer<T>>): T;
+export declare namespace stub {
+    var build: <T>(init: RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)) => (stub?: RecursivePartial<T>) => T;
+    var builder: <T>(init: RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)) => {
+        /**
+         * Adds an init object or handler to the builder.
+         *
+         * If `init` is an object, it will be merged with the stub object.
+         * If `init` is a function, it will be called with the stub object.
+         *
+         * @return {Builder<T>} The builder instance.
+         */
+        with(init: RecursivePartial<T> | ((stub?: RecursivePartial<T> | undefined) => RecursivePartial<T>)): any;
+        /**
+         * Creates the resulting stub function.
+         */
+        create(): (stub?: RecursivePartial<T> | undefined) => T;
+    };
+}
+//# sourceMappingURL=stub.d.ts.map

package/cjs/testing/stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.d.ts","sourceRoot":"","sources":["../../src/testing/stub.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAA;AACvD,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;yBAA9C,IAAI;gBAQL,CAAC,QACT,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAC/E,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC;kBAmBnB,CAAC,QAAQ,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;QAQnG;;;;;;;WAOG;;QAIH;;WAEG"}

package/cjs/testing/stub.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stub = stub;
+const unpartial_1 = require("unpartial");
+function stub(stub) {
+    return stub;
+}
+function build(init) {
+    return builder(init).create();
+}
+/**
+ * Create a builder for a stub function of type T.
+ *
+ * The builder contains two methods:
+ *
+ * `.with()`: adds additional handler or partial stub.
+ * `.create()`: creates the final stub function.
+ *
+ * @example
+ * ```ts
+ * const b = stub.builder<{ a: number; b: string }>({ a: 1 }).with({ b: 'b' }).create()
+ * b({ a: 2 }) // { a: 2, b: 'b' }
+ * ```
+ */
+function builder(init) {
+    return builderInternal([init]);
+}
+function builderInternal(initializers) {
+    const builder = {
+        /**
+         * Adds an init object or handler to the builder.
+         *
+         * If `init` is an object, it will be merged with the stub object.
+         * If `init` is a function, it will be called with the stub object.
+         *
+         * @return {Builder<T>} The builder instance.
+         */
+        with(init) {
+            return builderInternal([...initializers, init]);
+        },
+        /**
+         * Creates the resulting stub function.
+         */
+        create() {
+            return (stub) => {
+                return initializers.reduce((acc, init) => {
+                    if (typeof init === 'function') {
+                        return init(acc);
+                    }
+                    return (0, unpartial_1.requiredDeep)(init, acc);
+                }, stub);
+            };
+        },
+    };
+    return builder;
+}
+stub.build = build;
+stub.builder = builder;
+//# sourceMappingURL=stub.js.map

package/cjs/testing/stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.js","sourceRoot":"","sources":["../../src/testing/stub.ts"],"names":[],"mappings":";;AAeA,oBAEC;AAjBD,yCAAwC;AAexC,SAAgB,IAAI,CAAI,IAAa;IACpC,OAAO,IAAS,CAAA;AACjB,CAAC;AAQD,SAAS,KAAK,CAAI,IAAiF;IAClG,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAA;AAC9B,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,OAAO,CAAI,IAAiF;IACpG,OAAO,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;AAC/B,CAAC;AAED,SAAS,eAAe,CACvB,YAAgG;IAEhG,MAAM,OAAO,GAAG;QACf;;;;;;;WAOG;QACH,IAAI,CAAC,IAAiF;YACrF,OAAO,eAAe,CAAC,CAAC,GAAG,YAAY,EAAE,IAAI,CAAC,CAAC,CAAA;QAChD,CAAC;QACD;;WAEG;QAEH,MAAM;YACL,OAAO,CAAC,IAA0B,EAAE,EAAE;gBACrC,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;oBACxC,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;wBAChC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAA;oBACjB,CAAC;oBACD,OAAO,IAAA,wBAAY,EAAsB,IAAI,EAAE,GAAG,CAAC,CAAA;gBACpD,CAAC,EAAE,IAAI,CAAM,CAAA;YACd,CAAC,CAAA;QACF,CAAC;KACD,CAAA;IACD,OAAO,OAAO,CAAA;AACf,CAAC;AACD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;AAClB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA"}

package/cjs/testing/test_type.d.ts

@@ -0,0 +1,350 @@
+import type { IsAny } from '../any/is_any.js';
+import type { IsArray } from '../array/is_array.js';
+import type { IsBigint } from '../bigint/is_bigint.js';
+import type { IsBoolean } from '../boolean/is_boolean.js';
+import type { IsFalse } from '../boolean/is_false.js';
+import type { IsTrue } from '../boolean/is_true.js';
+import type { IsEqual } from '../equal/equal.js';
+import type { IsFunction } from '../function/is_function.js';
+import type { IsStrictFunction } from '../function/is_strict_function.js';
+import type { IsNever } from '../never/is_never.js';
+import type { IsNull } from '../null/is_null.js';
+import type { IsNumber } from '../number/is_number.js';
+import type { IsObject } from '../object/is_object.js';
+import type { Assignable } from '../predicates/assignable.js';
+import type { IsString } from '../string/is_string.js';
+import type { IsSymbol } from '../symbol/is_symbol.js';
+import type { IsTuple } from '../tuple/is_tuple.js';
+import type { IsUndefined } from '../undefined/is_undefined.js';
+import type { IsUnknown } from '../unknown/is_unknown.js';
+import type { IsVoid } from '../void/is_void.js';
+export declare namespace testType {
+    interface TestType {
+        /**
+         * Check if type `A` is equal to type `B` and `C`.
+         *
+         * @return `expected` as `A` for type inspection.
+         */
+        equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A;
+        /**
+         * Check if type `A` is equal to type `B`.
+         *
+         * @return `expected` as `A` for type inspection.
+         */
+        equal<A, B>(expected: IsEqual<A, B>): A;
+        /**
+         * Check if `A` can assign to `B`.
+         *
+         * If `A` is a union,
+         * the check is distributive.
+         *
+         * Meaning the result can be `boolean`,
+         * meaning both `true` and `false` will pass.
+         *
+         * If you want to avoid the distributivity,
+         * use `testType.strictCanAssign()` instead.
+         *
+         * @example
+         * ```ts
+         * testType.canAssign<123, number> // true
+         *
+         * testType.canAssign<number | string, number> // boolean
+         * ```
+         *
+         * @return `expected` as `A` for type inspection.
+         */
+        canAssign<A, B>(expected: Assignable<A, B>): A;
+        /**
+         * Check if `A` can fully assign to `B`.
+         *
+         * This checks all branches in an union `A` are assignable to `B`.
+         *
+         * @example
+         * ```ts
+         * testType.strictCanAssign<number | string, number | string> // true
+         *
+         * testType.strictCanAssign<number | string, number> // false
+         * ```
+         *
+         * @return `expected` as `A` for type inspection.
+         */
+        strictCanAssign<A, B>(expected: Assignable<A, B, {
+            distributive: false;
+        }>): A;
+        /**
+         * Check if type `T` is exactly `any`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        any<T>(expected: IsAny<T>): T;
+        /**
+         * Check if type `T` is exactly `array`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        array<T>(expected: IsArray<T, {
+            exact: true;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `bigint`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        strictBigint<T>(expected: IsBigint<T, {
+            distributive: false;
+            exact: true;
+        }>): T;
+        /**
+         * Check if type `T` is `bigint` or bigint literals.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        bigint<T>(expected: IsBigint<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `boolean`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        strictBoolean<T>(expected: IsBoolean<T, {
+            distributive: false;
+            exact: true;
+        }>): T;
+        /**
+         * Check if type `T` is `boolean` and boolean literals.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        boolean<T>(expected: IsBoolean<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `true`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        true<T>(expected: IsTrue<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `false`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        false<T>(expected: IsFalse<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `boolean`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        strictFunction<T>(expected: IsStrictFunction<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is `boolean` and boolean literals.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        function<T>(expected: IsFunction<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `never`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        never<T>(expected: IsNever<T>): T;
+        /**
+         * Check if type `T` is exactly `null`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        null<T>(expected: IsNull<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `number`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        strictNumber<T>(expected: IsNumber<T, {
+            distributive: false;
+            exact: true;
+        }>): T;
+        /**
+         * Check if type `T` is `number` or number literals.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        number<T>(expected: IsNumber<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is `object`.
+         *
+         * Note that `Function`, `Array`, and *tuple* are also `object`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        object<T>(expected: IsObject<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `string`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        strictString<T>(expected: IsString<T, {
+            distributive: false;
+            exact: true;
+        }>): T;
+        /**
+         * Check if type `T` is `string` or string literals.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        string<T>(expected: IsString<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is a `symbol`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        symbol<T>(expected: IsSymbol<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is a *tuple*.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        tuple<T>(expected: IsTuple<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `undefined`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        undefined<T>(expected: IsUndefined<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * Check if type `T` is exactly `unknown`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        unknown<T>(expected: IsUnknown<T>): T;
+        /**
+         * Check if type `T` is exactly `void`.
+         *
+         * @return `expected` as `T` for type inspection.
+         */
+        void<T>(expected: IsVoid<T, {
+            distributive: false;
+        }>): T;
+        /**
+         * A quick way to inspect a type.
+         *
+         * The handler receives a `InspectedType` object.
+         * It contains `value` which is typed to `T`,
+         * and many other properties to inspect the behavior of `T`.
+         *
+         * The handler is not being call,
+         * it is use to hold the type in value for inspection.
+         *
+         * 🧪 *testing*
+         * 🦴 *utilities*
+         *
+         * @example
+         * ```ts
+         * testType.inspect<SomeType>(t => {
+         *   type T = typeof t.value // resolve and inspect the type `T`
+         *   t.extend_boolean // result of `T extends boolean`
+         * })
+         * ```
+         *
+         * After trying out the type, remove the line.
+         */
+        inspect<T>(handler: (t: InspectedType<T>) => unknown): T;
+    }
+    type InspectedType<T> = {
+        type: T;
+        extends<R>(): T extends R ? true : false;
+        extends_any: T extends any ? true : false;
+        extends_unknown: T extends unknown ? true : false;
+        extends_void: T extends void ? true : false;
+        extends_never: T extends never ? true : false;
+        extends_undefined: T extends undefined ? true : false;
+        extends_null: T extends null ? true : false;
+        extends_boolean: T extends boolean ? true : false;
+        extends_true: T extends true ? true : false;
+        extends_false: T extends false ? true : false;
+        extends_number: T extends number ? true : false;
+        extends_1: T extends 1 ? true : false;
+        extends_bigint: T extends bigint ? true : false;
+        extends_1n: T extends 1n ? true : false;
+        extends_string: T extends string ? true : false;
+        extends_a: T extends 'a' ? true : false;
+        extends_symbol: T extends symbol ? true : false;
+        extends_object: T extends object ? true : false;
+        extends_function: T extends Function ? true : false;
+        extends_array_unknown: T extends unknown[] ? true : false;
+        extends_tuple_empty: T extends [] ? true : false;
+        union<R>(): T | R;
+        union_any: T | any;
+        union_unknown: T | unknown;
+        union_void: T | void;
+        union_never: T | never;
+        union_undefined: T | undefined;
+        union_null: T | null;
+        union_boolean: T | boolean;
+        union_true: T | true;
+        union_false: T | false;
+        union_number: T | number;
+        union_1: T | 1;
+        union_bigint: T | bigint;
+        union_1n: T | 1n;
+        union_string: T | string;
+        union_a: T | 'a';
+        union_symbol: T | symbol;
+        union_object: T | object;
+        union_function: T | Function;
+        union_array_unknown: T | unknown[];
+        union_tuple_empty: T | [];
+        intersect<R>(): T & R;
+        intersect_any: T & any;
+        intersect_unknown: T & unknown;
+        intersect_void: T & void;
+        intersect_never: T & never;
+        intersect_undefined: T & undefined;
+        intersect_null: T & null;
+        intersect_boolean: T & boolean;
+        intersect_true: T & true;
+        intersect_false: T & false;
+        intersect_number: T & number;
+        intersect_1: T & 1;
+        intersect_bigint: T & bigint;
+        intersect_1n: T & 1n;
+        intersect_string: T & string;
+        intersect_a: T & 'a';
+        intersect_symbol: T & symbol;
+        intersect_object: T & object;
+        intersect_function: T & Function;
+        intersect_array_unknown: T & unknown[];
+        intersect_tuple_empty: T & [];
+    };
+}
+/**
+ * Test utilities for types.
+ *
+ * This is designed specifically for testing.
+ * The return value is the input `expected` parameter asserted as the first type parameter,
+ * so that the type can be further inspected.
+ */
+export declare const testType: testType.TestType;
+//# sourceMappingURL=test_type.d.ts.map