npm - inferred-types - Versions diffs - 0.37.5 → 0.40.1 - Mend

inferred-types 0.37.5 → 0.40.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2087) hide show

package/dist/types/src/types/boolean-logic/operators/IsGreaterThan.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { GreaterThan, ToNumber } from "../..";
+/**
+ * **IsGreaterThan**`<A,B>`
+ *
+ * Boolean type operator which determines whether `A`
+ * is _greater than_ `B`.
+ */
+export type IsGreaterThan<A extends number | `${number}`, B extends number | `${number}`> = GreaterThan<A extends number ? A : ToNumber<A>, B extends number ? B : ToNumber<B>> extends true ? true : false;
+//# sourceMappingURL=IsGreaterThan.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsGreaterThan.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsGreaterThan.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,QAAQ,EAAE,MAAM,OAAO,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,EAC9B,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,IAC5B,WAAW,CACb,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EAClC,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CACnC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsGreaterThan.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsIndexable.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { AnyObject, Container, IfEqual, Keys } from "src/types/index";
+/**
+ * **IsIndexable**`<T>`
+ *
+ * Boolean operator which returns whether the true when
+ * T is a container and has _at least_ **one** key known at design
+ * time.
+ */
+export type IsIndexable<T> = T extends Container ? T extends unknown[] ? IfEqual<T["length"], number, false, IfEqual<T["length"], 0, false, true>> : T extends AnyObject ? IfEqual<Keys<T>, number, false, true> : false : false;
+//# sourceMappingURL=IsIndexable.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsIndexable.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsIndexable.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsIndexable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IACzB,CAAC,SAAS,SAAS,GACf,CAAC,SAAS,OAAO,EAAE,GACjB,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,EACnB,KAAK,EACL,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CACrC,GACD,CAAC,SAAS,SAAS,GACjB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,GACrC,KAAK,GACT,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsIndexable.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsLength.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { Length } from "../..";
+import type { IfEqual } from "../..";
+/**
+ * **IsLength**`<T, LEN>`
+ *
+ * Boolean type utility which returns true/false based on whether
+ * the correct length for `T` is specified.
+ */
+export type IsLength<T, LEN extends number> = T extends readonly unknown[] ? IfEqual<Length<T>, LEN, true, false> : false;
+//# sourceMappingURL=IsLength.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsLength.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsLength.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsLength.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,GAAG,SAAS,MAAM,IAChB,CAAC,SAAS,SAAS,OAAO,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,GACpC,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsLength.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsLiteral.d.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import type { IsBooleanLiteral, IsNumericLiteral, IsObjectLiteral, IsStringLiteral, IsTuple, IfNever } from "../..";
+/**
+ * **IsLiteral**`<T>`
+ *
+ * Boolean type literal which tests whether `T` is a _literal_ value or not.
+ *
+ * - ensures that strings, numbers, and boolean values are literal/narrow types
+ * - ensures that arrays (including readonly arrays) have a known set of values (length known at design time); some of the known values in the tuple _may_ be wide types
+ * - ensures that objects have a known set of keys (including no keys)
+ * - symbols, and null values will return **true** as they are always unique
+ * - _undefined_ will always return **false**
+ * - a **literal array** is one where the discrete elements are known; some of the elements _may_ be wide types
+ *
+ */
+export type IsLiteral<T> = IfNever<T, false, IsStringLiteral<T> extends true ? true : IsBooleanLiteral<T> extends true ? true : IsNumericLiteral<T> extends true ? true : IsTuple<T> extends true ? true : IsObjectLiteral<T> extends true ? true : false>;
+/**
+ * **IsOptionalLiteral**
+ *
+ * Type utility which returns true/false if the value passed -- a form of a
+ * string, number, or boolean -- is a _literal_ value of that type (true) or
+ * the more generic wide type (false).
+ *
+ * This type also strips off _undefined_ from any possible union type to evaluate
+ * to `true` even when a literal value is in union with _undefined_. If you don't
+ * want to test for the union with _undefined_ use the `IsOptional` utility instead.
+ */
+export type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string] ? IsStringLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [boolean] ? IsBooleanLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [number] ? IsNumericLiteral<Exclude<T, undefined>> : false;
+/**
+ * **IfOptionalLiteral**
+ *
+ * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
+ * the inclusion of _undefined_); otherwise returns the type `ELSE`
+ */
+export type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
+//# sourceMappingURL=IsLiteral.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsLiteral.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsLiteral.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAEhB,gBAAgB,EAChB,eAAe,EACf,eAAe,EAIhB,OAAO,EACP,OAAO,EAAC,MAAM,OAAO,CAAC;AAKvB;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,OAAO,CAChC,CAAC,EACD,KAAK,EACL,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9B,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9B,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,IAAI,GACJ,KAAK,CAClB,CAAC;AAGF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACvE,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GACtC,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GACzC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GACvC,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACxC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GACvC,KAAK,CAAC;AAIV;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAC3B,CAAC,EACD,EAAE,EACF,IAAI,IACF,iBAAiB,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsLiteral.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsMaybeTrue.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { IfFalse, IfTrue, IsBoolean } from "../..";
+/**
+ * **IsMaybeTrue**`<T>`
+ *
+ * Type utility which checks for the narrow type of `true` but
+ * only converts what it knows at design time. Valid return
+ * types are:
+ *
+ * - `true` - known to be of `true` type
+ * - `false` - known to be of `false` type (aka, "false" or non-boolean)
+ * - `boolean` - can't determine true/false at design time
+ */
+export type IsMaybeTrue<T> = IsBoolean<T> extends true ? IfTrue<T, true, IfFalse<T, false, boolean>> : false;
+//# sourceMappingURL=IsMaybeTrue.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsMaybeTrue.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsMaybeTrue.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsMaybeTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GAClD,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,GAC3C,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsMaybeTrue.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsNegativeNumber.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { Digital, DigitalLiteral, IfLiteral, IfStartsWith, ToString } from "../..";
+/**
+ * **IsNegativeNumber**`<T>`
+ *
+ * Returns a literal true/false where possible to whether `T` is a _negative_
+ * number. Will return `boolean` type if unable to resolve at design time.
+ */
+export type IsNegativeNumber<T> = T extends `${number}` | number ? IfLiteral<T, IfStartsWith<ToString<T>, "-", true, false>, boolean> : T extends Digital ? T[0] extends "-" ? true : false : T extends DigitalLiteral ? T[0] extends "-" ? true : false : never;
+//# sourceMappingURL=IsNegativeNumber.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsNegativeNumber.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsNegativeNumber.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsNegativeNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAG,SAAS,EAAE,YAAY,EAAG,QAAQ,EAAE,MAAM,OAAO,CAAC;AAErF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,MAAM,EAAE,GAAG,MAAM,GAC9D,SAAS,CACT,CAAC,EACD,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,EAC3C,OAAO,CACR,GACC,CAAC,SAAS,OAAO,GACf,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG,IAAI,GAAG,KAAK,GAC/B,CAAC,SAAS,cAAc,GACtB,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG,IAAI,GAAG,KAAK,GAC/B,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsNegativeNumber.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsNever.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+/**
+ * **IsNever**`<T>`
+ *
+ * Boolean type utility which check whether `T` is of type _never_.
+ */
+export type IsNever<T> = [T] extends never[] ? true : false;
+//# sourceMappingURL=IsNever.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsNever.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsNever.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsNever.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsNever.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsNotEqual.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { IsEqual } from "../..";
+/**
+ * **NotEqual**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are _not_ exactly the same type
+ */
+export type IsNotEqual<X, Y> = true extends IsEqual<X, Y> ? false : true;
+//# sourceMappingURL=IsNotEqual.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsNotEqual.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsNotEqual.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsNotEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsNotEqual.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsNull.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+/**
+ * **IsNull**`<T>`
+ *
+ * Type utility which returns a boolean flag based on whether the given
+ * type is **null**.
+ */
+export type IsNull<T> = T extends null ? true : false;
+//# sourceMappingURL=IsNull.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsNull.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsNull.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsNull.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsNull.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsNumber.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+/**
+ * **IsNumber**`<T>`
+ *
+ * Boolean type utility testing whether `T` is a numeric type.
+ */
+export type IsNumber<T> = T extends number ? true : false;
+//# sourceMappingURL=IsNumber.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsNumber.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsNumber.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsNumber.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsNumber.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsNumericLiteral.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { IfNever, IfEqual, DoesExtend } from "../..";
+/**
+ * **IsNumericLiteral**`<T>`
+ *
+ * Type utility which detects if the type `T` is a
+ * numeric literal.
+ */
+export type IsNumericLiteral<T> = IfNever<T, never, DoesExtend<T, number> extends true ? IfEqual<T, number, false, true> : false>;
+//# sourceMappingURL=IsNumericLiteral.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsNumericLiteral.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsNumericLiteral.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsNumericLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,OAAO,CACvC,CAAC,EAAE,KAAK,EACR,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,IAAI,GAC9B,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,GAC/B,KAAK,CACV,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsNumericLiteral.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsObject.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { AnyFunction, Mutable, Or, IfExtends } from "../..";
+/**
+ * **IsObject**
+ *
+ * Boolean type utility used to check whether a type `T` is an object
+ * (aka, it extends `Record<string, any>` or a readonly equivalent)
+ */
+export type IsObject<T> = Or<[
+    IfExtends<T, Record<string | symbol, unknown>, true, false>,
+    IfExtends<Mutable<T>, Record<string | symbol, unknown>, true, false>,
+    IfExtends<T, object, true, false>
+]> extends true ? T extends AnyFunction ? false : Mutable<T> extends unknown[] ? false : true : false;
+//# sourceMappingURL=IsObject.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsObject.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsObject.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,OAAO,EAAG,EAAE,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3B,SAAS,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;IACxD,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC;IAChE,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC;CAClC,CAAC,SAAS,IAAI,GAEb,CAAC,SAAS,WAAW,GAEnB,KAAK,GACL,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,EAAE,GAG5B,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsObject.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsObjectLiteral.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { AnyObject, RemoveIndexKeys, EmptyObject, IsEqual, Keys, IndexableObject, IfNotEqual } from "../..";
+/**
+ * **IsObjectLiteral**`<T>`
+ *
+ * Tests whether an object is a literal. An object literal is any of the following:
+ *
+ * - an `EmptyObject`
+ * - an `Indexable` object with at least one explicit key defined
+ */
+export type IsObjectLiteral<T> = T extends AnyObject ? IsEqual<T, EmptyObject> extends true ? true : RemoveIndexKeys<T> extends IndexableObject ? IfNotEqual<Keys<RemoveIndexKeys<T>>, readonly [], true, false> : false : false;
+//# sourceMappingURL=IsObjectLiteral.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsObjectLiteral.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsObjectLiteral.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsObjectLiteral.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,eAAe,EACf,WAAW,EACX,OAAO,EACP,IAAI,EACJ,eAAe,EACf,UAAU,EACX,MAAM,OAAO,CAAC;AAEf;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAClD,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC,SAAS,IAAI,GAClC,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,eAAe,GACxC,UAAU,CACR,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EACrC,IAAI,EACJ,KAAK,CACN,GACD,KAAK,GACT,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsObjectLiteral.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsOptionalScalar.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { IfNever, IfOr, IsScalar, IsUndefined, IfUnion, IfSomeExtend, UnionToTuple, Scalar } from "../..";
+/**
+ * **IsOptionalScalar**`<T>`
+ *
+ * Boolean type utility which tests for a _scalar_ value or _undefined_.
+ *
+ * **Related:** `IsScalar`
+ */
+export type IsOptionalScalar<T> = IfNever<T, false, IfOr<[
+    IsScalar<T>,
+    IsUndefined<T>
+], true, IfUnion<T, IfSomeExtend<UnionToTuple<T>, Scalar | undefined, boolean, false>, false>>>;
+//# sourceMappingURL=IsOptionalScalar.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsOptionalScalar.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsOptionalScalar.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsOptionalScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,WAAW,EACX,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,MAAM,EACP,MAAM,OAAO,CAAC;AAGf;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CACtD;IACE,QAAQ,CAAC,CAAC,CAAC;IAAE,WAAW,CAAC,CAAC,CAAC;CAC5B,EACD,IAAI,EACJ,OAAO,CACL,CAAC,EACD,YAAY,CACV,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,EACnC,OAAO,EAAE,KAAK,CACf,EACD,KAAK,CACN,CACF,CAAC,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsOptionalScalar.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsReadonlyArray.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+/**
+ * **IsReadonlyArray**`<T>`
+ *
+ * Boolean type utility which detects whether `T` is a readonly array.
+ */
+export type IsReadonlyArray<T> = T extends unknown[] ? false : T extends readonly unknown[] ? true : false;
+//# sourceMappingURL=IsReadonlyArray.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsReadonlyArray.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsReadonlyArray.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsReadonlyArray.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAE7B,CAAC,SAAS,OAAO,EAAE,GACf,KAAK,GACL,CAAC,SAAS,SAAS,OAAO,EAAE,GAC5B,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsReadonlyArray.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsReadonlyObject.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import { MutableProps, EmptyContainer, Container } from "src/types";
+/**
+ * **IsReadonlyObject**`<T>`
+ *
+ * Boolean operator which tests whether `T` is a _readonly
+ * object_. This is defined as an object where all properties
+ * are readonly.
+ *
+ * - Note: objects with no properties return `false`
+ */
+export type IsReadonlyObject<T> = T extends Container ? EmptyContainer<MutableProps<T>> extends true ? EmptyContainer<T> extends true ? false : true : false : false;
+//# sourceMappingURL=IsReadonlyObject.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsReadonlyObject.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsReadonlyObject.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsReadonlyObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,YAAY,EAAG,cAAc,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GACjD,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1C,cAAc,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,KAAK,GAAE,IAAI,GAC5C,KAAK,GACP,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsReadonlyObject.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsRef.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { Length } from "../..";
+/**
+ * **IsRef**`<T>`
+ *
+ * Boolean type utility that detects whether the type passed in
+ * is a VueJS `Ref<...>` type.
+ *
+ * **Note:** if `T` is a _wide_ Object type then `boolean` will be returned
+ * as we can't make enough of a judgement on whether it is reference or
+ * not.
+ */
+export type IsRef<T> = T extends {
+    value: unknown;
+} ? Length<T> extends 2 ? true : false : false;
+//# sourceMappingURL=IsRef.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsRef.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsRef.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAC/C,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GACjB,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsRef.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsScalar.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { Scalar, UnionToTuple, IsBoolean, IsNull, IsSymbol, IsNumber, IfOr, IsString, IfNever, IfUnion, IfSomeExtend } from "../..";
+/**
+ * **IsScalar**`<T>`
+ *
+ * Type utility which checks if a value is a _scalar_ value (aka, it is
+ * an atomic value and doesn't _contain_ other types). In practical terms this just
+ * means if it's a string, number, boolean, null, undefined, or symbol then it is
+ * a **scalar**. Arrays and records of any type are _not_ scalars.
+ *
+ * **Related:** `IsOptionalScalar`
+ */
+export type IsScalar<T> = IfNever<T, false, IfOr<[
+    IsString<T>,
+    IsNumber<T>,
+    IsBoolean<T>,
+    IsNull<T>,
+    IsSymbol<T>
+], true, IfUnion<T, IfSomeExtend<UnionToTuple<T>, Scalar, boolean, false>, false>>>;
+//# sourceMappingURL=IsScalar.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsScalar.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsScalar.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAAE,YAAY,EACpB,SAAS,EACT,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,OAAO,EACP,YAAY,EACb,MAAM,OAAO,CAAC;AAEf;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAC1C,IAAI,CACF;IACE,QAAQ,CAAC,CAAC,CAAC;IACX,QAAQ,CAAC,CAAC,CAAC;IACX,SAAS,CAAC,CAAC,CAAC;IACZ,MAAM,CAAC,CAAC,CAAC;IACT,QAAQ,CAAC,CAAC,CAAC;CACd,EACC,IAAI,EACJ,OAAO,CACL,CAAC,EACD,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EACrD,KAAK,CACN,CACF,CAAC,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsScalar.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsSingularNoun.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { IfNever, IfStringLiteral, SingularNoun } from "../..";
+/**
+ * **IsSingularNoun**`<T>`
+ *
+ * Boolean operator which returns:
+ *
+ * - `true` - if `T` is a string literal with only `Alpha` chars and ending in
+ * character defined by `SingularNounEnding`.
+ * - `boolean` - if `T` is a wide string type
+ * - `false` - all other conditions
+ */
+export type IsSingularNoun<T> = T extends string ? IfStringLiteral<T, IfNever<SingularNoun<T>, false, true>, boolean> : false;
+//# sourceMappingURL=IsSingularNoun.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsSingularNoun.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsSingularNoun.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsSingularNoun.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAG/D;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC5C,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,GAClE,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsSingularNoun.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsString.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+/**
+ * **IsString**
+ *
+ * Type utility which returns true/false based on whether `T` is a
+ * string (wide or narrow).
+ */
+export type IsString<T> = T extends string ? true : false;
+//# sourceMappingURL=IsString.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsString.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsString.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsString.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsString.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsStringLiteral.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { IfNever } from "../..";
+/**
+ * **IsStringLiteral**`<T>`
+ *
+ * Boolean type utility which detects whether `T` is
+ * a string literal.
+ */
+export type IsStringLiteral<T> = IfNever<T, never, [
+    T
+] extends [string] ? string extends T ? false : true : false>;
+//# sourceMappingURL=IsStringLiteral.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsStringLiteral.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsStringLiteral.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsStringLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EACjD;IAAC,CAAC;CAAC,SAAS,CAAC,MAAM,CAAC,GAChB,MAAM,SAAS,CAAC,GACd,KAAK,GACL,IAAI,GACN,KAAK,CACR,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsStringLiteral.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsSymbol.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+/**
+ * **IsSymbol**`<T>`
+ *
+ * Type utility which returns a boolean flag based on whether the given
+ * type is a **Symbol**.
+ */
+export type IsSymbol<T> = T extends symbol ? true : false;
+//# sourceMappingURL=IsSymbol.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsSymbol.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsSymbol.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsSymbol.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsSymbol.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsTrue.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import { IsEqual, IsNever } from "../..";
+/**
+ * **IsTrue**`<T>`
+ *
+ * Type utility which checks for the narrow type of `true`
+ * ```ts
+ * // true
+ * type T = IsTrue<true>;
+ * // false
+ * type U = IsTrue<boolean>;
+ * // false
+ * type F2 = IsTrue<"foobar">;
+ * ```
+ */
+export type IsTrue<T> = IsNever<T> extends true ? never : IsEqual<T, true> extends true ? true : false;
+//# sourceMappingURL=IsTrue.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsTrue.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsTrue.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,OAAO,EAAE,MAAM,OAAO,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7C,KAAK,GACL,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsTrue.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsTruthy.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { IfLiteral, IfSomeEqual } from "../..";
+/**
+ * **Truthy**`<T>`
+ *
+ * A type utility which evaluates `T` for _[truthiness](https://frontend.turing.edu/lessons/module-1/js-truthy-falsy-expressions.html)_ and returns `true` or `false`
+ * where the state can be detected at design time; otherwise returns `boolean`.
+ *
+ * **See Also:** `IfTruthy`, `IfSomeTruthy`, `IfAllTruthy`, and `TruthyReturns`
+ */
+export type IsTruthy<T> = T extends string ? T extends "" ? false : IfLiteral<T, true, boolean> : T extends number ? IfLiteral<T, IfSomeEqual<T, [0, -0], false, true>, boolean> : T extends boolean ? T extends false ? false : IfLiteral<T, true, boolean> : IfSomeEqual<T, [null, undefined, typeof NaN], false, boolean>;
+//# sourceMappingURL=IsTruthy.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsTruthy.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsTruthy.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsTruthy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAG/C;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IACpB,CAAC,SAAS,MAAM,GACZ,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,GACpD,CAAC,SAAS,MAAM,GACd,SAAS,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,GAC3D,CAAC,SAAS,OAAO,GACf,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,GACrD,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsTruthy.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsTuple.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { IfNever, Tuple } from "../..";
+/**
+ * **IfTuple**`<T>`
+ *
+ * Boolean operator which tests whether the given `T` is
+ * a _tuple_ value where a tuple is defined as:
+ *
+ * > a _finite_ and _known_ list of elements
+ *
+ * - note that this _does_ include a list of zero elements
+ * - types such as `string[]`, etc. are _not_ tuples as they
+ * do not discretely specify a length of elements
+ */
+export type IsTuple<T> = IfNever<T, false, T extends Tuple ? number extends T["length"] ? false : true : false>;
+//# sourceMappingURL=IsTuple.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsTuple.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsTuple.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,OAAO,CAC9B,CAAC,EAAE,KAAK,EACR,CAAC,SAAS,KAAK,GACX,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACxB,KAAK,GACL,IAAI,GACN,KAAK,CACV,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsTuple.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsUndefined.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+/**
+ * **IsUndefined**
+ *
+ * Boolean type utility returns `true` if `T` is undefined; `false` otherwise
+ */
+export type IsUndefined<T> = T extends undefined ? true : false;
+//# sourceMappingURL=IsUndefined.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsUndefined.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"IsUndefined.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsUndefined.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsUndefined.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsUnion.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { UnionToTuple, IfLength, IfNever } from "../..";
+/**
+ * **IsUnion**`<T>`
+ *
+ * Type utility which returns a boolean flag indicating whether the
+ * given `T` is typed as a _union_ type.
+ */
+export type IsUnion<T> = IfNever<T, never, IfLength<UnionToTuple<T>, 1, false, IfLength<UnionToTuple<T>, 0, false, true>>>;
+//# sourceMappingURL=IsUnion.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsUnion.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsUnion.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAG,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CACjD,YAAY,CAAC,CAAC,CAAC,EACf,CAAC,EACD,KAAK,EACL,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAC1C,CAAC,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsUnion.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/src/types/boolean-logic/operators/IsValidDotPath.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { Container, DotPathFor, IfNever, IfExtends, IfLiteral, IfStringLiteral } from "../..";
+/**
+ * **IsValidDotPath**`<TContainer, TKey>`
+ *
+ * Boolean operator which detects whether a given key of `TKey` should be considered a
+ * valid "dot path" for the container `TContainer`. Results based on `TKey` are:
+ *
+ * - `false`
+ *    - any non-string type or any string literal in which `DotPath<T>` resolves
+ * to false (including _never_ value).
+ * - `boolean`
+ *    - when a `TContainer` maps to a wide container type then we have to return boolean
+ * as the validity of the key can not be determined at design time
+ *    - the same applies to `TKey` being a wide string type
+ * - `true` - a string literal value where `DotPath<T>` does not resolve to _never_.
+ *
+ * Note: this utility not only validates that `TKey` is a valid key in principle but that it is a valid key for `TContainer`; if you prefer a simpler check then use `IsDotPath<T>` instead.
+ */
+export type IsValidDotPath<TContainer, TKey> = IfNever<TKey, false, IfNever<TContainer, false, TContainer extends Container ? TKey extends string ? IfLiteral<TContainer, IfStringLiteral<TKey, IfExtends<TKey, DotPathFor<TContainer>, true, false>, boolean>, boolean> : false : false>>;
+//# sourceMappingURL=IsValidDotPath.d.ts.map

package/dist/types/src/types/boolean-logic/operators/IsValidDotPath.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"IsValidDotPath.d.ts","sourceRoot":"","sources":["../../../../../../src/types/boolean-logic/operators/IsValidDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAE9F;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,CAAC,UAAU,EAAC,IAAI,IAC1C,OAAO,CACL,IAAI,EACJ,KAAK,EACL,OAAO,CACL,UAAU,EACV,KAAK,EACL,UAAU,SAAS,SAAS,GACxB,IAAI,SAAS,MAAM,GACjB,SAAS,CACP,UAAU,EACV,eAAe,CACb,IAAI,EACJ,SAAS,CACP,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,EAC5B,IAAI,EACJ,KAAK,CACJ,EACD,OAAO,CACR,EACD,OAAO,CACR,GACD,KAAK,GACT,KAAK,CACV,CACF,CAAC"}

package/dist/types/src/types/boolean-logic/operators/IsValidDotPath.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};