inferred-types 0.42.0 → 0.43.0

package/dist/types/boolean-logic/branching/IfBoolean.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfBoolean.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAwB;AAE5C,MAAM,MAAM,SAAS,CACnB,CAAC,EACD,IAAI,GAAG,CAAC,GAAG,OAAO,EAClB,KAAK,GAAG,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,IACzB,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfBooleanLiteral.d.ts

@@ -1,8 +0,0 @@
-import { IsBooleanLiteral } from "../../index";
-/**
- * **IfBooleanLiteral**
- *
- * Branch utility which returns `TRUE` type when `T` is a boolean literal and `FALSE` otherwise
- */
-export type IfBooleanLiteral<T extends boolean, TRUE, FALSE> = IsBooleanLiteral<T> extends true ? TRUE : FALSE;
-//# sourceMappingURL=IfBooleanLiteral.d.ts.map

package/dist/types/boolean-logic/branching/IfBooleanLiteral.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfBooleanLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfBooleanLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAwB;AAEnD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,OAAO,EACjB,IAAI,EACJ,KAAK,IACH,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfChar.d.ts

@@ -1,11 +0,0 @@
-import { IsChar, IfFalse, IfTrue } from "../../index";
-/**
- * **IfChar**`<T,IF,ELSE,[MAYBE]>`
- *
- * Branching utility which branches on whether `T` is a single character.
- *
- * - by default `IF` will take on the value of `T`
- * - by default `ELSE` will take on the value of `never`
- */
-export type IfChar<T, IF = T, ELSE = never, MAYBE = IF | ELSE> = IfTrue<IsChar<T>, IF, IfFalse<IsChar<T>, ELSE, MAYBE>>;
-//# sourceMappingURL=IfChar.d.ts.map

package/dist/types/boolean-logic/branching/IfChar.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfChar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfChar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAG,OAAO,EAAG,MAAM,EAAE,oBAAwB;AAE5D;;;;;;;GAOG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,EAAE,GAAG,CAAC,EACN,IAAI,GAAG,KAAK,EACZ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC"}

package/dist/types/boolean-logic/branching/IfContainer.d.ts

@@ -1,9 +0,0 @@
-import { IsContainer } from "../../index";
-/**
- * **IfContainer<T,IF,ELSE>**
- *
- * Type operator which identifies if `T` is a _container_ where a container is
- * any object or array.
- */
-export type IfContainer<T, IF, ELSE> = IsContainer<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfContainer.d.ts.map

package/dist/types/boolean-logic/branching/IfContainer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfContainer.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAE9C;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9D,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfContains.d.ts

@@ -1,10 +0,0 @@
-import { Contains } from "../../index";
-/**
- * **IfContains**`<TList,TContains,IF,ELSE>`
- *
- * Branching utility which check
- *
- * **Related:** `NarrowlyContains`
- */
-export type IfContains<TList extends readonly unknown[], TContains, IF, ELSE> = Contains<TList, TContains> extends true ? IF : ELSE;
-//# sourceMappingURL=IfContains.d.ts.map

package/dist/types/boolean-logic/branching/IfContains.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfContains.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfContains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CACpB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,SAAS,EACT,EAAE,EACF,IAAI,IACF,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,IAAI,GACvC,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfDefined.d.ts

@@ -1,12 +0,0 @@
-import { IfNever, IfUndefined } from "../../index";
-/**
- * **IfDefined**`<T>`
- *
- * Conditional utility which branches based on whether `T` is
- * considered "defined" where defined is:
- *
- * - any value which is NOT `never` or `undefined`
- */
-export type IfDefined<T, IF, ELSE> = IfNever<T, ELSE, // never is considered "undefined"
-IfUndefined<T, ELSE, IF>>;
-//# sourceMappingURL=IfDefined.d.ts.map

package/dist/types/boolean-logic/branching/IfDefined.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfDefined.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfDefined.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAEvD;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,EACD,EAAE,EACF,IAAI,IACF,OAAO,CACT,CAAC,EACD,IAAI,EAAE,kCAAkC;AACxC,WAAW,CACT,CAAC,EACD,IAAI,EACJ,EAAE,CACH,CACF,CAAC"}

package/dist/types/boolean-logic/branching/IfDoesNotExtend.d.ts

@@ -1,10 +0,0 @@
-/**
- * **IfDoesNotExtend**`<TValue, TCompareTo>`
- *
- * A branching utility which branches based on whether
- * `TValue` _does not_ extend `TCompareTo`.
- *
- * **Related:** `
- */
-export type IfDoesNotExtend<TValue, TCompareTo, IF = Exclude<TValue, TCompareTo>, ELSE = TValue & TCompareTo> = TValue extends TCompareTo ? ELSE : IF;
-//# sourceMappingURL=IfDoesNotExtend.d.ts.map

package/dist/types/boolean-logic/branching/IfDoesNotExtend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfDoesNotExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfDoesNotExtend.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CACzB,MAAM,EAAE,UAAU,EAClB,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,EAChC,IAAI,GAAG,MAAM,GAAG,UAAU,IACxB,MAAM,SAAS,UAAU,GAC3B,IAAI,GACJ,EAAE,CAAC"}

package/dist/types/boolean-logic/branching/IfDotPath.d.ts

@@ -1,14 +0,0 @@
-import { IsDotPath } from "../../index";
-/**
- * **IfDotPath**`<TDotPath,IF,ELSE,[MAYBE]>`
- *
- * Branching utility which is based on whether `TDotPath` is a valid dot path.
- *
- * - you may state a `MAYBE` type -- which is mapped to when not enough information
- * exists in the design time environment and `IsDotPath` returns "boolean"; by default
- * this type is a union between `IF` and `ELSE`.
- *
- * **Related:** `IfValidDotPath`
- */
-export type IfDotPath<TDotPath, IF, ELSE, MAYBE = IF | ELSE> = IsDotPath<TDotPath> extends true ? IF : IsDotPath<TDotPath> extends false ? ELSE : MAYBE;
-//# sourceMappingURL=IfDotPath.d.ts.map

package/dist/types/boolean-logic/branching/IfDotPath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAwB;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,CACnB,QAAQ,EACR,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,SAAS,CAAC,QAAQ,CAAC,SAAS,IAAI,GAChC,EAAE,GACF,SAAS,CAAC,QAAQ,CAAC,SAAS,KAAK,GAC/B,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfEmptyContainer.d.ts

@@ -1,12 +0,0 @@
-import { Container, EmptyContainer } from "../../index";
-/**
- * **IfEmptyContainer**`<TContainer,TIf,TElse>`
- *
- * Branching utility which branches on whether the `TContainer` passed in is
- * considered _empty_.
- *
- * Note: `TElse` is defaulted to `TContainer` to help use this utility as a guard against
- * an empty condition.
- */
-export type IfEmptyContainer<TContainer extends Container, TIf, TElse = TContainer> = EmptyContainer<TContainer> extends true ? TIf : TElse;
-//# sourceMappingURL=IfEmptyContainer.d.ts.map

package/dist/types/boolean-logic/branching/IfEmptyContainer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfEmptyContainer.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfEmptyContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,oBAAwB;AAE5D;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAC1B,UAAU,SAAS,SAAS,EAC5B,GAAG,EACH,KAAK,GAAG,UAAU,IAChB,cAAc,CAAC,UAAU,CAAC,SAAS,IAAI,GACzC,GAAG,GACH,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfEmptyObject.d.ts

@@ -1,9 +0,0 @@
-import { IsEmptyObject } from "../../index";
-/**
- * **IfEmptyObject**`<T,IF,ELSE>`
- *
- * Branching utility which returns type `IF` when `T` is an
- * empty object; otherwise returns `ELSE` type.
- */
-export type IfEmptyObject<T, IF, ELSE> = IsEmptyObject<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfEmptyObject.d.ts.map

package/dist/types/boolean-logic/branching/IfEmptyObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfEmptyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfEmptyObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAwB;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAC,EAAE,EAAC,IAAI,IAAI,aAAa,CAAC,CAAC,CAAC,SAAS,IAAI,GAChE,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfEqualLength.d.ts

@@ -1,8 +0,0 @@
-import { ErrorCondition, OfSameLength, Tuple } from "../../index";
-/**
- * **IfEqualLength**`<A,B,IF,ELSE,[ERR]>`
- *
- * Branching utility which branches based on whether `A` and `B` are of equal length.
- */
-export type IfEqualLength<A extends Tuple | string, B extends Tuple | string, IF, ELSE, ERR = OfSameLength<A, B>> = OfSameLength<A, B> extends true ? IF : OfSameLength<A, B> extends false ? ELSE : OfSameLength<A, B> extends ErrorCondition<string> ? ERR : never;
-//# sourceMappingURL=IfEqualLength.d.ts.map

package/dist/types/boolean-logic/branching/IfEqualLength.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfEqualLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfEqualLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,EAAE,oBAAwB;AAEtE;;;;GAIG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,KAAK,GAAG,MAAM,EACxB,CAAC,SAAS,KAAK,GAAG,MAAM,EACxB,EAAE,EACF,IAAI,EACJ,GAAG,GAAG,YAAY,CAAC,CAAC,EAAC,CAAC,CAAC,IACrB,YAAY,CAAC,CAAC,EAAC,CAAC,CAAC,SAAS,IAAI,GAChC,EAAE,GACF,YAAY,CAAC,CAAC,EAAC,CAAC,CAAC,SAAS,KAAK,GAC/B,IAAI,GACJ,YAAY,CAAC,CAAC,EAAC,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,GAC9C,GAAG,GACH,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfError.d.ts

@@ -1,15 +0,0 @@
-import { IsErrorOptions, ErrorCondition, IsError } from "../../index";
-/**
- * **IfError**`<TType,TOptions,IF,[ELSE]>`
- *
- * Branching utility which returns type `IF` when `TType` is either an
- * `ErrorCondition` or the type of `never`. In all other cases the
- * type `ELSE` is returned.
- *
- * - type of `ELSE` is defaulted to `TType` for convenience but can be set
- * to any type which is appropriate.
- *
- * **Related:** `IfNotError`, `IfErrorCondition`
- */
-export type IfError<TType, TOptions extends IsErrorOptions, IF, ELSE = Exclude<TType, ErrorCondition>> = IsError<TType, TOptions> extends true ? IF : ELSE;
-//# sourceMappingURL=IfError.d.ts.map

package/dist/types/boolean-logic/branching/IfError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfError.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,cAAc,EAAE,cAAc,EAAE,OAAO,EAAE,oBAAwB;AAE3E;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CACnB,KAAK,EACL,QAAQ,SAAS,cAAc,EAC/B,EAAE,EACF,IAAI,GAAG,OAAO,CAAC,KAAK,EAAE,cAAc,CAAC,IACjC,OAAO,CAAC,KAAK,EAAC,QAAQ,CAAC,SAAS,IAAI,GACtC,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfExtends.d.ts

@@ -1,9 +0,0 @@
-import { DoesExtend } from "../../index";
-/**
- * **IfExtends**`<TValue,TExtends,IF,ELSE>`
- *
- * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
- * it will return the type `ELSE`.
- */
-export type IfExtends<TValue, TExtends, IF = TValue & TExtends, ELSE = Exclude<TValue, TExtends>> = DoesExtend<TValue, TExtends> extends true ? IF : ELSE;
-//# sourceMappingURL=IfExtends.d.ts.map

package/dist/types/boolean-logic/branching/IfExtends.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfExtends.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfExtends.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,oBAAwB;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CACnB,MAAM,EACN,QAAQ,EACR,EAAE,GAAG,MAAM,GAAG,QAAQ,EACtB,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,IAC9B,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfExtendsAll.d.ts

@@ -1,11 +0,0 @@
-import { Tuple, ExtendsAll } from "../../index";
-/**
- * **IfExtendsAll**`<TVal,TList,IF,ELSE>`
- *
- * Type utility which converts the type based on whether `TVal` _extends_
- * all the values in `TList`.
- *
- * **Related:** `IfExtendsSome`, `IfExtends`
- */
-export type IfExtendsAll<TVal, TList extends Tuple, IF, ELSE> = ExtendsAll<TVal, TList> extends true ? IF : ELSE;
-//# sourceMappingURL=IfExtendsAll.d.ts.map

package/dist/types/boolean-logic/branching/IfExtendsAll.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfExtendsAll.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfExtendsAll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAG,UAAU,EAAE,oBAAwB;AAErD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CACtB,IAAI,EAAC,KAAK,SAAS,KAAK,EACxB,EAAE,EACF,IAAI,IACF,UAAU,CAAC,IAAI,EAAC,KAAK,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfExtendsSome.d.ts

@@ -1,9 +0,0 @@
-import { Tuple, ExtendsSome } from "../../index";
-/**
- * **IfExtendsSome**`<TList,TValue,IF,ELSE>`
- *
- * Type utility which converts the type based on whether elements of `TList`
- * extend `TValue`.
- */
-export type IfExtendsSome<TValue, TList extends Tuple, IF, ELSE> = ExtendsSome<TValue, TList> extends true ? IF : ELSE;
-//# sourceMappingURL=IfExtendsSome.d.ts.map

package/dist/types/boolean-logic/branching/IfExtendsSome.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfExtendsSome.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfExtendsSome.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAG,WAAW,EAAE,oBAAwB;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACzB,MAAM,EACN,KAAK,SAAS,KAAK,EACnB,EAAE,EACF,IAAI,IACA,WAAW,CAAC,MAAM,EAAC,KAAK,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfFalse.d.ts

@@ -1,11 +0,0 @@
-import { IsFalse } from "../../index";
-/**
- * **IfFalse**`<T, IF, ELSE>`
- * Type utility which checks for literal `false` value and then switches
- * the  type accordingly to the `IF` or `ELSE` types.
- *
- * Note: the wide _boolean_ type or any non-boolean type results in false / `ELSE`;
- * if you are looking for different behavior consider `IfSoftTrue` instead
- */
-export type IfFalse<T, IF, ELSE> = IsFalse<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfFalse.d.ts.map

package/dist/types/boolean-logic/branching/IfFalse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfFalse.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,EAAE,EACF,IAAI,IACF,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfFalsy.d.ts

@@ -1,11 +0,0 @@
-import { IfEqual, IsTruthy } from "../../index";
-/**
- * **IfFalsy**`<T,IF,ELSE,[MAYBE]>`
- *
- * Type branching utility that branches based on whether `T` is
- * a _falsy_ value.
- */
-export type IfFalsy<T, IF, ELSE, MAYBE = IF | ELSE> = IfEqual<IsTruthy<T>, false, IF, // falsy
-IfEqual<IsTruthy<T>, true, ELSE, // truthy 
-MAYBE>>;
-//# sourceMappingURL=IfFalsy.d.ts.map

package/dist/types/boolean-logic/branching/IfFalsy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfFalsy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfFalsy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,QAAQ,EAAE,oBAAwB;AAErD;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAC,EAAE,EAAC,IAAI,EAAC,KAAK,GAAG,EAAE,GAAG,IAAI,IAC/C,OAAO,CACL,QAAQ,CAAC,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,QAAQ;AAC9B,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAC,IAAI,EAAE,IAAI,EAAE,UAAU;AAC1C,KAAK,CACN,CAAC,CAAC"}

package/dist/types/boolean-logic/branching/IfFnWithParams.d.ts

@@ -1,14 +0,0 @@
-import { IsFnWithParams } from "../../index";
-/**
- * **IfFnWithDict**`<T, IsFn, NotFn>`
- *
- * Transforms type `T` to type `IsFn` if `T` is a function
- * which also includes an intersection with a key/value
- * dictionary.
- *
- * In all other cases it will transform to type `NotFn`.
- *
- * **Related:** `IfFunction`, `IfFnWithoutDict`
- */
-export type IfFnWithParams<T, IsFn, NotFn> = T extends IsFnWithParams<T> ? IsFn : NotFn;
-//# sourceMappingURL=IfFnWithParams.d.ts.map

package/dist/types/boolean-logic/branching/IfFnWithParams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfFnWithParams.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfFnWithParams.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,oBAAwB;AAGjD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CACtB,CAAC,EACD,IAAI,EACJ,KAAK,IACL,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfFnWithoutParams.d.ts

@@ -1,16 +0,0 @@
-import { IsFnWithParams } from "../../index";
-type BaseFunction = unknown;
-/**
- * **IfFnWithoutDict**`<T, IsFn, NotFn>`
- *
- * Transforms type `T` to type `IsFn` if `T` is a function
- * without including an intersection with a key/value
- * dictionary.
- *
- * In all other cases it will transform to type `NotFn`.
- *
- * **Related:** `IfFunction`, `IfFnWithDict`
- */
-export type IfFnWithoutParams<T, FnWithDict = T, NotFn = BaseFunction & T> = T extends IsFnWithParams<T> ? FnWithDict : NotFn;
-export {};
-//# sourceMappingURL=IfFnWithoutParams.d.ts.map

package/dist/types/boolean-logic/branching/IfFnWithoutParams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfFnWithoutParams.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfFnWithoutParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,oBAAwB;AAGjD,KAAK,YAAY,GAAG,OAAO,CAAC;AAE5B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,CACzB,CAAC,EACD,UAAU,GAAG,CAAC,EACd,KAAK,GAAG,YAAY,GAAG,CAAC,IACxB,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfFunction.d.ts

@@ -1,14 +0,0 @@
-import { AnyFunction } from "../../index";
-/**
- * **IfFunction**`<T, IsFn, NotFn>`
- *
- * Transforms type `T` to type `IsFn` if `T` is _any_ type
- * of function including a function which is intersected with
- * a key/value dictionary.
- *
- * In all other cases it will transform to type `NotFn`.
- *
- * **Related:** `IfFnWithDict`, `IfFnWithoutDict`
- */
-export type IfFunction<T, IsFn, NotFn> = T extends AnyFunction ? IsFn : NotFn;
-//# sourceMappingURL=IfFunction.d.ts.map

package/dist/types/boolean-logic/branching/IfFunction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfFunction.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,CAClB,CAAC,EACD,IAAI,EACJ,KAAK,IACL,CAAC,SAAS,WAAW,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfGreaterThan.d.ts

@@ -1,9 +0,0 @@
-import { IsGreaterThan } from "../../index";
-/**
- * **IfGreaterThan**`<A,B,IF,ELSE>`
- *
- * Type branching utility based on whether `A` is
- * _greater than_ `B`.
- */
-export type IfGreaterThan<A extends number | `${number}`, B extends number | `${number}`, IF, ELSE> = IsGreaterThan<A, B> extends true ? IF : ELSE;
-//# sourceMappingURL=IfGreaterThan.d.ts.map

package/dist/types/boolean-logic/branching/IfGreaterThan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfGreaterThan.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAwB;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,EAC9B,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,EAC9B,EAAE,EACF,IAAI,IACF,aAAa,CAAC,CAAC,EAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfHasCharacters.d.ts

@@ -1,9 +0,0 @@
-import { HasCharacters } from "../../index";
-/**
- * **IfHasCharacters**<TVal,TChars,IF,ELSE,[MAYBE]>
- *
- * Branching utility which branches based on whether `TVal` _has_ the characters defined
- * by `TChars` (which is either a string union or array of strings).
- */
-export type IfHasCharacters<TVal extends string, TChars extends string | readonly string[], IF, ELSE, MAYBE = IF | ELSE> = HasCharacters<TVal, TChars> extends true ? IF : HasCharacters<TVal, TChars> extends false ? ELSE : MAYBE;
-//# sourceMappingURL=IfHasCharacters.d.ts.map

package/dist/types/boolean-logic/branching/IfHasCharacters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfHasCharacters.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfHasCharacters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAwB;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CACzB,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,EACzC,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,IAAI,GACxC,EAAE,GACF,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,KAAK,GACvC,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfIndexAt.d.ts

@@ -1,62 +0,0 @@
-import { AsError, Concat, Container } from "../../index";
-type InvalidOp<TIndex extends PropertyKey, TUtility extends string> = AsError<[
-    "invalid-operation",
-    Concat<["Attempt to index a non-container with ", TIndex]>,
-    {
-        library: "inferred-types";
-        utility: TUtility;
-    }
-]>;
-type NotFound<TIndex extends PropertyKey, TUtility extends string> = AsError<[
-    "index-not-found",
-    Concat<[
-        "The index '",
-        TIndex,
-        "' was not found on the container"
-    ]>,
-    {
-        library: "inferred-types";
-        utility: TUtility;
-        id: TIndex;
-    }
-]>;
-/**
- * **IfIndexAt**`<TContainer,TIndex,[IF],[ELSE]>`
- *
- * Branching utility based on whether `TContainer`:
- * 1. is a Container
- * 2. has a key/index of `TIndex`
- *
- * #### Default values
- * If `IF` is not specified then it will narrow the `TContainer` to include
- * the intersection with `Container`.
- *
- * If `ELSE` is not specified it will result in one of two errors:
-*    - `TContainer` was not a container → `ErrorCondition<"invalid-operation">`
-*    - `TContainer` _is_ a container but doesn't have the key →
- * `ErrorCondition<"index-not-found">`
- *
- * **Related:** `IfNoIndexAt`
- */
-export type IfIndexAt<TContainer, TIndex extends PropertyKey, IF = TContainer & Container, ELSE = TContainer extends Container ? NotFound<TIndex, "IfIndexAt"> : InvalidOp<TIndex, "IfIndexAt">> = TContainer extends Container ? TIndex extends keyof TContainer ? IF : ELSE : ELSE;
-/**
- * **IfNoIndexAt**`<TContainer,TIndex,[IF],[ELSE]>`
- *
- * Branching utility based on whether `TContainer`:
- * 1. is a Container
- * 2. has a key/index of `TIndex`
- *
- * #### Default values
- * If `IF` is not specified it will result in one of two errors:
- *    - `TContainer` was not a container → `ErrorCondition<"invalid-operation">`
- *    - `TContainer` _is_ a container but doesn't have the key →
- * `ErrorCondition<"index-not-found">`
- *
- * If `ELSE` is not specified then it will narrow the `TContainer` to include
- * the intersection with `Container`.
- *
- * **Related:** `IfNoIndexAt`
- */
-export type IfNoIndexAt<TContainer, TIndex extends PropertyKey, IF = TContainer extends Container ? NotFound<TIndex, "IfIndexAt"> : InvalidOp<TIndex, "IfIndexAt">, ELSE = TContainer extends Container ? TIndex extends keyof TContainer ? TContainer[TIndex] : never : never> = TContainer extends Container ? TIndex extends keyof TContainer ? ELSE : IF : ELSE;
-export {};
-//# sourceMappingURL=IfIndexAt.d.ts.map

package/dist/types/boolean-logic/branching/IfIndexAt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfIndexAt.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfIndexAt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,oBAAwB;AAE7D,KAAK,SAAS,CAAC,MAAM,SAAS,WAAW,EAAE,QAAQ,SAAS,MAAM,IAAI,OAAO,CAAC;IAC5E,mBAAmB;IACnB,MAAM,CAAC,CAAC,wCAAwC,EAAE,MAAM,CAAC,CAAC;IAC1D;QAAE,OAAO,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,QAAQ,CAAA;KAAE;CACjD,CAAC,CAAC;AAEH,KAAK,QAAQ,CAAC,MAAM,SAAS,WAAW,EAAE,QAAQ,SAAS,MAAM,IAAI,OAAO,CAAC;IAC3E,iBAAiB;IACjB,MAAM,CAAC;QACL,aAAa;QACb,MAAM;QACN,kCAAkC;KACnC,CAAC;IACF;QAAE,OAAO,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,QAAQ,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE;CAC7D,CAAC,CAAC;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,SAAS,CACnB,UAAU,EACV,MAAM,SAAS,WAAW,EAC1B,EAAE,GAAG,UAAU,GAAG,SAAS,EAC3B,IAAI,GAAG,UAAU,SAAS,SAAS,GAC/B,QAAQ,CAAC,MAAM,EAAC,WAAW,CAAC,GAC5B,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,IAChC,UAAU,SAAS,SAAS,GAC9B,MAAM,SAAS,MAAM,UAAU,GAC7B,EAAE,GACF,IAAI,GACN,IAAI,CAAC;AAEP;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,WAAW,CACrB,UAAU,EACV,MAAM,SAAS,WAAW,EAC1B,EAAE,GAAG,UAAU,SAAS,SAAS,GAC/B,QAAQ,CAAC,MAAM,EAAC,WAAW,CAAC,GAC5B,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,EAChC,IAAI,GAAG,UAAU,SAAS,SAAS,GAAG,MAAM,SAAS,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,GAAG,KAAK,GAAG,KAAK,IACxG,UAAU,SAAS,SAAS,GAC9B,MAAM,SAAS,MAAM,UAAU,GAC7B,IAAI,GACJ,EAAE,GACJ,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfIndexable.d.ts

@@ -1,11 +0,0 @@
-import { Container, IsIndexable } from "../../index";
-/**
- * **IfIndexable**`<TContainer,IF,ELSE>`
- *
- * Branching utility which branches based on whether `TContainer` is
- * both a _container_ and whether it has at least one known key.
- *
- * **Related:** `IfHasIndex`
- */
-export type IfIndexable<TContainer, IF, ELSE> = TContainer extends Container ? IsIndexable<TContainer> extends true ? IF : ELSE : ELSE;
-//# sourceMappingURL=IfIndexable.d.ts.map

package/dist/types/boolean-logic/branching/IfIndexable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfIndexable.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfIndexable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,oBAAwB;AAEzD;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CACrB,UAAU,EACV,EAAE,EACF,IAAI,IACF,UAAU,SAAS,SAAS,GAC9B,WAAW,CAAC,UAAU,CAAC,SAAS,IAAI,GAClC,EAAE,GACF,IAAI,GACN,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfLessThan.d.ts

@@ -1,10 +0,0 @@
-import { LessThan } from "../../numeric-literals";
-/**
- * **IfLessThan**`<TVal,TCompare,TIf,[TElse]>`
- *
- * Branching utility which return `TIf` when `TVal` it is _less than_ `TCompare`.
- *
- * **Related:** `IfNegative`
- */
-export type IfLessThan<TVal extends number, TCompare extends number, TIf, TElse extends TVal> = LessThan<TVal, TCompare> extends true ? TIf : TElse;
-//# sourceMappingURL=IfLessThan.d.ts.map

package/dist/types/boolean-logic/branching/IfLessThan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfLessThan.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfLessThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,+BAAmC;AAEtD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CACpB,IAAI,SAAS,MAAM,EACnB,QAAQ,SAAS,MAAM,EACvB,GAAG,EACH,KAAK,SAAS,IAAI,IAChB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,IAAI,GACvC,GAAG,GACH,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfLiteral.d.ts

@@ -1,8 +0,0 @@
-import { IsLiteral } from "../../index";
-/**
- * **IfLiteral**
- *
- * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
- */
-export type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfLiteral.d.ts.map

package/dist/types/boolean-logic/branching/IfLiteral.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAwB;AAE5C;;;;GAIG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,EACD,EAAE,EACF,IAAI,IACF,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GACzB,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfMaybeFalse.d.ts

@@ -1,13 +0,0 @@
-import { IfTrue, IfFalse, IfBoolean } from "../../index";
-/**
- * **IfSoftFalse**`<T, IF, ELSE, MAYBE, UNKNOWN>`
- *
- * Type utility which transforms the type based on `T`'s boolean state:
- *
- * - `false` - converts to the `IF` type
- * - `true` - converts to the `ELSE` type
- * - `boolean` - converts to the `MAYBE` state (which is union of `IF` and `ELSE` by default)
- * - any other value converts to `never`
- */
-export type IfMaybeFalse<T, IF, ELSE, MAYBE = IF | ELSE> = IfFalse<T, IF, IfTrue<T, ELSE, IfBoolean<T, MAYBE, never>>>;
-//# sourceMappingURL=IfMaybeFalse.d.ts.map

package/dist/types/boolean-logic/branching/IfMaybeFalse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfMaybeFalse.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfMaybeFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAG,OAAO,EAAG,SAAS,EAAE,oBAAwB;AAE/D;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,OAAO,CACT,CAAC,EAAE,EAAE,EACL,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAC5C,CAAC"}

package/dist/types/boolean-logic/branching/IfMaybeTrue.d.ts

@@ -1,13 +0,0 @@
-import { IfBoolean, IfFalse, IfTrue } from "../../index";
-/**
- * **IfMaybeTrue**`<T, IF, ELSE, MAYBE>`
- *
- * Type utility which transforms the type based on `T`'s boolean state:
- *
- * - `true` - converts to the `IF` type
- * - `false` - converts to the `ELSE` type
- * - `boolean` - converts to the `MAYBE` state (which is union of `IF` and `ELSE` by default)
- * - any other value converts to `never`
- */
-export type IfMaybeTrue<T, IF, ELSE, MAYBE = IF | ELSE> = IfTrue<T, IF, IfFalse<T, ELSE, IfBoolean<T, MAYBE, never>>>;
-//# sourceMappingURL=IfMaybeTrue.d.ts.map

package/dist/types/boolean-logic/branching/IfMaybeTrue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfMaybeTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfMaybeTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAG,OAAO,EAAG,MAAM,EAAE,oBAAwB;AAE/D;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,EACD,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,MAAM,CACR,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CACpD,CAAC"}

package/dist/types/boolean-logic/branching/IfNarrowlyContains.d.ts

@@ -1,10 +0,0 @@
-import { NarrowlyContains } from "../../index";
-/**
- * **IfContains**`<TList,TContains,IF,ELSE>`
- *
- * Branching utility which check
- *
- * **Related:** `NarrowlyContains`
- */
-export type IfNarrowlyContains<TList extends readonly unknown[], TContains, IF, ELSE> = NarrowlyContains<TList, TContains> extends true ? IF : ELSE;
-//# sourceMappingURL=IfNarrowlyContains.d.ts.map

package/dist/types/boolean-logic/branching/IfNarrowlyContains.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfNarrowlyContains.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNarrowlyContains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAwB;AAGnD;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,CAC5B,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,SAAS,EACT,EAAE,EACF,IAAI,IACF,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,IAAI,GAC/C,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfNegativeNumber.d.ts

@@ -1,10 +0,0 @@
-import { Chars, First, IfLiteral, NumberLike } from "../../index";
-/**
- * **IfNegative**`<TVal,TIf,[TElse]>`
- *
- * Branching utility which return `TIf` when `TVal` is _less than_ 0.
- *
- * **Related:** `IfLessThan`
- */
-export type IfNegativeNumber<TVal extends NumberLike, TIf, TElse = TVal> = IfLiteral<TVal, First<Chars<`${TVal}`>> extends "-" ? TIf : TElse, TIf | TElse>;
-//# sourceMappingURL=IfNegativeNumber.d.ts.map

package/dist/types/boolean-logic/branching/IfNegativeNumber.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfNegativeNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNegativeNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,KAAK,EAAE,KAAK,EAAE,SAAS,EAAG,UAAU,EAAE,oBAAwB;AAExE;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,IAAI,SAAS,UAAU,EACvB,GAAG,EACH,KAAK,GAAG,IAAI,IACV,SAAS,CACX,IAAI,EACJ,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,SAAS,GAAG,GACjC,GAAG,GACH,KAAK,EACP,GAAG,GAAG,KAAK,CACZ,CAAC"}

package/dist/types/boolean-logic/branching/IfNotEqual.d.ts

@@ -1,9 +0,0 @@
-import type { IsNotEqual } from "../../index";
-/**
- * **IfEqual**`<X,Y,IF,ELSE>`
- *
- * Type utility which returns type `IF` _if_ `X` is equivalent to `Y`; otherwise returns
- * type `ELSE`.
- */
-export type IfNotEqual<X, Y, IF, ELSE> = IsNotEqual<X, Y> extends true ? IF : ELSE;
-//# sourceMappingURL=IfNotEqual.d.ts.map

package/dist/types/boolean-logic/branching/IfNotEqual.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfNotEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNotEqual.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAwB;AAElD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,EACD,CAAC,EACD,EAAE,EACF,IAAI,IACF,UAAU,CAAC,CAAC,EAAC,CAAC,CAAC,SAAS,IAAI,GAC5B,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfNotError.d.ts

@@ -1,15 +0,0 @@
-import { ErrorCondition, IsError, IsErrorOptions, AsError } from "../../index";
-/**
- * **IfNotError**`<TType,TOptions,[IF],[ELSE]>`
- *
- * Branching utility which returns type `IF` when `T` is neither a _never_
- * value nor a `ErrorCondition`. Otherwise returns `ELSE`.
- *
- * - type of `
- * - type of `ELSE` is defaulted to `T` for convenience but can be set
- * to any type which is appropriate.
- *
- * **Related:** `IfError`, `IfErrorCondition`
- */
-export type IfNotError<TType, TOptions extends IsErrorOptions, IF = Exclude<TType, ErrorCondition>, ELSE = AsError<TType>> = IsError<TType, TOptions> extends false ? IF : ELSE;
-//# sourceMappingURL=IfNotError.d.ts.map

package/dist/types/boolean-logic/branching/IfNotError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfNotError.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNotError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAG,OAAO,EAAE,oBAAwB;AAGpF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,CACpB,KAAK,EACL,QAAQ,SAAS,cAAc,EAC/B,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,cAAc,CAAC,EACnC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IACnB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfNotLiteral.d.ts

@@ -1,8 +0,0 @@
-import { IsLiteral } from "../../index";
-/**
- * **IfLiteral**
- *
- * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
- */
-export type IfNotLiteral<T, IF, ELSE> = IsLiteral<T> extends false ? IF : ELSE;
-//# sourceMappingURL=IfNotLiteral.d.ts.map

package/dist/types/boolean-logic/branching/IfNotLiteral.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfNotLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNotLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAwB;AAE5C;;;;GAIG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,EAAE,EACF,IAAI,IACF,SAAS,CAAC,CAAC,CAAC,SAAS,KAAK,GAC1B,EAAE,GACF,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfNotNever.d.ts

@@ -1,8 +0,0 @@
-import { IsNever } from "../../index";
-/**
- * **IfNotNever**`<T,IF,ELSE>`
- *
- * Boolean type test which tests whether `T` extends _never_.
- */
-export type IfNotNever<T, IF = T, ELSE = never> = IsNever<T> extends true ? ELSE : IF;
-//# sourceMappingURL=IfNotNever.d.ts.map

package/dist/types/boolean-logic/branching/IfNotNever.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IfNotNever.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNotNever.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;GAIG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,EACD,EAAE,GAAG,CAAC,EACN,IAAI,GAAG,KAAK,IACV,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,EAAE,CAAC"}