inferred-types 0.51.0 → 0.51.1

package/dist/types/boolean-logic/operators/IsNever.js

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

package/dist/types/boolean-logic/operators/IsNonLiteralUnion.d.ts

@@ -0,0 +1,13 @@
+import { If, IsUnion, RetainLiterals, UnionToTuple } from "inferred-types/dist/types/index";
+type Process<T> = UnionToTuple<T> extends readonly unknown[] ? RetainLiterals<UnionToTuple<T>>["length"] extends UnionToTuple<T>["length"] ? false : true : never;
+/**
+ * **IsNonLiteralUnion**`<T>`
+ *
+ * Boolean utility which checks whether `T` is both a _union type_
+ * and that none of it's elements are considered _literal types_.
+ *
+ * **Related:** `IsLiteralUnion`, `IsWideUnion`
+ */
+export type IsNonLiteralUnion<T> = If<IsUnion<T>, Process<T>, false>;
+export {};
+//# sourceMappingURL=IsNonLiteralUnion.d.ts.map

package/dist/types/boolean-logic/operators/IsNonLiteralUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsNonLiteralUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNonLiteralUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,EAAE,EAAE,OAAO,EAAE,cAAc,EAAG,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG9F,KAAK,OAAO,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1D,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GACzE,KAAK,GACL,IAAI,GACN,KAAK,CAAC;AAER;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,CAC3B,CAAC,IAAI,EAAE,CACP,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,CAAC,CAAC,EACV,KAAK,CACN,CAAA"}

package/dist/types/boolean-logic/operators/IsNonLiteralUnion.js

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

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

@@ -0,0 +1,8 @@
+import { IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **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/boolean-logic/operators/IsNotEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsNotEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNotEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC1D;;;;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/boolean-logic/operators/IsNotEqual.js

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

package/dist/types/boolean-logic/operators/IsNothing.d.ts

@@ -0,0 +1,9 @@
+import { Nothing } from "inferred-types/dist/types/index";
+/**
+ * **IsNothing**`<T>`
+ *
+ * Boolean operator which tests whether `T` is _nothing_ (aka.,
+ * `null` or `undefined`).
+ */
+export type IsNothing<T> = [T] extends [Nothing] ? true : false;
+//# sourceMappingURL=IsNothing.d.ts.map

package/dist/types/boolean-logic/operators/IsNothing.d.ts.map

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

package/dist/types/boolean-logic/operators/IsNothing.js

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

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

@@ -0,0 +1,12 @@
+import { IsUnion } from "./IsUnion";
+/**
+ * **IsNull**`<T>`
+ *
+ * Type utility which returns a boolean flag based on whether the given
+ * type is **null**.
+ *
+ * Note: if `T` is a union type and one of the elements of the union
+ * is `null` then this will return `boolean`.
+ */
+export type IsNull<T> = IsUnion<T> extends true ? [null] extends [T] ? boolean : false : [T] extends [null] ? true : false;
+//# sourceMappingURL=IsNull.d.ts.map

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

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

package/dist/types/boolean-logic/operators/IsNull.js

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

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

@@ -0,0 +1,8 @@
+import { IsUnion, WidenUnion } from "inferred-types/dist/types/index";
+/**
+ * **IsNumber**`<T>`
+ *
+ * Boolean type utility testing whether `T` is a numeric type.
+ */
+export type IsNumber<T> = [IsUnion<T>] extends [true] ? WidenUnion<T> extends number ? true : number extends WidenUnion<T> ? boolean : false : [T] extends [number] ? true : false;
+//# sourceMappingURL=IsNumber.d.ts.map

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

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

package/dist/types/boolean-logic/operators/IsNumber.js

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

package/dist/types/boolean-logic/operators/IsNumberLike.d.ts

@@ -0,0 +1,10 @@
+import { DoesExtend } from "./DoesExtend";
+import { IsNever } from "./IsNever";
+import { IsNumber } from "./IsNumber";
+/**
+ * **IsNumberLike**`<T>`
+ *
+ * Boolean operator which validates that `T` is a number or `${number}`
+ */
+export type IsNumberLike<T> = IsNever<T> extends true ? false : IsNumber<T> extends true ? true : DoesExtend<T, `${number}`> extends true ? true : false;
+//# sourceMappingURL=IsNumberLike.d.ts.map

package/dist/types/boolean-logic/operators/IsNumberLike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsNumberLike.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNumberLike.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACnD,KAAK,GACL,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GACxB,IAAI,GACJ,UAAU,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,SAAS,IAAI,GACvC,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsNumberLike.js

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

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

@@ -0,0 +1,9 @@
+import { IfNever, IfEqual, DoesExtend } from "inferred-types/dist/types/index";
+/**
+ * **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/boolean-logic/operators/IsNumericLiteral.d.ts.map

@@ -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,iCAAiC,CAAC;AAE/E;;;;;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/boolean-logic/operators/IsNumericLiteral.js

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

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

@@ -0,0 +1,13 @@
+import { AnyFunction, Mutable, Or, If, Extends } from "inferred-types/dist/types/index";
+/**
+ * **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<[
+    If<Extends<T, Record<string | symbol, unknown>>, true, false>,
+    If<Extends<Mutable<T>, Record<string | symbol, unknown>>, true, false>,
+    If<Extends<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/boolean-logic/operators/IsObject.d.ts.map

@@ -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,EAAE,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAE1F;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3B,EAAE,CAAC,OAAO,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;IAC1D,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC;IAClE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;CACpC,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/boolean-logic/operators/IsObject.js

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

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

@@ -0,0 +1,14 @@
+import { Dictionary, UnionToTuple, RemoveIndexKeys, ExplicitlyEmptyObject, IsEqual, IsNever } from "inferred-types/dist/types/index";
+type _Keys<T extends Dictionary> = UnionToTuple<keyof RemoveIndexKeys<T>>;
+type CheckIt<T extends Dictionary> = IsNever<keyof T> extends true ? false : IsEqual<_Keys<T>, []> extends true ? false : true;
+/**
+ * **IsObjectLiteral**`<T>`
+ *
+ * Tests whether an object is a literal. An object literal is any of the following:
+ *
+ * - any KV-like type which has an **explicit** number of keys
+ * - if `Keys<T>["length"]` translates to `number` than this is **not** a literal.
+ */
+export type IsObjectLiteral<T> = IsNever<T> extends true ? false : T extends Dictionary ? IsEqual<T, ExplicitlyEmptyObject> extends true ? true : CheckIt<T> : false;
+export {};
+//# sourceMappingURL=IsObjectLiteral.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsObjectLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsObjectLiteral.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,OAAO,EACP,OAAO,EACR,MAAM,iCAAiC,CAAC;AAEzC,KAAK,KAAK,CACR,CAAC,SAAS,UAAU,IAClB,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3C,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,IAAI,GAC9D,KAAK,GACL,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,IAAI,GAChC,KAAK,GACL,IAAI,CAAC;AAGX;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACtD,KAAK,GACL,CAAC,SAAS,UAAU,GACpB,OAAO,CAAC,CAAC,EAAE,qBAAqB,CAAC,SAAS,IAAI,GAC5C,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,GACZ,KAAK,CAAA"}

package/dist/types/boolean-logic/operators/IsObjectLiteral.js

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

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

@@ -0,0 +1,12 @@
+import { IsNever, IsScalar, IsUndefined, IsUnion } from "inferred-types/dist/types/index";
+type Process<T> = [IsNever<T>] extends [true] ? false : [IsScalar<T>] extends [true] ? true : [IsUndefined<T>] extends [true] ? true : [IsUnion<T>] extends [true] ? boolean : false;
+/**
+ * **IsOptionalScalar**`<T>`
+ *
+ * Boolean type utility which tests for a _scalar_ value or _undefined_.
+ *
+ * **Related:** `IsScalar`
+ */
+export type IsOptionalScalar<T> = Process<T> extends boolean ? Process<T> : never;
+export {};
+//# sourceMappingURL=IsOptionalScalar.d.ts.map

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

@@ -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,QAAQ,EACR,WAAW,EACX,OAAO,EACR,MAAM,iCAAiC,CAAC;AAEzC,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,KAAK,GACL,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC1B,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,IAAI,GACJ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACzB,OAAO,GACP,KAAK,CAAC;AAGd;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,GAC1D,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsOptionalScalar.js

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

package/dist/types/boolean-logic/operators/IsPositiveNumber.d.ts

@@ -0,0 +1,11 @@
+import { NumberLike } from "inferred-types/dist/types/index";
+import { IsNegativeNumber } from "./IsNegativeNumber";
+/**
+ * **IsPositiveNumber**`<T>`
+ *
+ * Boolean operator which checks whether the value `T` is a _positive_ number.
+ *
+ * **Related:** `IsNegativeNumber`, `Abs`, `InvertNumericSign`
+ */
+export type IsPositiveNumber<T extends NumberLike> = IsNegativeNumber<T> extends true ? false : true;
+//# sourceMappingURL=IsPositiveNumber.d.ts.map

package/dist/types/boolean-logic/operators/IsPositiveNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsPositiveNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsPositiveNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,UAAU,IAAI,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GACnF,KAAK,GACL,IAAI,CAAC"}

package/dist/types/boolean-logic/operators/IsPositiveNumber.js

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

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

@@ -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/boolean-logic/operators/IsReadonlyArray.d.ts.map

@@ -0,0 +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/boolean-logic/operators/IsReadonlyArray.js

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

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

@@ -0,0 +1,12 @@
+import { Dictionary, ReadonlyKeys, IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **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 Dictionary ? IsEqual<ReadonlyKeys<T>, keyof T> : false;
+//# sourceMappingURL=IsReadonlyObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsReadonlyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsReadonlyObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAI,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAEtF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,GAClD,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACjC,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsReadonlyObject.js

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

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

@@ -0,0 +1,17 @@
+import { IfNever, Scalar } from "inferred-types/dist/types/index";
+/**
+ * **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, or symbol then it is
+ * a **scalar**. Arrays and records of any type are _not_ scalars.
+ *
+ * - Typically this resolves at design-time to true/false, however, in some
+ * cases a union type can not resolve until runtime and a `boolean` value will
+ * be returned.
+ *
+ * **Related:** `IsOptionalScalar`
+ */
+export type IsScalar<T> = IfNever<T, false, T extends Scalar ? true : false>;
+//# sourceMappingURL=IsScalar.d.ts.map

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

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

package/dist/types/boolean-logic/operators/IsScalar.js

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

package/dist/types/boolean-logic/operators/IsSingleChar.d.ts

@@ -0,0 +1,8 @@
+import { If, IsStringLiteral, Length } from "inferred-types/dist/types/index";
+/**
+ * **IsSingleChar**`<T>`
+ *
+ * Boolean operator which returns true/false/boolean based on whether `T` is a
+ */
+export type IsSingleChar<T> = T extends string ? Length<T> extends 1 ? true : If<IsStringLiteral<T>, false, boolean> : false;
+//# sourceMappingURL=IsSingleChar.d.ts.map

package/dist/types/boolean-logic/operators/IsSingleChar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsSingleChar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsSingleChar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,EAAE,EACF,eAAe,EACf,MAAM,EACP,MAAM,iCAAiC,CAAC;AAEzC;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC1C,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GACjB,IAAI,GACJ,EAAE,CACA,eAAe,CAAC,CAAC,CAAC,EAClB,KAAK,EACL,OAAO,CACR,GACH,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsSingleChar.js

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

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

@@ -0,0 +1,13 @@
+import { If, IfNever, IsStringLiteral, SingularNoun } from "inferred-types/dist/types/index";
+/**
+ * **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 ? If<IsStringLiteral<T>, IfNever<SingularNoun<T>, false, true>, boolean> : false;
+//# sourceMappingURL=IsSingularNoun.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsSingularNoun.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsSingularNoun.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG7F;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC5C,EAAE,CACA,eAAe,CAAC,CAAC,CAAC,EAClB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EACrC,OAAO,CACR,GACD,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsSingularNoun.js

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

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

@@ -0,0 +1,9 @@
+import { WidenUnion, IsUnion } from "inferred-types/dist/types/index";
+/**
+ * **IsString**
+ *
+ * Type utility which returns true/false based on whether `T` is a
+ * string (wide or narrow).
+ */
+export type IsString<T> = [IsUnion<T>] extends [true] ? WidenUnion<T> extends string ? true : string extends WidenUnion<T> ? boolean : false : [T] extends [string] ? true : false;
+//# sourceMappingURL=IsString.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsString.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,UAAU,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACnD,UAAU,CAAC,CAAC,CAAC,SAAS,MAAM,GAC1B,IAAI,GACJ,MAAM,SAAS,UAAU,CAAC,CAAC,CAAC,GAC1B,OAAO,GACP,KAAK,GACT,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsString.js

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

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

@@ -0,0 +1,9 @@
+import { IsEqual, IsNever } from "inferred-types/dist/types/index";
+/**
+ * **IsStringLiteral**`<T>`
+ *
+ * Boolean type utility which detects whether `T` is
+ * a string literal.
+ */
+export type IsStringLiteral<T> = IsNever<T> extends true ? false : T extends string ? IsEqual<T, string> extends true ? false : true : false;
+//# sourceMappingURL=IsStringLiteral.d.ts.map

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

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

package/dist/types/boolean-logic/operators/IsStringLiteral.js

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

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

@@ -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/boolean-logic/operators/IsSymbol.d.ts.map

@@ -0,0 +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/boolean-logic/operators/IsSymbol.js

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

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

@@ -0,0 +1,18 @@
+import { IsEqual, IsNever } from "inferred-types/dist/types/index";
+type Process<T, TNever> = [IsNever<T>] extends [true] ? TNever : [IsEqual<T, true>] extends [true] ? true : false;
+/**
+ * **IsTrue**`<T,[TNever]>`
+ *
+ * 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, TNever = never> = Process<T, TNever>;
+export {};
+//# sourceMappingURL=IsTrue.d.ts.map

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

@@ -0,0 +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,iCAAiC,CAAC;AAEpE,KAAK,OAAO,CAAC,CAAC,EACd,MAAM,IACF,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,MAAM,GACN,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,IAAI,GACJ,KAAK,CAAC;AAER;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,MAAM,GAAG,KAAK,IACZ,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/IsTrue.js

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

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

@@ -0,0 +1,13 @@
+import { If, IsNumericLiteral, IsStringLiteral, IsFalse, IsTrue, SomeEqual } from "inferred-types/dist/types/index";
+/**
+ * **IsTruthy**`<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 : If<IsStringLiteral<T>, true, boolean> : [T] extends [number] ? If<IsNumericLiteral<T>, If<SomeEqual<[0, -0], T>, false, true>, boolean> : [T] extends [boolean] ? If<IsFalse<T>, false, If<IsTrue<T>, true, boolean>> : If<SomeEqual<[null, undefined, typeof NaN], T>, false, boolean>;
+//# sourceMappingURL=IsTruthy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsTruthy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTruthy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,EAAE,EACF,gBAAgB,EAChB,eAAe,EACf,OAAO,EACP,MAAM,EACN,SAAS,EACV,MAAM,iCAAiC,CAAC;AAGzC;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IACpB;IAAC,CAAC;CAAC,SAAS,CAAC,MAAM,CAAC,GAChB,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,GAC9D,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAClB,EAAE,CACA,gBAAgB,CAAC,CAAC,CAAC,EACnB,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,EAAG,KAAK,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,GAClD,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GACnB,EAAE,CACA,OAAO,CAAC,CAAC,CAAC,EACV,KAAK,EACL,EAAE,CACA,MAAM,CAAC,CAAC,CAAC,EACT,IAAI,EACJ,OAAO,CACR,CACF,GACH,EAAE,CACA,SAAS,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC,EAAC,CAAC,CAAC,EAC1C,KAAK,EACL,OAAO,CACR,CAAC"}

package/dist/types/boolean-logic/operators/IsTruthy.js

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

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

@@ -0,0 +1,17 @@
+import { IsNever } from "./IsNever";
+type Process<T> = [IsNever<T>] extends [true] ? false : T extends readonly unknown[] ? number extends T["length"] ? false : true : false;
+/**
+ * **IsTuple**`<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> = Process<T> extends boolean ? Process<T> : never;
+export {};
+//# sourceMappingURL=IsTuple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsTuple.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,KAAK,GACL,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACxB,KAAK,GACL,IAAI,GACN,KAAK,CAAC;AAGV;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,GACjD,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsTuple.js

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

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

@@ -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/boolean-logic/operators/IsUndefined.d.ts.map

@@ -0,0 +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/boolean-logic/operators/IsUndefined.js

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

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

@@ -0,0 +1,9 @@
+import { UnionToTuple, IsNever, IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **IsUnion**`<T>`
+ *
+ * Type utility which returns a boolean flag indicating whether the
+ * given `T` is typed as a _union_ type.
+ */
+export type IsUnion<T> = [IsNever<UnionToTuple<T>>] extends [true] ? false : IsEqual<T, boolean> extends true ? false : UnionToTuple<T>["length"] extends 1 ? false : true;
+//# sourceMappingURL=IsUnion.d.ts.map

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

@@ -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,OAAO,EAAG,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAGnF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAChE,KAAK,GACL,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAChC,KAAK,GACL,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACjC,KAAK,GACL,IAAI,CAAC"}

package/dist/types/boolean-logic/operators/IsUnion.js

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

package/dist/types/boolean-logic/operators/IsUnionArray.d.ts

@@ -0,0 +1,9 @@
+import { ElementOf, IsEqual, IsUnion } from "inferred-types/dist/types/index";
+/**
+ * **IsUnionArray**`<T>`
+ *
+ * Boolean operator which tests whether `T` is an array of
+ * a _union type_.
+ */
+export type IsUnionArray<T> = T extends readonly any[] ? IsEqual<T["length"], number> extends true ? IsUnion<ElementOf<T>> extends true ? true : false : false : false;
+//# sourceMappingURL=IsUnionArray.d.ts.map

package/dist/types/boolean-logic/operators/IsUnionArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsUnionArray.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsUnionArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAI9E;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,EAAE,GAClD,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,IAAI,GACzC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,KAAK,GACP,KAAK,GACL,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsUnionArray.js

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

package/dist/types/boolean-logic/operators/IsUnset.d.ts

@@ -0,0 +1,9 @@
+import { Unset, IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **IsUnset**`<T>`
+ *
+ * Boolean operator which reports true/false on whether
+ * `T` is the value `Unset`.
+ */
+export type IsUnset<T> = IsEqual<T, Unset>;
+//# sourceMappingURL=IsUnset.d.ts.map

package/dist/types/boolean-logic/operators/IsUnset.d.ts.map

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

package/dist/types/boolean-logic/operators/IsUnset.js

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

package/dist/types/boolean-logic/operators/IsUrl.d.ts

@@ -0,0 +1,34 @@
+import { And, Extends, GetUrlPath, GetUrlSource, IsNever, IsStringLiteral, NetworkProtocol, NetworkProtocolPrefix, Not, Or } from "inferred-types/dist/types/index";
+export type HasUrlPath<T extends string> = And<[
+    Not<IsNever<GetUrlPath<T>>>,
+    Or<[
+        Extends<GetUrlPath<T>, "">,
+        Extends<GetUrlPath<T>, `/${string}`>,
+        string extends GetUrlPath<T> ? true : false
+    ]>
+]>;
+export type HasUrlSource<T extends string> = Not<IsNever<GetUrlSource<T>>>;
+export type HasNetworkProtocolReference<TTest extends string, TProto extends NetworkProtocol> = Extends<TTest, `${NetworkProtocolPrefix<TProto>}${string}`>;
+/**
+ * **IsUrl**`<TTest,[TProtocol]>`
+ *
+ * Boolean operator which tests whether the passed in `TTest`
+ * is a valid URL.
+ *
+ * **Note:** by default it will only check the `https` protocol
+ * but you can choose any set `TProtocol` with anything from `NetworkProtocol`
+ * if you like.
+ *
+ * **Note:** you can add **optional** as a part of the protocol union
+ * type and it will then accept the protocols you've selected or a URL
+ * without a protocol.
+ */
+export type IsUrl<TTest, TProtocol extends NetworkProtocol | "optional" = "https"> = TTest extends string ? IsStringLiteral<TTest> extends true ? And<[
+    Or<[
+        HasNetworkProtocolReference<TTest, TProtocol extends NetworkProtocol ? TProtocol : "https">,
+        Extends<"optional", TProtocol>
+    ]>,
+    HasUrlPath<TTest>,
+    HasUrlSource<TTest>
+]> : boolean : false;
+//# sourceMappingURL=IsUrl.d.ts.map

package/dist/types/boolean-logic/operators/IsUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsUrl.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,OAAO,EACP,UAAU,EACV,YAAY,EACZ,OAAO,EACP,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,GAAG,EACH,EAAE,EACH,MAAM,iCAAiC,CAAC;AAGzC,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,GAAG,CAAC;IAC7C,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,EAAE,CAAC;QACD,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAC,EAAE,CAAC;QACzB,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAC,IAAI,MAAM,EAAE,CAAC;QACnC,MAAM,SAAS,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK;KAC5C,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3E,MAAM,MAAM,2BAA2B,CACrC,KAAK,SAAS,MAAM,EACpB,MAAM,SAAS,eAAe,IAC5B,OAAO,CAAC,KAAK,EAAE,GAAG,qBAAqB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAAC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,CACf,KAAK,EACL,SAAS,SAAS,eAAe,GAAG,UAAU,GAAG,OAAO,IACtD,KAAK,SAAS,MAAM,GACtB,eAAe,CAAC,KAAK,CAAC,SAAS,IAAI,GACjC,GAAG,CAAC;IACF,EAAE,CAAC;QACD,2BAA2B,CACzB,KAAK,EACL,SAAS,SAAS,eAAe,GAC7B,SAAS,GACT,OAAO,CACZ;QACD,OAAO,CAAC,UAAU,EAAE,SAAS,CAAC;KAC/B,CAAC;IACF,UAAU,CAAC,KAAK,CAAC;IACjB,YAAY,CAAC,KAAK,CAAC;CACpB,CAAC,GACF,OAAO,GACV,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsUrl.js

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

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

@@ -0,0 +1,15 @@
+import { Contains, DotPathFor, IsContainer, IsDotPath, IsEqual, IsObjectLiteral, IsTuple } from "inferred-types/dist/types/index";
+/**
+ * **IsValidDotPath**`<TContainer,TDotPath>`
+ *
+ * - if `TContainer` is a literal value than it will validate against
+ * the _actual_ dot paths which are valid for the container.
+ * - if `TContainer` is a wide container type then it will generically validate
+ * whether the dot path _could_ be a valid path.
+ * - if `TContainer` isn't a container at all then the only valid dot path is
+ * an empty string
+ * - a DotPath of either "" or null is _always_ valid because these are _identity_
+ * paths that simply return the container.
+ */
+export type IsValidDotPath<TContainer, TDotPath extends string | null> = IsEqual<TDotPath, null> extends true ? true : IsObjectLiteral<TContainer> extends true ? IsTuple<TContainer> extends true ? Contains<DotPathFor<TContainer>, TDotPath> : IsContainer<TContainer> extends true ? IsDotPath<TDotPath> : IsEqual<TDotPath, ""> extends true ? true : false : IsContainer<TContainer> extends true ? IsDotPath<TDotPath> : IsEqual<TDotPath, ""> extends true ? true : false;
+//# sourceMappingURL=IsValidDotPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsValidDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsValidDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,UAAU,EACV,WAAW,EACX,SAAS,EACT,OAAO,EACP,eAAe,EACf,OAAO,EACR,MAAM,iCAAiC,CAAC;AAGzC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,CACxB,UAAU,EACV,QAAQ,SAAS,MAAM,GAAG,IAAI,IAC5B,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,IAAI,GACtC,IAAI,GACJ,eAAe,CAAC,UAAU,CAAC,SAAS,IAAI,GACxC,OAAO,CAAC,UAAU,CAAC,SAAS,IAAI,GAC9B,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,GAC1C,WAAW,CAAC,UAAU,CAAC,SAAS,IAAI,GAClC,SAAS,CAAC,QAAQ,CAAC,GACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,KAAK,GACT,WAAW,CAAC,UAAU,CAAC,SAAS,IAAI,GACpC,SAAS,CAAC,QAAQ,CAAC,GACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsValidDotPath.js

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