inferred-types 0.52.15 → 0.53.0

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

@@ -1,15 +0,0 @@
-import { Contains, DotPathFor, IsContainer, IsDotPath, IsEqual, IsObjectLiteral, IsTuple } from "inferred-types/types";
-/**
- * **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

@@ -1 +0,0 @@
-{"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,sBAAsB,CAAC;AAG9B;;;;;;;;;;;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

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

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

@@ -1,11 +0,0 @@
-import { Abs, AsNumber, Container, ExplicitlyEmptyObject, IsEqual, IsNegativeNumber, IsStringLiteral, IsObjectLiteral, IsTuple, Dictionary, Tuple, NumericKeys, TupleToUnion } from "inferred-types/types";
-/**
- * **IsValidIndex**`<TContainer,TKey>`
- *
- * Provides a boolean check on whether `TKey` is a valid key for `TContainer`.
- *
- * - valid responses are `true` or `false` if literal types found; otherwise `boolean`
- * - negative indexes are allowed when `TContainer` is a tuple
- */
-export type IsValidIndex<TContainer extends Container, TKey extends PropertyKey> = TContainer extends Tuple ? IsTuple<TContainer> extends true ? TKey extends number ? IsNegativeNumber<AsNumber<TKey>> extends true ? Abs<AsNumber<TKey>> extends number ? [Abs<AsNumber<TKey>>] extends [TupleToUnion<NumericKeys<TContainer>>] ? true : false : never : [TKey] extends [TupleToUnion<NumericKeys<TContainer>>] ? true : false : false : boolean : TContainer extends Dictionary ? IsEqual<TContainer, ExplicitlyEmptyObject> extends true ? false : [IsObjectLiteral<TContainer>] extends [true] ? [IsStringLiteral<TKey>] extends [true] ? [TKey] extends [keyof TContainer] ? true : false : [TKey] extends [symbol] ? [TKey] extends [keyof TContainer] ? true : false : false : boolean : false;
-//# sourceMappingURL=IsValidIndex.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsValidIndex.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsValidIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,SAAS,EACT,qBAAqB,EACrB,OAAO,EACP,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,KAAK,EACL,WAAW,EACX,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CACtB,UAAU,SAAS,SAAS,EAC5B,IAAI,SAAS,WAAW,IACtB,UAAU,SAAS,KAAK,GAC1B,OAAO,CAAC,UAAU,CAAC,SAAS,IAAI,GAC9B,IAAI,SAAS,MAAM,GACjB,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,GAC3C,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,GAChC,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,GACnE,IAAI,GACJ,KAAK,GACP,KAAK,GACP,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,GACpD,IAAI,GACJ,KAAK,GACT,KAAK,GACP,OAAO,GAET,UAAU,SAAS,UAAU,GAC3B,OAAO,CAAC,UAAU,EAAE,qBAAqB,CAAC,SAAS,IAAI,GACnD,KAAK,GACL,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC5C,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACpC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,GAC/B,IAAI,GACJ,KAAK,GACP,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GACrB,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,GAC/B,IAAI,GACJ,KAAK,GACP,KAAK,GACT,OAAO,GACb,KAAK,CAAC"}

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

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

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

@@ -1,14 +0,0 @@
-import { If, IsEqual, ObjectKey, RemoveIndexKeys, Retain, UnionToTuple } from "inferred-types/types";
-type _Keys<T extends object> = UnionToTuple<keyof RemoveIndexKeys<T>> extends readonly ObjectKey[] ? UnionToTuple<keyof RemoveIndexKeys<T>> : never;
-type _Len<T extends object> = _Keys<T> extends ObjectKey[] ? _Keys<T>["length"] : 0;
-type _Validate<T extends object> = "value" extends keyof T ? true : false;
-/**
- * **IsVueRef**`<T>`
- *
- * Boolean type utility that detects whether the type passed in
- * is a VueJS `Ref<...>` type or this library's `VueRef<...>`
- * (which serves as a lightweight proxy type for Vue's `Ref`).
- */
-export type IsVueRef<T> = T extends object ? If<IsEqual<_Len<T>, 0>, false, Retain<_Keys<T>, string>["length"] extends 1 ? _Validate<T> : false> : false;
-export {};
-//# sourceMappingURL=IsVueRef.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsVueRef.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsVueRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,EAAE,EAAG,OAAO,EAAG,SAAS,EAAG,eAAe,EAAI,MAAM,EAAG,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAI5G,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,SACrE,SAAS,SAAS,EAAE,GAChB,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,GACtC,KAAK,CAAC;AAEV,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,SAAS,EAAE,GACtD,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAClB,CAAC,CAAC;AAEN,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI,OAAO,SAAS,MAAM,CAAC,GACxD,IAAI,GACJ,KAAK,CAAA;AAGP;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GACxC,EAAE,CACA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,KAAK,EACL,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACxC,SAAS,CAAC,CAAC,CAAC,GACZ,KAAK,CACR,GACH,KAAK,CAAC"}

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

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

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

@@ -1,51 +0,0 @@
-import { Container, ErrorCondition, IsEqual, IsNever, IsVueRef, IsWideUnion, ObjectKey, ProxyError, RemoveIndexKeys, Scalar, Throw, UnionToTuple } from "inferred-types/types";
-/**
- * **IsWideScalar**`<T>`
- *
- * Boolean operator which validates whether or not `T`
- * is considered a "wide type" which extends `Scalar`
- */
-export type IsWideScalar<T> = [T] extends [Scalar] ? [
-    IsEqual<T, string, true, false>,
-    IsEqual<T, number, true, false>,
-    IsEqual<T, boolean, true, false>,
-    IsEqual<T, null, true, false>,
-    IsEqual<T, symbol, true, false>
-] extends [
-    false,
-    false,
-    false,
-    false,
-    false
-] ? false : true : false;
-type _Keys<T extends object> = UnionToTuple<keyof RemoveIndexKeys<T>>;
-type GetKeys<T extends object> = IsVueRef<T> extends true ? ["value"] : _Keys<T> extends [symbol] ? ObjectKey[] : _Keys<T> extends [] ? UnionToTuple<keyof T> extends [ObjectKey] ? (keyof T)[] : ObjectKey[] : _Keys<T>;
-/**
- * **IsWideContainer**`<T>`
- *
- * Boolean operator which tests wether `T` is a `Container` and
- * also a `wide type` (aka, not a literal).
- */
-export type IsWideContainer<T> = T extends Container ? T extends readonly unknown[] ? "length" extends keyof T ? IsEqual<T["length"], number> extends true ? true : false : false : T extends object ? "length" extends keyof GetKeys<T> ? IsEqual<GetKeys<T>["length"], number> extends true ? true : false : false : false : false;
-type InvalidNever = Throw<"invalid-never", `The value of T when calling IsWideType<T> was "never" which makes the comparison invalid! If you want prefer to instead allow this condition then set the TNever generic to true or false depending on your preferred outcome`, "IsWideType", {
-    library: "inferred-types/constants";
-}>;
-/**
- * **IsWideType**`<T, [TNever]>`
- *
- * Identifies types which are "wide" (and have a narrow variant):
- *
- * - string, number, and boolean types
- * - `string[]`, `number[]` array types
- * - wide union types like `string | number`
- *
- * **Note:**
- * - types such as `null` and `undefined` **are** considered wide.
- * - If the `T` passed in is _never_ the result of this operation is
- * ErrorCondition<"invalid-never"> but this can be made into whatever
- * you like by setting the `TNever` generic.
- * - If an ErrorCondition is in `T` then it will be bubbled up
- */
-export type IsWideType<T, TNever = InvalidNever> = [IsNever<T>] extends [true] ? TNever : [T] extends [ErrorCondition] ? ProxyError<T, "IsWideType"> : IsWideScalar<T> extends true ? true : IsWideContainer<T> extends true ? true : IsWideUnion<T> extends true ? true : false;
-export {};
-//# sourceMappingURL=IsWideType.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsWideType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsWideType.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,cAAc,EACd,OAAO,EACP,OAAO,EACP,QAAQ,EACR,WAAW,EACX,SAAS,EACT,UAAU,EACV,eAAe,EACf,MAAM,EACN,KAAK,EACL,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAC9C;IACE,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC,KAAK,CAAC;IAC9B,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC,KAAK,CAAC;IAC9B,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC,KAAK,CAAC;IAC/B,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAC,KAAK,CAAC;IAC5B,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC,KAAK,CAAC;CAC/B,SAAS;IACR,KAAK;IAAE,KAAK;IAAE,KAAK;IAAE,KAAK;IAAE,KAAK;CAClC,GACG,KAAK,GACL,IAAI,GACV,KAAK,CAAC;AAER,KAAK,KAAK,CACR,CAAC,SAAS,MAAM,IACZ,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7C,KAAK,OAAO,CACV,CAAC,SAAS,MAAM,IACd,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1B,CAAC,OAAO,CAAC,GACT,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACvB,SAAS,EAAE,GACX,KAAK,CAAC,CAAC,CAAC,SAAS,EAAE,GACjB,YAAY,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,GACvC,CAAC,MAAM,CAAC,CAAC,EAAE,GACX,SAAS,EAAE,GACb,KAAK,CAAC,CAAC,CAAC,CAAC;AAGf;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAClD,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,QAAQ,SAAS,MAAM,CAAC,GACtB,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,IAAI,GACvC,IAAI,GACJ,KAAK,GACP,KAAK,GACP,CAAC,SAAS,MAAM,GACd,QAAQ,SAAS,MAAM,OAAO,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,IAAI,GAChD,IAAI,GACJ,KAAK,GACP,KAAK,GACP,KAAK,GACT,KAAK,CAAC;AAIR,KAAK,YAAY,GAAG,KAAK,CACvB,eAAe,EACf,+NAA+N,EAC/N,YAAY,EACZ;IAAE,OAAO,EAAE,0BAA0B,CAAA;CAAC,CACvC,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,EACD,MAAM,GAAG,YAAY,IACnB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,MAAM,GACN,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,GAC5B,UAAU,CAAC,CAAC,EAAC,YAAY,CAAC,GAC3B,YAAY,CAAC,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/B,IAAI,GACJ,WAAW,CAAC,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,KAAK,CAAC"}

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

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

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

@@ -1,15 +0,0 @@
-import { IsUnion, IsWideType, UnionToTuple } from "inferred-types/types";
-type Process<T extends readonly unknown[]> = {
-    [K in keyof T]: IsWideType<T[K]>;
-};
-/**
- * **IsWideUnion**`<T>`
- *
- * Boolean utility which checks whether `T` is both a _union type_
- * and that it's elements are all considered _wide types_.
- *
- * **Related:** `IsNonLiteralUnion`
- */
-export type IsWideUnion<T> = [IsUnion<T>] extends [true] ? [Process<UnionToTuple<T>>] extends [readonly true[]] ? true : false : false;
-export {};
-//# sourceMappingURL=IsWideUnion.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsWideUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsWideUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,UAAU,EACV,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B,KAAK,OAAO,CACV,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B;KACD,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACtD,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC,GAClD,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

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

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

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

@@ -1,20 +0,0 @@
-import { UnionToTuple, IsUnion, Contains, ErrorCondition } from "inferred-types/types";
-type AnyError<T extends readonly unknown[]> = Contains<T, ErrorCondition> extends true ? true : Contains<T, Error> extends true ? true : false;
-/**
- * **MaybeError**`<T>`
- *
- * Tests whether T is part of a union and if it is then
- * tests whether any element of that union is an error, where
- * an error is:
- *
- * - `ErrorCondition`
- * - extends JS's `Error` class
- *
- * MaybeError returns **false** if there _is_ an error; it is
- * positive only when it _might_ be an error.
- *
- * **Related**: `IsError`, `IsErrorCondition`
- */
-export type MaybeError<T> = IsUnion<T> extends true ? AnyError<UnionToTuple<T>> : false;
-export {};
-//# sourceMappingURL=MaybeError.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"MaybeError.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/MaybeError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGvF,KAAK,QAAQ,CACX,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B,QAAQ,CAAC,CAAC,EAAE,cAAc,CAAC,SAAS,IAAI,GAC1C,IAAI,GACJ,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,IAAI,GAC/B,IAAI,GACJ,KAAK,CAAC;AAGR;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACjD,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACzB,KAAK,CAAC"}

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

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

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

@@ -1,13 +0,0 @@
-import { AfterFirst, First, IsEqual } from "inferred-types/types";
-/**
- * **NarrowlyContains**`<TList, TContains>`
- *
- * Type utility which checks whether a type `T` exists within an
- * array `A`. Result is `true` if `T` _extends_ any element in
- * `A` making it match widely against `A`. If you prefer a wider
- * match you can use `Contains<T,A>` instead.
- *
- * **Related:** `Contains`, `ContainsAll`, `ContainsSome`
- */
-export type NarrowlyContains<TList extends readonly unknown[], TContains> = IsEqual<First<TList>, TContains> extends true ? true : [] extends AfterFirst<TList> ? false : NarrowlyContains<AfterFirst<TList>, TContains>;
-//# sourceMappingURL=NarrowlyContains.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"NarrowlyContains.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/NarrowlyContains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAG,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,CAC1B,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,SAAS,IACP,OAAO,CACT,KAAK,CAAC,KAAK,CAAC,EACZ,SAAS,CACV,SAAS,IAAI,GACV,IAAI,GACJ,EAAE,SAAS,UAAU,CAAC,KAAK,CAAC,GAC5B,KAAK,GACL,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC"}

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

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

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

@@ -1,71 +0,0 @@
-import { AfterFirst, And, BeforeLast, First, GetUrlQueryParams, HasOtherCharacters, Ip4Address, Ip4Octet, Ip6AddressFull, Ip6AddressLoose, Ip6GroupExpansion, IsGreaterThan, IsLessThan, IsStringLiteral, Last, Length, LowerAlphaChar, NumericChar, Split } from "inferred-types/types";
-/**
- * **IsIp4Octet**`<T>`
- *
- * Checks whether `T` is a valid IPv4Octet.
- */
-export type IsIp4Octet<T> = T extends number ? IsIp4Octet<`${T}`> : T extends string ? IsStringLiteral<T> extends true ? T extends Ip4Octet ? true : false : boolean : false;
-/**
- * **IsHexadecimal**`<T>`
- *
- * Boolean operator which tests the string `T` to ensure
- * all characters are valid hexadecimal digits/chars.
- */
-export type IsHexadecimal<T> = T extends string ? IsStringLiteral<T> extends true ? HasOtherCharacters<Lowercase<T>, NumericChar | "a" | "b" | "c" | "d" | "e" | "f"> extends true ? false : true : boolean : false;
-/**
- * **IsIp6HexGroup**`<T>`
- *
- * Tests whether `T` is a valid hexadecimal group for an IP6
- * Group. To be valid means:
- *
- * - each digit must be a hexadecimal digit
- * - There will be between 1 and 4 digits
- */
-export type IsIp6HexGroup<T> = T extends string ? IsStringLiteral<T> extends true ? IsLessThan<Length<T>, 5> extends true ? IsGreaterThan<Length<T>, 0> extends true ? IsHexadecimal<T> : false : false : boolean : false;
-type DeepOctetCheck<T extends readonly string[]> = [] extends T ? true : IsIp4Octet<First<T>> extends true ? DeepOctetCheck<AfterFirst<T>> : false;
-/**
- * **IsIp4Address**`<T>`
- *
- * Validates that `T` is a _valid_ IPv4 address by:
- *
- * - making sure the basic `${number}.${number}.${number}.${number}`
- * - and then that each octet is a valid number between 0 and 255
- */
-export type IsIp4Address<T> = T extends string ? IsStringLiteral<T> extends true ? T extends Ip4Address ? Split<T, ".">["length"] extends 4 ? DeepOctetCheck<Split<T, ".">> : false : false : boolean : never;
-type _EachGroup<T extends readonly string[]> = {
-    [K in keyof T]: IsIp6HexGroup<T[K]>;
-};
-export type IsIp6Address<T> = T extends string ? IsStringLiteral<T> extends true ? T extends Ip6AddressFull ? And<_EachGroup<Split<T, ":">>> : Ip6GroupExpansion<T> extends Ip6AddressFull ? And<_EachGroup<Split<Ip6GroupExpansion<T>, ":">>> : false : boolean : false;
-/**
- * **IsIpAddress**`<T>`
- *
- * A boolean operator which validates that `T` is either a V4 or V6 IP
- * Address.
- */
-export type IsIpAddress<T> = T extends string ? IsStringLiteral<T> extends true ? IsIp4Address<T> extends true ? true : IsIp6Address<T> extends true ? true : false : boolean : false;
-/**
- * **HasIpAddress**`<T>`
- *
- * a boolean operator which tests whether a string literal `T` has an IP address
- * in it.
- */
-export type HasIpAddress<T> = T extends string ? IsStringLiteral<T> extends true ? T extends `${string}${infer IpAddress extends Ip4Address | Ip6AddressLoose}${string}` ? IsIp4Address<IpAddress> : false : boolean : never;
-type _TLD<T extends string> = Length<T> extends 0 ? false : Length<T> extends 1 ? false : HasOtherCharacters<Lowercase<T>, LowerAlphaChar> extends true ? false : true;
-type _BeforeTLD<T extends readonly string[]> = [] extends T ? true : HasOtherCharacters<Lowercase<First<T>>, LowerAlphaChar | NumericChar | "-" | "_"> extends true ? false : _BeforeTLD<AfterFirst<T>>;
-/**
- * **IsDomainName**`<T>`
- *
- * Checks whether `T` is a valid DNS domain name.
- */
-export type IsDomainName<T> = T extends string ? IsStringLiteral<T> extends true ? T extends `${string}.${string}` ? _TLD<Last<Split<T, ".">>> extends true ? _BeforeTLD<BeforeLast<Split<T, ".">>> extends true ? true : false : false : false : boolean : never;
-/**
- * **HasQueryParameter**`<T,P>`
- *
- * Checks whether the URL in `T` has a query parameter with the key of `P`.
- */
-export type HasQueryParameter<T extends string, P extends string> = And<[
-    IsStringLiteral<T>,
-    IsStringLiteral<P>
-]> extends true ? GetUrlQueryParams<T> extends `${string}${P}=${string}` ? true : false : boolean;
-export {};
-//# sourceMappingURL=Network-operators.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Network-operators.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Network-operators.ts"],"names":[],"mappings":"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"}

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

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

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

@@ -1,8 +0,0 @@
-import { IsEqual } from "inferred-types/types";
-/**
- * **NotEqual**`<A,B>`
- *
- * Boolean utility to determine whether two values are **not** equal.
- */
-export type NotEqual<A, B> = IsEqual<A, B> extends true ? false : true;
-//# sourceMappingURL=NotEqual.d.ts.map

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

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

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

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

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

@@ -1,8 +0,0 @@
-import { If, IsNotEqual, Length } from "inferred-types/types";
-/**
- * **NotLength**`<T>`
- *
- * Boolean operator which detects whether `T` is _not_ a certain length.
- */
-export type NotLength<T extends readonly unknown[], U extends number> = If<IsNotEqual<Length<T>, U>, true, false>;
-//# sourceMappingURL=NotLength.d.ts.map

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

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

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

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

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

@@ -1,32 +0,0 @@
-import { IsStringLiteral, GetPhoneCountryCode, IsTrue, PhoneNumber, PhoneCountryCode, IsErrorCondition, MaybeError } from "inferred-types/types";
-/**
- * **IsPhoneNumber**`<T>`
- *
- * Boolean operator which tests whether `T` has a
- * type that supports it being a phone number.
- *
- * **Note:**
- *
- * - this utility relies on the using the `PhoneNumber<T>` validation
- * technique to determine that whether it is a phone number but whereas
- * this utility returns `T` _or_ and `ErrorCode` this produces a boolean
- * outcome.
- *
- * **Related:** `PhoneNumber`, `HasPhoneCountryCode`
- */
-export type IsPhoneNumber<T extends string | number> = IsErrorCondition<PhoneNumber<T>> extends true ? false : MaybeError<PhoneNumber<T>> extends true ? boolean : true;
-/**
- * **HasPhoneCountryCode**`<T>`
- *
- * Boolean operator which validates whether the passed in `T` has a country code leading it (ignoring any leading
- * whitespace):
- *
- * - by default, the country code is not only parsed out of the phone number but also validated against an world
- * wide index of valid country codes
- * - if you want to just validate that user _attempted_ to express a country code then you can change the check by
- * setting `TExplicit` to **false**.
- *
- * **Related:** `IsPhoneNumber`, `PhoneNumber`
- */
-export type HasPhoneCountryCode<TPhone, TExplicit extends boolean = true> = TPhone extends string ? IsStringLiteral<TPhone> extends true ? IsTrue<TExplicit> extends true ? GetPhoneCountryCode<TPhone> extends PhoneCountryCode ? true : false : GetPhoneCountryCode<TPhone> extends "" ? false : true : boolean : false;
-//# sourceMappingURL=PhoneOperators.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"PhoneOperators.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/PhoneOperators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,MAAM,EACN,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACX,MAAM,sBAAsB,CAAC;AAI9B;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAChG,KAAK,GACL,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACvC,OAAO,GACP,IAAI,CAAC;AAGT;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,CAC7B,MAAM,EACN,SAAS,SAAS,OAAO,GAAG,IAAI,IAC9B,MAAM,SAAS,MAAM,GACvB,eAAe,CAAC,MAAM,CAAC,SAAS,IAAI,GAChC,MAAM,CAAC,SAAS,CAAC,SAAS,IAAI,GAC5B,mBAAmB,CAAC,MAAM,CAAC,SAAS,gBAAgB,GAClD,IAAI,GACJ,KAAK,GACP,mBAAmB,CAAC,MAAM,CAAC,SAAS,EAAE,GACpC,KAAK,GACL,IAAI,GACZ,OAAO,GACP,KAAK,CAAC"}

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

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

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

@@ -1,9 +0,0 @@
-import { TypedFunction } from "inferred-types/types";
-/**
- * **Returns**`<TFn,TExpected>`
- *
- * Boolean type utility which detects whether `TFn` is a function
- * and _extends_ `TExpected` in it's return type.
- */
-export type Returns<TFn, TExpected> = TFn extends TypedFunction ? ReturnType<TFn> extends TExpected ? true : false : false;
-//# sourceMappingURL=Returns.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Returns.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Returns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,GAAG,EACH,SAAS,IACP,GAAG,SAAS,aAAa,GACzB,UAAU,CAAC,GAAG,CAAC,SAAS,SAAS,GAC/B,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

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

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

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

@@ -1,11 +0,0 @@
-import { IsBoolean, TypedFunction } from "inferred-types/types";
-/**
- * **ReturnsBoolean**`<T>`
- *
- * Type utility which indicates whether the _return value_ of `T` is
- * a `false` value. Possible values are `true`, `false`, or `boolean`.
- *
- * Note: any non-functions passed in as `T` are always a **false** value
- */
-export type ReturnsBoolean<T> = T extends TypedFunction ? IsBoolean<ReturnType<T>> : false;
-//# sourceMappingURL=ReturnsBoolean.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ReturnsBoolean.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAI,SAAS,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GACnD,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACxB,KAAK,CAAC"}

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

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

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

@@ -1,11 +0,0 @@
-import { IsEqual, TypedFunction } from "inferred-types/types";
-/**
- * **ReturnsTrue**`<T>`
- *
- * Type utility which indicates whether the _return value_ of `T` is
- * a `false` value. Possible values are `true`, `false`, or `boolean`.
- *
- * Note: any non-functions passed in as `T` are removed from the result set
- */
-export type ReturnsFalse<T> = T extends TypedFunction ? ReturnType<T> extends false ? true : IsEqual<ReturnType<T>, boolean> extends true ? boolean : false : false;
-//# sourceMappingURL=ReturnsFalse.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ReturnsFalse.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GACjD,UAAU,CAAC,CAAC,CAAC,SAAS,KAAK,GACzB,IAAI,GACJ,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,OAAO,GAAG,KAAK,GAChE,KAAK,CAAC"}

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

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

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

@@ -1,12 +0,0 @@
-import { TypedFunction } from "inferred-types/types";
-/**
- * **ReturnsTrue**`<T>`
- *
- * Type utility which indicates whether the _return value_ of `T` is
- * a `true` value. Return value are always either `true` or `false`.
- *
- * Note: any non-functions passed in as `T` are always a **false** value
- * and so is a `boolean` value
- */
-export type ReturnsTrue<T> = T extends TypedFunction ? ReturnType<T> extends true ? true : false : false;
-//# sourceMappingURL=ReturnsTrue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ReturnsTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGtD;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GAChD,UAAU,CAAC,CAAC,CAAC,SAAS,IAAI,GACxB,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

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

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

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

@@ -1,12 +0,0 @@
-import { IfEqual, AfterFirst, First } from "inferred-types/types";
-/**
- * **SomeEqual**`<TVal, TList>`
- *
- * A type utility which tests whether `TVal` is exactly equal to an array of values
- * stored in `TList`. Possible results are `true`, `false`. A wide `boolean` type
- * is not possible as equality operator can always be evaluated at design time.
- *
- * **See Also:** `SomeExtend` and `IfSomeEqual`
- */
-export type SomeEqual<TList extends readonly unknown[], TVal> = [] extends TList ? false : IfEqual<TVal, First<TList>, true, SomeEqual<AfterFirst<TList>, TVal>>;
-//# sourceMappingURL=SomeEqual.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SomeEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/SomeEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,UAAU,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,CACrB,KAAK,SAAS,SAAS,OAAO,EAAE,EAC9B,IAAI,IACF,EAAE,SAAS,KAAK,GAClB,KAAK,GACL,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC"}

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

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

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

@@ -1,11 +0,0 @@
-import { AfterFirst, First, If, Extends } from "inferred-types/types";
-type SomeAcc<TList extends readonly unknown[], TExtend> = [] extends TList ? false : If<Extends<First<TList>, TExtend>, true, SomeAcc<AfterFirst<TList>, TExtend>>;
-/**
- * **SomeExtend**`<TList, TExtend>`
- *
- * Boolean util which checks whether **some** of the elements
- * in `TList` _extend_ `TExtend`.
- */
-export type SomeExtend<TList extends readonly unknown[], TExtend> = SomeAcc<TList, TExtend>;
-export {};
-//# sourceMappingURL=SomeExtend.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SomeExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/SomeExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEtE,KAAK,OAAO,CACV,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,EAAE,CACA,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAC9B,IAAI,EACJ,OAAO,CACL,UAAU,CAAC,KAAK,CAAC,EACjB,OAAO,CACR,CACF,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CACpB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,OAAO,CAAC,KAAK,EAAC,OAAO,CAAC,CAAC"}

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

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

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

@@ -1,24 +0,0 @@
-import { AsString, IsWideType, TupleToUnion, IsEqual } from "inferred-types/types";
-type Check<TValue extends string, TComparator extends string | number> = TValue extends `${TComparator}${string}` ? true : false;
-type Process<TValue extends string, TComparator extends string | number | readonly string[]> = TComparator extends readonly string[] ? Check<[
-    TValue
-] extends [number] ? `${TValue}` : TValue, TupleToUnion<TComparator>> : Check<[
-    TValue
-] extends [number] ? `${TValue}` : TValue, AsString<TComparator>>;
-/**
- * **StartsWith**<TValue, TComparator>
- *
- * A type utility which checks whether `TValue` _starts with_ the
- * value of `TComparator`.
- *
- * - numeric values for `TValue` will be converted into string literals
- * prior to comparison
- * - a tuple value in `TComparator` is allowed and will test whether
- * _any_ of the patterns start `TValue`
- * - a union type for `TComparator` is allowed so long as it's only for a single character
- *    - this can be much more type efficient for unions with lots of characters
- *    - if you need larger pattern matches then use a Tuple for `TComparator`
- */
-export type StartsWith<TValue extends string | number, TComparator extends string | number | readonly string[]> = [IsWideType<TValue>] extends [true] ? boolean : [IsWideType<TComparator>] extends [true] ? boolean : IsEqual<Process<AsString<TValue>, TComparator>, boolean> extends true ? true : Process<AsString<TValue>, TComparator>;
-export {};
-//# sourceMappingURL=StartsWith.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"StartsWith.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/StartsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,OAAO,EACR,MAAM,sBAAsB,CAAC;AAG9B,KAAK,KAAK,CACR,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,GAAG,MAAM,IAClC,MAAM,SAAS,GAAG,WAAW,GAAG,MAAM,EAAE,GACzC,IAAI,GACJ,KAAK,CAAC;AAER,KAAK,OAAO,CACV,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,IACrD,WAAW,SAAS,SAAS,MAAM,EAAE,GACvC,KAAK,CACH;IAAC,MAAM;CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,GAAG,MAAM,EAAE,GAAG,MAAM,EAChD,YAAY,CAAC,WAAW,CAAC,CAC1B,GACD,KAAK,CACH;IAAC,MAAM;CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,GAAG,MAAM,EAAE,GAAG,MAAM,EAChD,QAAQ,CAAC,WAAW,CAAC,CACtB,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,CACpB,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,IACrD,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACrC,OAAO,GACP,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACxC,OAAO,GACP,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GACnE,IAAI,GACJ,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC"}

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

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

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

@@ -1,14 +0,0 @@
-import { HasArray, IsUnion, UnionToTuple } from "inferred-types/types";
-type Process<T extends readonly unknown[]> = HasArray<T> extends true ? true : false;
-/**
- * **UnionHasArray**`<T>`
- *
- * A boolean operator which tests whether T is:
- *
- * - indeed a _union_ type
- * - and that one of the elements of the union is an array
- * of some sort.
- */
-export type UnionHasArray<T> = IsUnion<T> extends true ? Process<UnionToTuple<T>> : false;
-export {};
-//# sourceMappingURL=UnionHasArray.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"UnionHasArray.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/UnionHasArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGvE,KAAK,OAAO,CACV,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1B,IAAI,GACJ,KAAK,CAAC;AAGR;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACpD,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACxB,KAAK,CAAC"}

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

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

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

@@ -1,20 +0,0 @@
-import { AsString, ErrorCondition, IsBoolean, IsFalse, IsTrue, IsWideType, LogicFunction } from "inferred-types/types";
-type WideBooleanNotAllowed = ErrorCondition<"wide-boolean-not-allowed", `Call to Validate<T,E> received a wide boolean type for T!`>;
-type WideReturnNotAllowed<T> = ErrorCondition<"wide-return-not-allowed", `Call to Validate<T,E> returned a wide type: ${AsString<T>}!`>;
-/**
- * **Validate**`<T,[E]>`
- *
- * Branching utility which proxies through the value of `T` when it is
- * **not** `false` or _returns_ false, otherwise it passes along `E`.
- *
- * - `E` by default is _never_
- * - if `T` is a wide boolean type an `ErrorCondition<"wide-boolean-not-allowed">`
- * will be returned
- *
- * ```ts
- * const fn = <T extends string>(dp: T & Validate<IsDotPath<T>>) => {}
- * ```
- */
-export type Validate<TTest, TErr = never> = [IsTrue<TTest>] extends [true] ? TTest : [IsFalse<TTest>] extends [true] ? TErr : [IsBoolean<TTest>] extends [true] ? WideBooleanNotAllowed : [TTest] extends [LogicFunction] ? [IsTrue<ReturnType<TTest>>] extends [true] ? TTest : [IsFalse<ReturnType<TTest>>] extends [true] ? TErr : WideBooleanNotAllowed : [IsWideType<TTest>] extends [true] ? WideReturnNotAllowed<TTest> : TTest;
-export {};
-//# sourceMappingURL=Validate.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Validate.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Validate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,SAAS,EACT,OAAO,EACP,MAAM,EACN,UAAU,EACV,aAAa,EACd,MAAM,sBAAsB,CAAC;AAG9B,KAAK,qBAAqB,GAAG,cAAc,CACzC,0BAA0B,EAC1B,2DAA2D,CAC5D,CAAC;AAEF,KAAK,oBAAoB,CAAC,CAAC,IAAI,cAAc,CAC3C,yBAAyB,EACzB,+CAA+C,QAAQ,CAAC,CAAC,CAAC,GAAG,CAC9D,CAAC;AAGF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAClB,KAAK,EACL,IAAI,GAAG,KAAK,IACV,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC9B,KAAK,GACL,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC/B,IAAI,GACJ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,qBAAqB,GACrB,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,GAC7B,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACxC,KAAK,GACP,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACzC,IAAI,GACN,qBAAqB,GACvB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAChC,oBAAoB,CAAC,KAAK,CAAC,GAC3B,KAAK,CAAC"}

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

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