inferred-types 0.51.0 → 0.51.2

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

@@ -0,0 +1,11 @@
+import { Abs, AsNumber, Container, ExplicitlyEmptyObject, IsEqual, IsNegativeNumber, IsStringLiteral, IsObjectLiteral, IsTuple, Dictionary, Tuple, NumericKeys, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,14 @@
+import { If, IsEqual, ObjectKey, RemoveIndexKeys, Retain, UnionToTuple } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,51 @@
+import { Container, ErrorCondition, IsEqual, IsNever, IsVueRef, IsWideUnion, ObjectKey, ProxyError, RemoveIndexKeys, Scalar, Throw, UnionToTuple } from "inferred-types/dist/types/index";
+/**
+ * **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";
+}>;
+/**
+ * **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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEzC;;;;;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,gBAAgB,CAAA;CAAC,CAC7B,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

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

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

@@ -0,0 +1,15 @@
+import { IsUnion, IsWideType, UnionToTuple } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,20 @@
+import { UnionToTuple, IsUnion, Contains, ErrorCondition } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,13 @@
+import { AfterFirst, First, IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,71 @@
+import { AfterFirst, And, BeforeLast, First, GetUrlQueryParams, HasOtherCharacters, Ip4Address, Ip4Octet, Ip6AddressFull, Ip6AddressLoose, Ip6GroupExpansion, IsGreaterThan, IsLessThan, IsStringLiteral, Last, Length, LowerAlphaChar, NumericChar, Split } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,8 @@
+import { IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,8 @@
+import { If, IsNotEqual, Length } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,32 @@
+import { IsStringLiteral, GetPhoneCountryCode, IsTrue, PhoneNumber, PhoneCountryCode, IsErrorCondition, MaybeError } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,9 @@
+import { TypedFunction } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,11 @@
+import { IsBoolean, TypedFunction } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,11 @@
+import { IsEqual, TypedFunction } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,12 @@
+import { TypedFunction } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,12 @@
+import { IfEqual, AfterFirst, First } from "inferred-types/dist/types/index";
+/**
+ * **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

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

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

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

@@ -0,0 +1,11 @@
+import { AfterFirst, First, If, Extends } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,24 @@
+import { AsString, IsWideType, TupleToUnion, IsEqual } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,14 @@
+import { HasArray, IsUnion, UnionToTuple } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,20 @@
+import { AsString, ErrorCondition, IsBoolean, IsFalse, IsTrue, IsWideType, LogicFunction } from "inferred-types/dist/types/index";
+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

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

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

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

@@ -0,0 +1,32 @@
+import { YouTubeVideoUrl, YouTubeUrl, IsStringLiteral, GetUrlQueryParams, YouTubePlaylistUrl } from "inferred-types/dist/types/index";
+type VideoUrlKind = "single-video" | "video-in-playlist" | "both";
+/**
+ * **IsYouTubeUrl**`<T>`
+ *
+ * Boolean operator which returns _true_ when the string is a
+ * possible YouTube URL.
+ */
+export type IsYouTubeUrl<T> = [T] extends [string] ? [IsStringLiteral<T>] extends [true] ? [T] extends [YouTubeUrl] ? true : false : boolean : false;
+type _VideoKind<TQueryParams extends string, TKind extends VideoUrlKind> = TQueryParams extends `${string}list=${string}` ? TKind extends "single-video" ? false : true : TKind extends "video-in-playlist" ? false : true;
+/**
+ * **IsYouTubeVideoUrl**`<TTest,[TKind]>`
+ *
+ * Boolean operator which returns _true_ when the string is a
+ * possible YouTube URL which is for playing a video.
+ *
+ * **Note:** by default any URL which plays a video is allowed but
+ * you can change `TKind` to "single-video" or "video-in-playlist"
+ * to isolate to just one of the play styles.
+ *
+ * **Related:** `IsYouTubeUrl`, `YouTubeVideoUrl`
+ */
+export type IsYouTubeVideoUrl<TTest, TKind extends VideoUrlKind = "both"> = [TTest] extends [string] ? [IsStringLiteral<TTest>] extends [true] ? [TTest] extends [YouTubeVideoUrl] ? _VideoKind<GetUrlQueryParams<TTest>, TKind> : false : boolean : false;
+/**
+ * **IsYouTubeUrl**`<T>`
+ *
+ * Boolean operator which returns _true_ when the string is a
+ * possible YouTube URL.
+ */
+export type IsYouTubePlaylist<T> = [T] extends [string] ? [IsStringLiteral<T>] extends [true] ? [T] extends [YouTubePlaylistUrl] ? true : false : boolean : false;
+export {};
+//# sourceMappingURL=YouTube-operators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"YouTube-operators.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/YouTube-operators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAEtI,KAAK,YAAY,GAAE,cAAc,GAAG,mBAAmB,GAAG,MAAM,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAChD,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GACtB,IAAI,GACJ,KAAK,GACP,OAAO,GACT,KAAK,CAAC;AAER,KAAK,UAAU,CACb,YAAY,SAAS,MAAM,EAC3B,KAAK,SAAS,YAAY,IACxB,YAAY,SAAS,GAAG,MAAM,QAAQ,MAAM,EAAE,GAChD,KAAK,SAAS,cAAc,GAC1B,KAAK,GACL,IAAI,GACN,KAAK,SAAS,mBAAmB,GAC/B,KAAK,GACL,IAAI,CAAC;AAGT;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,CAC3B,KAAK,EACL,KAAK,SAAS,YAAY,GAAG,MAAM,IACjC,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,GAC1B,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACrC,CAAC,KAAK,CAAC,SAAS,CAAC,eAAe,CAAC,GAC/B,UAAU,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,GAC3C,KAAK,GACP,OAAO,GACT,KAAK,CAAC;AAGR;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACrD,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,CAAC,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,GAC9B,IAAI,GACJ,KAAK,GACP,OAAO,GACT,KAAK,CAAC"}

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

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