inferred-types 0.51.0 → 0.51.2

package/dist/runtime/type-conversion/toNumber.js

@@ -0,0 +1,26 @@
+const convertScalar = (val) => {
+    switch (typeof val) {
+        case "number":
+            return val;
+        case "string":
+            return Number(val);
+        case "boolean":
+            return val ? 1 : 0;
+        default:
+            throw Error(`${typeof val} is an invalid scalar type to convert to a number!`);
+    }
+};
+const convertList = (val) => val.map(i => convertScalar(i));
+/**
+ * **toNumber**(value)
+ *
+ * Runtime utility which converts a value into a _numeric_ variant:
+ *
+ * - for scalars (and objects) it will try to convert to number but otherwise returns `NaN` to runtime and `never` to type system
+ * - for arrays it will iterate over each element and try to convert to a number like above
+ */
+export function toNumber(value) {
+    return (Array.isArray(value)
+        ? convertList(value)
+        : convertScalar(value));
+}

package/dist/runtime/type-conversion/union.d.ts

@@ -0,0 +1,10 @@
+import { Narrowable, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **union**(options) => (value)
+ *
+ * A higher order function which creates a union type with a runtime value set.
+ *
+ * **Related:** `unionize`
+ */
+export declare const union: <TOptions extends readonly Narrowable[]>(...options: TOptions) => <TValue extends TupleToUnion<TOptions>>(value: TValue) => TupleToUnion<TOptions>;
+//# sourceMappingURL=union.d.ts.map

package/dist/runtime/type-conversion/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-conversion/union.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAChB,QAAQ,SAAS,SAAS,UAAU,EAAE,cAE1B,QAAQ,MACpB,MAAM,SAAS,YAAY,CAAC,QAAQ,CAAC,SAC9B,MAAM,KAAc,YAAY,CAAC,QAAQ,CAAC,CAAC"}

package/dist/runtime/type-conversion/union.js

@@ -0,0 +1,8 @@
+/**
+ * **union**(options) => (value)
+ *
+ * A higher order function which creates a union type with a runtime value set.
+ *
+ * **Related:** `unionize`
+ */
+export const union = (...options) => (value) => value;

package/dist/runtime/type-conversion/unionize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * **unionize**(value,inUnionWith)
+ *
+ * Takes a runtime **value** and modifies it's type to be a union with
+ * the type of `inUnionWith` parameter (but does not change the actual
+ * runtime value).
+ */
+export declare function unionize<T, U>(value: T, inUnionWith: U): T | U;
+//# sourceMappingURL=unionize.d.ts.map

package/dist/runtime/type-conversion/unionize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unionize.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-conversion/unionize.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,EAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAE7D"}

package/dist/runtime/type-conversion/unionize.js

@@ -0,0 +1,11 @@
+/**
+ * **unionize**(value,inUnionWith)
+ *
+ * Takes a runtime **value** and modifies it's type to be a union with
+ * the type of `inUnionWith` parameter (but does not change the actual
+ * runtime value).
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function unionize(value, inUnionWith) {
+    return value;
+}

package/dist/runtime/type-guards/api-tg.d.ts

@@ -0,0 +1,33 @@
+import { Dictionary, Narrowable, OptionalParamFn, TypedFunction } from "inferred-types/dist/types/index";
+export declare const isEscapeFunction: <T>(val: T) => val is T & (() => unknown);
+/**
+ * **isOptionalParamFunction**`(val)`
+ *
+ * A type guard which ensures that the value passed in is not only a _function_
+ * but also has the `optionalParam` value set to **true** indicating that it
+ * is safe to be called _without_ parameters.
+ *
+ * **Note:** this is similar to an "escape function" but whereas an API can
+ * only have one escape function, an API may have as many ze
+ */
+export declare const isOptionalParamFunction: <T>(val: T) => val is T & OptionalParamFn;
+/**
+ * **isApi**`(val)`
+ *
+ * Type guard which validates that the value passed in is an `Api` type
+ * with "surface" and "_kind" property.
+ *
+ * **Related:** `isFluentApi()`
+ */
+export declare const isApi: <T extends Narrowable>(api: T) => api is T & {
+    __kind: "api";
+    surface: Dictionary | TypedFunction;
+};
+/**
+ * **isApiSurface**`(val)`
+ *
+ * A type guard which tests whether the value passed in is the SurfaceArea
+ * of an API (or could be).
+ */
+export declare const isApiSurface: <T>(val: T) => val is T & (Dictionary | TypedFunction);
+//# sourceMappingURL=api-tg.d.ts.map

package/dist/runtime/type-guards/api-tg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-tg.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-guards/api-tg.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,UAAU,EAAG,UAAU,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAK3G,eAAO,MAAM,gBAAgB,GAAI,CAAC,OAAO,CAAC,KAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,OAAO,CAErE,CAAA;AAGD;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,OAAO,CAAC,KAAG,GAAG,IAAI,CAAC,GAAG,eAE9D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,UAAU,OAAO,CAAC,KAAG,GAAG,IAAI,CAAC,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,UAAU,GAAG,aAAa,CAAA;CAEnH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,OAAO,CAAC,KAAG,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG,aAAa,CAE9E,CAAA"}

package/dist/runtime/type-guards/api-tg.js

@@ -0,0 +1,38 @@
+import { isFunction } from "./isFunction";
+import { isObject } from "./isObject";
+export const isEscapeFunction = (val) => {
+    return isFunction(val) && "escape" in val && val.escape === true;
+};
+/**
+ * **isOptionalParamFunction**`(val)`
+ *
+ * A type guard which ensures that the value passed in is not only a _function_
+ * but also has the `optionalParam` value set to **true** indicating that it
+ * is safe to be called _without_ parameters.
+ *
+ * **Note:** this is similar to an "escape function" but whereas an API can
+ * only have one escape function, an API may have as many ze
+ */
+export const isOptionalParamFunction = (val) => {
+    return isFunction(val) && "optionalParams" in val && val.optionalParams === true;
+};
+/**
+ * **isApi**`(val)`
+ *
+ * Type guard which validates that the value passed in is an `Api` type
+ * with "surface" and "_kind" property.
+ *
+ * **Related:** `isFluentApi()`
+ */
+export const isApi = (api) => {
+    return isObject(api) && "surface" in api && "_kind" in api && api._kind === "api";
+};
+/**
+ * **isApiSurface**`(val)`
+ *
+ * A type guard which tests whether the value passed in is the SurfaceArea
+ * of an API (or could be).
+ */
+export const isApiSurface = (val) => {
+    return isObject(val) && Object.keys(val).some(k => isEscapeFunction(val[k]));
+};

package/dist/runtime/type-guards/geo/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./isIso3166Alpha2";
+export * from "./isZipCode";
+export * from "./isUsState";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/type-guards/geo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/geo/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/dist/runtime/type-guards/geo/index.js

@@ -0,0 +1,3 @@
+export * from "./isIso3166Alpha2";
+export * from "./isZipCode";
+export * from "./isUsState";

package/dist/runtime/type-guards/geo/isIso3166Alpha2.d.ts

@@ -0,0 +1,46 @@
+import { Iso3166_1_Alpha2, Iso3166_1_Alpha3, Iso3166_1_CountryCode, Iso3166_1_CountryName } from "inferred-types/dist/types/index";
+/**
+ * Type guard which checks whether `val` is a 2 character country
+ * representation found in the ISO3166-1 standard.
+ */
+export declare const isIso3166Alpha2: (val: unknown) => val is Iso3166_1_Alpha2;
+/**
+ * Type guard which checks whether `val` is a 2 character country
+ * representation found in the ISO3166-1 standard.
+ *
+ * **Alias:** `isIso3166Alpha2`
+ */
+export declare const isCountryCode2: (val: unknown) => val is Iso3166_1_Alpha2;
+/**
+ * Type guard which checks whether `val` is a 3 character country
+ * representation found in the ISO3166-1 standard.
+ */
+export declare const isIso3166Alpha3: (val: unknown) => val is Iso3166_1_Alpha3;
+/**
+ * Type guard which checks whether `val` is a 3 character country
+ * representation found in the ISO3166-1 standard.
+ *
+ * **Alias:** `isIso3166Alpha3`
+ */
+export declare const isCountryCode3: (val: unknown) => val is Iso3166_1_Alpha3;
+/**
+ * Type guard which checks whether `val` is a 3 character country
+ * representation found in the ISO3166-1 standard.
+ */
+export declare const isIso3166CountryCode: (val: unknown) => val is Iso3166_1_CountryCode;
+/**
+ * Type guard which checks whether `val` is a 2 or 3 character country
+ * abbreviation found in the ISO3166-1 standard.
+ */
+export declare const isCountryAbbrev: (val: unknown) => val is Iso3166_1_Alpha2 | Iso3166_1_Alpha3;
+/**
+ * Type guard which checks whether `val` is a valid ISO3166-1 country name.
+ */
+export declare const isIso3166CountryName: (val: unknown) => val is Iso3166_1_CountryName;
+/**
+ * Type guard which checks whether `val` is a valid ISO3166-1 country name.
+ *
+ * **Alias:** `isIso3166CountryName`
+ */
+export declare const isCountryName: (val: unknown) => val is Iso3166_1_CountryName;
+//# sourceMappingURL=isIso3166Alpha2.d.ts.map

package/dist/runtime/type-guards/geo/isIso3166Alpha2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIso3166Alpha2.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/geo/isIso3166Alpha2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAInI;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAS,OAAO,KAAG,GAAG,IAAI,gBAGrD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAS,OAAO,KAAG,GAAG,IAAI,gBAGpD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAS,OAAO,KAAG,GAAG,IAAI,gBAGrD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAS,OAAO,KAAG,GAAG,IAAI,gBAGpD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAAS,OAAO,KAAG,GAAG,IAAI,qBAG1D,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAS,OAAO,KAAG,GAAG,IAAI,gBAAgB,GAAG,gBAExE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAAS,OAAO,KAAG,GAAG,IAAI,qBAG1D,CAAA;AAGD;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAAS,OAAO,KAAG,GAAG,IAAI,qBAGnD,CAAA"}

package/dist/runtime/type-guards/geo/isIso3166Alpha2.js

@@ -0,0 +1,69 @@
+import { isString } from "../isString";
+import { ISO3166_1 } from "inferred-types/dist/constants/index";
+/**
+ * Type guard which checks whether `val` is a 2 character country
+ * representation found in the ISO3166-1 standard.
+ */
+export const isIso3166Alpha2 = (val) => {
+    const codes = ISO3166_1.map(i => i["alpha2"]);
+    return isString(val) && codes.includes(val);
+};
+/**
+ * Type guard which checks whether `val` is a 2 character country
+ * representation found in the ISO3166-1 standard.
+ *
+ * **Alias:** `isIso3166Alpha2`
+ */
+export const isCountryCode2 = (val) => {
+    const codes = ISO3166_1.map(i => i["alpha2"]);
+    return isString(val) && codes.includes(val);
+};
+/**
+ * Type guard which checks whether `val` is a 3 character country
+ * representation found in the ISO3166-1 standard.
+ */
+export const isIso3166Alpha3 = (val) => {
+    const codes = ISO3166_1.map(i => i["alpha3"]);
+    return isString(val) && codes.includes(val);
+};
+/**
+ * Type guard which checks whether `val` is a 3 character country
+ * representation found in the ISO3166-1 standard.
+ *
+ * **Alias:** `isIso3166Alpha3`
+ */
+export const isCountryCode3 = (val) => {
+    const codes = ISO3166_1.map(i => i["alpha3"]);
+    return isString(val) && codes.includes(val);
+};
+/**
+ * Type guard which checks whether `val` is a 3 character country
+ * representation found in the ISO3166-1 standard.
+ */
+export const isIso3166CountryCode = (val) => {
+    const codes = ISO3166_1.map(i => i["countryCode"]);
+    return isString(val) && codes.includes(val);
+};
+/**
+ * Type guard which checks whether `val` is a 2 or 3 character country
+ * abbreviation found in the ISO3166-1 standard.
+ */
+export const isCountryAbbrev = (val) => {
+    return isCountryCode2(val) || isCountryCode3(val);
+};
+/**
+ * Type guard which checks whether `val` is a valid ISO3166-1 country name.
+ */
+export const isIso3166CountryName = (val) => {
+    const codes = ISO3166_1.map(i => i["name"]);
+    return isString(val) && codes.includes(val);
+};
+/**
+ * Type guard which checks whether `val` is a valid ISO3166-1 country name.
+ *
+ * **Alias:** `isIso3166CountryName`
+ */
+export const isCountryName = (val) => {
+    const codes = ISO3166_1.map(i => i["name"]);
+    return isString(val) && codes.includes(val);
+};

package/dist/runtime/type-guards/geo/isUsState.d.ts

@@ -0,0 +1,4 @@
+import { UsStateAbbrev, UsStateName } from "inferred-types/dist/types/index";
+export declare const isUsStateAbbreviation: (val: unknown) => val is UsStateAbbrev;
+export declare const isUsStateName: (val: unknown) => val is UsStateName;
+//# sourceMappingURL=isUsState.d.ts.map

package/dist/runtime/type-guards/geo/isUsState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isUsState.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/geo/isUsState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAO5E,eAAO,MAAM,qBAAqB,QAAS,OAAO,KAAG,GAAG,IAAI,aAE3D,CAAA;AAED,eAAO,MAAM,aAAa,QAAS,OAAO,KAAG,GAAG,IAAI,WAEnD,CAAA"}

package/dist/runtime/type-guards/geo/isUsState.js

@@ -0,0 +1,10 @@
+import { isString } from "../isString";
+import { US_STATE_LOOKUP } from "inferred-types/dist/constants/index";
+const ABBREV = US_STATE_LOOKUP.map(i => i.abbrev);
+const NAME = US_STATE_LOOKUP.map(i => i.name);
+export const isUsStateAbbreviation = (val) => {
+    return isString(val) && ABBREV.includes(val);
+};
+export const isUsStateName = (val) => {
+    return isString(val) && NAME.includes(val);
+};

package/dist/runtime/type-guards/geo/isZipCode.d.ts

@@ -0,0 +1,23 @@
+import { Zip5, ZipCode, ZipPlus4 } from "inferred-types/dist/types/index";
+/**
+ * Type guard which validates that passed in value is a US ZipCode
+ * in the `Zip5` format.
+ *
+ * **Related:** `isZipCode()`, `isZipPlus4()`
+ */
+export declare const isZipCode5: (val: unknown) => val is Zip5;
+/**
+ * Type guard which validates that passed in value is a US ZipCode
+ * in the `ZipPlus4` format.
+ *
+ * **Related:** `isZipCode()`, `isZipCode5()`
+ */
+export declare const isZipPlus4: (val: unknown) => val is ZipPlus4;
+/**
+ * Type guard which validates that passed in value is a US ZipCode
+ * in either the `Zip5` or `ZipPlus4` format.
+ *
+ * **Related:** `isZipCode5()`, `isZipPlus4()`
+ */
+export declare const isZipCode: (val: unknown) => val is ZipCode;
+//# sourceMappingURL=isZipCode.d.ts.map

package/dist/runtime/type-guards/geo/isZipCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isZipCode.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/geo/isZipCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAO1E;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAS,OAAO,KAAG,GAAG,IAAI,IAKhD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAS,OAAO,KAAG,GAAG,IAAI,QAQhD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,QAAS,OAAO,KAAG,GAAG,IAAI,OAE/C,CAAA"}

package/dist/runtime/type-guards/geo/isZipCode.js

@@ -0,0 +1,40 @@
+import { isString } from "../isString";
+import { isNumber } from "../isNumber";
+import { isNumberLike } from "../isNumericString";
+import { retainWhile, stripChars } from "src/runtime/index";
+import { NUMERIC_CHAR } from "inferred-types/dist/constants/index";
+/**
+ * Type guard which validates that passed in value is a US ZipCode
+ * in the `Zip5` format.
+ *
+ * **Related:** `isZipCode()`, `isZipPlus4()`
+ */
+export const isZipCode5 = (val) => {
+    if (isNumber(val)) {
+        return isZipCode5(`${val}`);
+    }
+    return isString(val) && val.trim().length === 5 && isNumberLike(val.trim());
+};
+/**
+ * Type guard which validates that passed in value is a US ZipCode
+ * in the `ZipPlus4` format.
+ *
+ * **Related:** `isZipCode()`, `isZipCode5()`
+ */
+export const isZipPlus4 = (val) => {
+    if (isString(val)) {
+        const first = retainWhile(val.trim(), ...NUMERIC_CHAR);
+        const next = stripChars(val.trim().replace(first, "").trim(), "-");
+        return first.length === 5 && next.length === 4 && isNumberLike(next);
+    }
+    return false;
+};
+/**
+ * Type guard which validates that passed in value is a US ZipCode
+ * in either the `Zip5` or `ZipPlus4` format.
+ *
+ * **Related:** `isZipCode5()`, `isZipPlus4()`
+ */
+export const isZipCode = (val) => {
+    return isZipCode5(val) || isZipPlus4(val);
+};

package/dist/runtime/type-guards/hasDefaultValue.d.ts

@@ -0,0 +1,13 @@
+import { Narrowable } from "inferred-types/dist/types/index";
+import { NoDefaultValue } from "inferred-types/dist/constants/index";
+/**
+ * **hasDefaultValue**(value)
+ *
+ * Type guard which helps to eliminate the use case where a value which _might_ be a
+ * `DefaultValue` is _not_ in this initial state and therefore indicating that the value
+ * **is** in fact a default value.
+ *
+ * Probably a better way to phrase this. :)
+ */
+export declare function hasDefaultValue<T extends Narrowable>(value: T): value is Exclude<T, NoDefaultValue>;
+//# sourceMappingURL=hasDefaultValue.d.ts.map

package/dist/runtime/type-guards/hasDefaultValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasDefaultValue.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-guards/hasDefaultValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAErE;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,UAAU,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,cAAc,CAAC,CAGnG"}

package/dist/runtime/type-guards/hasDefaultValue.js

@@ -0,0 +1,14 @@
+import { isSpecificConstant } from "./isSpecificConstant";
+/**
+ * **hasDefaultValue**(value)
+ *
+ * Type guard which helps to eliminate the use case where a value which _might_ be a
+ * `DefaultValue` is _not_ in this initial state and therefore indicating that the value
+ * **is** in fact a default value.
+ *
+ * Probably a better way to phrase this. :)
+ */
+export function hasDefaultValue(value) {
+    const noDefault = isSpecificConstant("no-default-value");
+    return noDefault(value) ? false : true;
+}

package/dist/runtime/type-guards/hasErrorConditions.d.ts

@@ -0,0 +1,3 @@
+import { ErrorCondition } from "inferred-types/dist/types/index";
+export declare const hasErrorConditions: <T extends readonly unknown[]>(list: T) => list is T & readonly [...unknown[], ErrorCondition<string>];
+//# sourceMappingURL=hasErrorConditions.d.ts.map

package/dist/runtime/type-guards/hasErrorConditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasErrorConditions.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-guards/hasErrorConditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGjE,eAAO,MAAM,kBAAkB,GAC7B,CAAC,SAAS,SAAS,OAAO,EAAE,QACtB,CAAC,KAAG,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC,GAAG,OAAO,EAAE,EAAE,cAAc,CAAC,MAAM,CAAC,CAErE,CAAC"}

package/dist/runtime/type-guards/hasErrorConditions.js

@@ -0,0 +1,4 @@
+import { isErrorCondition } from "./isErrorCondition";
+export const hasErrorConditions = (list) => {
+    return list.some(i => isErrorCondition(i));
+};

package/dist/runtime/type-guards/hasIndexOf.d.ts

@@ -0,0 +1,9 @@
+import { Container, Dictionary, Tuple } from "inferred-types/dist/types/index";
+/**
+ * **hasIndexOf**(value, idx) => boolean
+ *
+ * A type guard which determines whether container passed in has
+ * an explicit index.
+ */
+export declare const hasIndexOf: <TContainer extends Container, TIndex extends PropertyKey>(value: TContainer, idx: TIndex) => value is TContainer & (TContainer extends Tuple ? Tuple<TIndex> : TContainer extends Dictionary ? Record<TIndex, unknown> : never);
+//# sourceMappingURL=hasIndexOf.d.ts.map

package/dist/runtime/type-guards/hasIndexOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasIndexOf.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-guards/hasIndexOf.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAgB,UAAU,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAI7F;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACrB,UAAU,SAAS,SAAS,EAC5B,MAAM,SAAS,WAAW,SAEjB,UAAU,OACZ,MAAM,KACZ,KAAK,IAAI,UAAU,GACpB,CAAC,UAAU,SAAS,KAAK,GACrB,KAAK,CAAC,MAAM,CAAC,GACb,UAAU,SAAS,UAAU,GACzB,MAAM,CAAC,MAAM,EAAC,OAAO,CAAC,GACtB,KAAK,CAYd,CAAC"}

package/dist/runtime/type-guards/hasIndexOf.js

@@ -0,0 +1,17 @@
+import { isErrorCondition, isObject } from "src/runtime/index";
+/**
+ * **hasIndexOf**(value, idx) => boolean
+ *
+ * A type guard which determines whether container passed in has
+ * an explicit index.
+ */
+export const hasIndexOf = (value, idx) => {
+    const result = isObject(value)
+        ? String(idx) in value
+        : Array.isArray(value)
+            ? Number(idx) in value
+            : false;
+    return (isErrorCondition(result, "invalid-index")
+        ? false
+        : result);
+};

package/dist/runtime/type-guards/hasKeys.d.ts

@@ -0,0 +1,15 @@
+import { AsObject, EnsureKeys } from "inferred-types/dist/types/index";
+/**
+ * **hasKeys**(props) => (obj) => `HasKeys<O,P>`
+ *
+ * Higher order type guard which on first call generates
+ * a type guard that can test for the existence of the
+ * properties passed into this first call.
+ *
+ * ```ts
+ * const hasFooBar = hasKeys(["foo", "bar"]); // type guard
+ * const hasFooBarToo = hasKeys({foo: 1, bar: 1});
+ * ```
+ */
+export declare const hasKeys: <P extends readonly string[] | [Record<string, unknown>]>(...props: P) => <T>(val: T) => val is T & ([EnsureKeys<AsObject<T>, ["name"]>] extends never[] ? never : EnsureKeys<AsObject<T>, P>);
+//# sourceMappingURL=hasKeys.d.ts.map

package/dist/runtime/type-guards/hasKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasKeys.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-guards/hasKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAItE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAClB,CAAC,SAAS,SAAS,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,YAC7C,CAAC,MAOX,CAAC,OACI,CAAC,KAAG,GAAG,IAAI,CAAC,GAAE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,GACrE,KAAK,GACL,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,CAS5B,CAAA"}

package/dist/runtime/type-guards/hasKeys.js

@@ -0,0 +1,26 @@
+import { isObject } from "./isObject";
+import { isFunction } from "./isFunction";
+/**
+ * **hasKeys**(props) => (obj) => `HasKeys<O,P>`
+ *
+ * Higher order type guard which on first call generates
+ * a type guard that can test for the existence of the
+ * properties passed into this first call.
+ *
+ * ```ts
+ * const hasFooBar = hasKeys(["foo", "bar"]); // type guard
+ * const hasFooBarToo = hasKeys({foo: 1, bar: 1});
+ * ```
+ */
+export const hasKeys = (...props) => 
+/**
+ * Type guard which validates whether the configured properties
+ * exist on a given `Record<ObjectKey, unknown` and if they do at
+ * runtime will provide the type support for them.
+ */
+(val) => {
+    const keys = Array.isArray(props)
+        ? props
+        : Object.keys(props).filter(i => typeof i === "string");
+    return (isFunction(val) || isObject(val)) && keys.every(k => k in val) ? true : false;
+};

package/dist/runtime/type-guards/hasWhitespace.d.ts

@@ -0,0 +1,7 @@
+/**
+ * **hasWhiteSpace**`(val)`
+ *
+ * Type guard which checks whether a string has a any whitespace characters in it
+ */
+export declare const hasWhiteSpace: <T>(val: T) => val is T;
+//# sourceMappingURL=hasWhitespace.d.ts.map

package/dist/runtime/type-guards/hasWhitespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasWhitespace.d.ts","sourceRoot":"","sources":["../../../src/runtime/type-guards/hasWhitespace.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,OAAO,CAAC,KAAG,GAAG,IAAI,CAEhD,CAAA"}

package/dist/runtime/type-guards/hasWhitespace.js

@@ -0,0 +1,11 @@
+import { WHITESPACE_CHARS } from "inferred-types/dist/constants/index";
+import { asChars } from "../type-conversion";
+import { isString } from "./isString";
+/**
+ * **hasWhiteSpace**`(val)`
+ *
+ * Type guard which checks whether a string has a any whitespace characters in it
+ */
+export const hasWhiteSpace = (val) => {
+    return isString(val) && asChars(val).some(c => WHITESPACE_CHARS.includes(c));
+};

package/dist/runtime/type-guards/higher-order/endsWith.d.ts

@@ -0,0 +1,10 @@
+import { Narrowable } from "inferred-types/dist/types/index";
+export type EndingWithTypeGuard<T extends string> = <V extends Narrowable>(val: V) => val is V & `${string}${T}`;
+/**
+ * **endsWith**(endingIn) => (val)
+ *
+ * Creates a TypeGuard which checks whether a value _ends with_ a
+ * particular string literal.
+ */
+export declare const endsWith: <T extends string>(endingIn: T) => EndingWithTypeGuard<T>;
+//# sourceMappingURL=endsWith.d.ts.map

package/dist/runtime/type-guards/higher-order/endsWith.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endsWith.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/higher-order/endsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAI7D,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,MAAM,IAAI,CAClD,CAAC,SAAS,UAAU,EACpB,GAAG,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GACnB,CAAC,SAAS,MAAM,YACN,CAAC,KAAG,mBAAmB,CAAC,CAAC,CAMpC,CAAC"}

package/dist/runtime/type-guards/higher-order/endsWith.js

@@ -0,0 +1,14 @@
+import { isString, isNumber } from "src/runtime/index";
+/**
+ * **endsWith**(endingIn) => (val)
+ *
+ * Creates a TypeGuard which checks whether a value _ends with_ a
+ * particular string literal.
+ */
+export const endsWith = (endingIn) => (val) => {
+    return isString(val)
+        ? val.endsWith(endingIn) ? true : false
+        : isNumber(val)
+            ? String(val).endsWith(endingIn) ? true : false
+            : false;
+};

package/dist/runtime/type-guards/higher-order/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./endsWith";
+export * from "./startsWith";
+export * from "./isEqual";
+export * from "./isLength";
+export * from "./isTypeOf";
+export * from "./isSameTypeOf";
+export * from "./isTuple";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/type-guards/higher-order/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/higher-order/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC"}

package/dist/runtime/type-guards/higher-order/index.js

@@ -0,0 +1,7 @@
+export * from "./endsWith";
+export * from "./startsWith";
+export * from "./isEqual";
+export * from "./isLength";
+export * from "./isTypeOf";
+export * from "./isSameTypeOf";
+export * from "./isTuple";

package/dist/runtime/type-guards/higher-order/isEqual.d.ts

@@ -0,0 +1,12 @@
+import { Narrowable, TypeGuard } from "inferred-types/dist/types/index";
+/**
+ * A TypeGuard which was generated from `isEqual()` runtime util.
+ */
+export type EqualTo<T extends Narrowable> = TypeGuard<T>;
+/**
+ * **isEqual**(compareTo)(value)
+ *
+ * Higher order type guard to detect whether two values are equal
+ */
+export declare const isEqual: <TBase extends Narrowable>(base: TBase) => EqualTo<TBase>;
+//# sourceMappingURL=isEqual.d.ts.map

package/dist/runtime/type-guards/higher-order/isEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqual.d.ts","sourceRoot":"","sources":["../../../../src/runtime/type-guards/higher-order/isEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAG,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAIzE;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,UAAU,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAClB,KAAK,SAAS,UAAU,QAClB,KAAK,KAAG,OAAO,CAAC,KAAK,CAMhB,CAAC"}

package/dist/runtime/type-guards/higher-order/isEqual.js

@@ -0,0 +1,11 @@
+import { isSameTypeOf } from "src/runtime/index";
+/**
+ * **isEqual**(compareTo)(value)
+ *
+ * Higher order type guard to detect whether two values are equal
+ */
+export const isEqual = (base) => (value) => isSameTypeOf(base)(value)
+    ? value === base
+        ? true
+        : false
+    : false;

package/dist/runtime/type-guards/higher-order/isLength.d.ts

@@ -0,0 +1,14 @@
+/**
+ * **ifLength**(len) => (value) => boolean
+ *
+ * Higher order type guard which provides a type-aware check on the
+ * "length" of some unit:
+ *
+ * - **arrays** - the number of elements in the array
+ * - **objects** - the number of keys in the object
+ * - **string** - the length of the string
+ *
+ * All other types return `false`
+ */
+export declare function isLength<TValue, TLen extends number>(value: TValue, len: TLen): boolean;
+//# sourceMappingURL=isLength.d.ts.map