is-what 4.1.0

package/test/ava.ts

@@ -0,0 +1,419 @@
+import test from 'ava'
+
+import {
+  isError,
+  isEmptyArray,
+  isObject,
+  isPlainObject,
+  isAnyObject,
+  isUndefined,
+  isNull,
+  isNullOrUndefined,
+  isFunction,
+  isArray,
+  isString,
+  isEmptyString,
+  isFullString,
+  isBoolean,
+  isRegExp,
+  isNumber,
+  isPositiveNumber,
+  isNegativeNumber,
+  isDate,
+  isSymbol,
+  isPrimitive,
+  isType,
+  isMap,
+  isWeakMap,
+  isSet,
+  isWeakSet,
+  isFullArray,
+  // isBlob,
+  // isFile,
+  isPromise,
+  isNaNValue,
+  isEmptyObject,
+  isOneOf,
+  isFullObject,
+} from '../src/index.js'
+
+// TODO: test isBlob
+// test('isBlob', () => {
+//   expect(isBlob(Blob)).toBe(false)
+//   expect(isBlob(new Blob())).toBe(true)
+// })
+
+// TODO: test isFile
+// test('isFile', () => {
+//   expect(isFile(File)).toBe(false)
+//   expect(isFile(new File([''], '', { type: 'text/html' }))).toBe(true)
+// })
+
+test('Basic true tests', (t: any) => {
+  t.is(isError(new Error('')), true)
+  t.is(isUndefined(undefined), true)
+  t.is(isNull(null), true)
+  t.is(isNullOrUndefined(null), true)
+  t.is(isNullOrUndefined(undefined), true)
+  t.is(isObject({}), true)
+  t.is(isEmptyObject({}), true)
+  t.is(isFullObject({ 0: '' }), true)
+  t.is(isFullObject({ '': '' }), true)
+  t.is(isObject(new Object()), true)
+  t.is(isArray([]), true)
+  t.is(isEmptyArray([]), true)
+  t.is(isFullArray(['']), true)
+  t.is(isArray(new Array()), true)
+  t.is(isString(''), true)
+  t.is(isString('_'), true)
+  t.is(isEmptyString(''), true)
+  t.is(isFullString(' '), true)
+  t.is(isBoolean(true), true)
+  t.is(isBoolean(false), true)
+  t.is(isRegExp(/./), true)
+  t.is(isRegExp(/./gi), true)
+  t.is(isNumber(0), true)
+  t.is(isNumber(1), true)
+  t.is(isDate(new Date()), true)
+  t.is(isSymbol(Symbol()), true)
+  t.is(isMap(new Map()), true)
+  t.is(isWeakMap(new WeakMap()), true)
+  t.is(isSet(new Set()), true)
+  t.is(isWeakSet(new WeakSet()), true)
+  // t.is(isBlob(blob), true)
+  // t.is(isFile(new File([''], '', { type: 'text/html' })), true)
+  t.is(isPromise(new Promise((resolve, reject) => {})), true)
+})
+
+test('Basic false tests', (t: any) => {
+  t.is(isError({}), false)
+  t.is(isNumber(NaN), false)
+  t.is(isDate(new Date('_')), false)
+  t.is(isDate(NaN), false)
+  t.is(isUndefined(NaN), false)
+  t.is(isNull(NaN), false)
+  t.is(isObject(NaN), false)
+  t.is(isArray(NaN), false)
+  t.is(isString(NaN), false)
+  t.is(isEmptyString(' '), false)
+  t.is(isFullString(''), false)
+  t.is(isBoolean(NaN), false)
+  t.is(isRegExp(NaN), false)
+  t.is(isSymbol(NaN), false)
+  t.is(isMap(new WeakMap()), false)
+  t.is(isWeakMap(new Map()), false)
+  t.is(isSet(new WeakSet()), false)
+  t.is(isWeakSet(new Set()), false)
+  t.is(isNullOrUndefined(NaN), false)
+})
+
+test('isFunction', (t: any) => {
+  t.is(isFunction(NaN), false)
+  t.is(
+    isFunction(() => {}),
+    true
+  )
+  t.is(
+    isFunction(function () {}),
+    true
+  )
+  t.is(
+    isFunction(async () => {}),
+    true
+  )
+  t.is(
+    isFunction(async function () {}),
+    true
+  )
+  t.is(
+    isFunction(function* () {}),
+    true
+  )
+  t.is(
+    isFunction(async function* () {}),
+    true
+  )
+  const _ = { fn: () => {}, method() {} }
+  t.is(isFunction(_.fn), true)
+  t.is(isFunction(_.method), true)
+})
+
+test('isEmptyObject', (t: any) => {
+  t.is(isEmptyObject({}), true)
+  t.is(isEmptyObject(new Object()), true)
+
+  t.is(isEmptyObject('{}'), false)
+  t.is(isEmptyObject('{}'), false)
+  t.is(isEmptyObject(null), false)
+  t.is(isEmptyObject(new Date()), false)
+  t.is(isEmptyObject(new Error('')), false)
+  t.is(isEmptyObject(new Date()), false)
+  t.is(isEmptyObject(Symbol()), false)
+  t.is(isEmptyObject(new Map()), false)
+  t.is(isEmptyObject(new WeakMap()), false)
+  t.is(isEmptyObject(new Set()), false)
+  t.is(isEmptyObject(new WeakSet()), false)
+})
+
+test('isEmptyArray', (t: any) => {
+  t.is(isEmptyArray([]), true)
+  t.is(isEmptyArray(new Array()), true)
+  t.is(isEmptyArray(new Array(0)), true)
+
+  t.is(isEmptyArray(new Array(1)), false)
+  t.is(isEmptyArray([undefined]), false)
+  t.is(isEmptyArray(null), false)
+  t.is(isEmptyArray(new Date()), false)
+  t.is(isEmptyArray(new Error('')), false)
+  t.is(isEmptyArray(new Date()), false)
+  t.is(isEmptyArray(Symbol()), false)
+  t.is(isEmptyArray(new Map()), false)
+  t.is(isEmptyArray(new WeakMap()), false)
+  t.is(isEmptyArray(new Set()), false)
+  t.is(isEmptyArray(new WeakSet()), false)
+})
+
+test('isFullArray', (t: any) => {
+  t.is(isFullArray(new Array(1)), true)
+  t.is(isFullArray([undefined]), true)
+  t.is(isFullArray([null]), true)
+  t.is(isFullArray(['']), true)
+
+  t.is(isFullArray([]), false)
+  t.is(isFullArray(new Array()), false)
+  t.is(isFullArray(new Array(0)), false)
+
+  t.is(isFullArray(null), false)
+  t.is(isFullArray(new Date()), false)
+  t.is(isFullArray(new Error('')), false)
+  t.is(isFullArray(new Date()), false)
+  t.is(isFullArray(Symbol()), false)
+  t.is(isFullArray(new Map()), false)
+  t.is(isFullArray(new WeakMap()), false)
+  t.is(isFullArray(new Set()), false)
+  t.is(isFullArray(new WeakSet()), false)
+})
+
+test('isPositiveNumber / isNegativeNumber', (t: any) => {
+  t.is(isPositiveNumber(-1), false)
+  t.is(isPositiveNumber(0), false)
+  t.is(isPositiveNumber(1), true)
+  t.is(isNegativeNumber(-1), true)
+  t.is(isNegativeNumber(0), false)
+  t.is(isNegativeNumber(1), false)
+})
+
+test('NaN tests', (t: any) => {
+  t.is(isNaNValue(NaN), true)
+  t.is(isNaNValue(new Error('')), false)
+  t.is(isNaNValue(undefined), false)
+  t.is(isNaNValue(null), false)
+  t.is(isNaNValue(undefined), false)
+  t.is(isNaNValue({}), false)
+  t.is(isNaNValue(new Object()), false)
+  t.is(
+    isNaNValue(() => {}),
+    false
+  )
+  t.is(isNaNValue([]), false)
+  t.is(isNaNValue(new Array()), false)
+  t.is(isNaNValue(''), false)
+  t.is(isNaNValue('_'), false)
+  t.is(isNaNValue(''), false)
+  t.is(isNaNValue(' '), false)
+  t.is(isNaNValue(true), false)
+  t.is(isNaNValue(false), false)
+  t.is(isNaNValue(/./), false)
+  t.is(isNaNValue(/./gi), false)
+  t.is(isNaNValue(0), false)
+  t.is(isNaNValue(1), false)
+  t.is(isNaNValue(new Date()), false)
+  t.is(isNaNValue(Symbol()), false)
+  t.is(isNaNValue(new Map()), false)
+  t.is(isNaNValue(new WeakMap()), false)
+  t.is(isNaNValue(new Set()), false)
+  t.is(isNaNValue(new WeakSet()), false)
+  t.is(isNaNValue(new Promise((resolve, reject) => {})), false)
+})
+
+test('Primitive tests', (t: any) => {
+  // true
+  t.is(isPrimitive(0), true)
+  t.is(isPrimitive(''), true)
+  t.is(isPrimitive('str'), true)
+  t.is(isPrimitive(Symbol()), true)
+  t.is(isPrimitive(true), true)
+  t.is(isPrimitive(false), true)
+  t.is(isPrimitive(null), true)
+  t.is(isPrimitive(undefined), true)
+  // false
+  t.is(isPrimitive(NaN), false)
+  t.is(isPrimitive([]), false)
+  t.is(isPrimitive(new Array()), false)
+  t.is(isPrimitive({}), false)
+  t.is(isPrimitive(new Object()), false)
+  t.is(isPrimitive(new Date()), false)
+  t.is(
+    isPrimitive(() => {}),
+    false
+  )
+})
+
+test('Date exception', (t: any) => {
+  t.is(isDate(new Date('_')), false)
+})
+
+test('Generic isType', (t: any) => {
+  // -----------------------------
+  // This is correct old fashion syntax for classes, if this is missing
+  function MyClass() {}
+  MyClass.prototype.constructor = MyClass
+  // @ts-ignore
+  const myClass = new MyClass()
+  // -----------------------------
+  class MyOtherClass {
+    constructor() {}
+  }
+  // this is expected behaviour
+  t.is(isType('', String), true)
+  t.is(isType('_', String), true)
+  t.is(isType('Hello World', String), true)
+  t.is(isType(NaN, Number), true)
+  t.is(isType(0, Number), true)
+  t.is(isType(1, Number), true)
+  t.is(isType({}, Object), true)
+  t.is(isType(new Object(), Object), true)
+  t.is(isType([], Array), true)
+  t.is(isType(new Array(), Array), true)
+  t.is(
+    isType(() => {}, Function),
+    true
+  )
+  t.is(isType(true, Boolean), true)
+  t.is(isType(false, Boolean), true)
+  t.is(isType(new Date('_'), Date), true)
+  t.is(isType(new Date(), Date), true)
+  t.is(isType(/./, RegExp), true)
+  t.is(isType(/./gi, RegExp), true)
+  t.is(isType(myClass, MyClass), true)
+  t.is(isType(new MyOtherClass(), MyOtherClass), true)
+  t.is(isType(myClass, MyOtherClass), false)
+  t.is(isType(Symbol(), Symbol), true)
+  // t.is(isType(null, Null), true)
+  // t.is(isType(undefined, Undefined), true)
+  // It SHOULD fail
+  t.is(isType(5, String), false)
+  t.is(isType(null, Object), false)
+  // Not sure if this would be the expected behaviour but everything is an object
+  // so I would say so
+  t.is(isType(myClass, Object), true)
+})
+
+test('isObject vs isAnyObject', (t: any) => {
+  // -----------------------------
+  // This is correct old fashion syntax for classes, if this is missing
+  function MyClass() {}
+  MyClass.prototype.constructor = MyClass
+  // @ts-ignore
+  const myClass = new MyClass()
+  // -----------------------------
+  class MyClass2 {
+    constructor() {}
+  }
+  const myClass2 = new MyClass2()
+  const mySpecialObject = {}
+  Object.setPrototypeOf(mySpecialObject, {
+    toDate: function () {
+      return new Date()
+    },
+  })
+  // IS OBJECT
+  // plain object
+  t.is(isObject({}), true)
+  t.is(isObject(new Object()), true)
+  t.is(isPlainObject({}), true)
+  t.is(isPlainObject(new Object()), true)
+  // classes & prototypes
+  t.is(isObject(myClass), false)
+  t.is(isObject(myClass2), false)
+  t.is(isObject(mySpecialObject), false)
+  t.is(isPlainObject(myClass), false)
+  t.is(isPlainObject(myClass2), false)
+  t.is(isPlainObject(mySpecialObject), false)
+  // arrays and dates
+  t.is(isObject([]), false)
+  t.is(isObject(new Array()), false)
+  t.is(isObject(new Date('_')), false)
+  t.is(isObject(new Date()), false)
+  t.is(isPlainObject([]), false)
+  t.is(isPlainObject(new Array()), false)
+  t.is(isPlainObject(new Date('_')), false)
+  t.is(isPlainObject(new Date()), false)
+  // IS ANY OBJECT
+  // plain object
+  t.is(isAnyObject({}), true)
+  t.is(isAnyObject(new Object()), true)
+  // classes & prototypes
+  t.is(isAnyObject(myClass), true)
+  t.is(isAnyObject(myClass2), true)
+  t.is(isAnyObject(mySpecialObject), true)
+  // arrays and dates
+  t.is(isAnyObject([]), false)
+  t.is(isAnyObject(new Array()), false)
+  t.is(isAnyObject(new Date('_')), false)
+  t.is(isAnyObject(new Date()), false)
+})
+
+test('isOneOf', (t: any) => {
+  t.is(isOneOf(isString, isNumber)('_'), true)
+  t.is(isOneOf(isString, isNumber)(1), true)
+  t.is(isOneOf(isString, isNumber)(undefined), false)
+
+  t.is(isOneOf(isString, isNumber, isBoolean)('_'), true)
+  t.is(isOneOf(isString, isNumber, isBoolean)(1), true)
+  t.is(isOneOf(isString, isNumber, isBoolean)(true), true)
+  t.is(isOneOf(isString, isNumber, isBoolean)(undefined), false)
+
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray)('_'), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(1), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(true), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray)([]), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(undefined), false)
+
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)('_'), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(1), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(true), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)([]), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)({}), true)
+  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(undefined), false)
+})
+
+test('type related tests', (t: any) => {
+  t.pass()
+  // const fn: string | ((k: number) => string) = (p) => 'a'
+  // if (!isFunction(fn)) {
+  //   fn
+  // }
+
+  // const a: Record<string, number> = {}
+
+  // a[fn(1)] = fn(2)
+
+  // const myArray: string | string[] = ['a', 'b']
+  // if (!isArray(myArray)) {
+  //   myArray
+  // }
+
+  // const a: Record<string, number> = {}
+
+  // a[myArray[1]] = myArray[0]
+
+  // const myArray: string | any[] = [1, 2, 'a', 'b']
+  // if (!isArray(myArray)) {
+  //   myArray
+  // }
+
+  // const a: Record<string, number> = {}
+
+  // a[myArray[1]] = myArray[0]
+})

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "ES2020",
+    "target": "ES2019",
+    "lib": ["ES2020", "DOM"],
+    "strict": true,
+    "moduleResolution": "node",
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "declarationDir": "./types/"
+  },
+  "include": ["src/**/*", "test/**/*"]
+}

package/types/index.d.ts

@@ -0,0 +1,267 @@
+export declare type AnyFunction = (...args: any[]) => any;
+export declare type AnyAsyncFunction = (...args: any[]) => Promise<any>;
+export declare type AnyClass = new (...args: any[]) => any;
+export declare type PlainObject = Record<string | number | symbol, any>;
+declare type TypeGuard<A, B extends A> = (payload: A) => payload is B;
+/**
+ * Returns the object type of the given payload
+ *
+ * @param {*} payload
+ * @returns {string}
+ */
+export declare function getType(payload: any): string;
+/**
+ * Returns whether the payload is undefined
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
+export declare function isUndefined(payload: any): payload is undefined;
+/**
+ * Returns whether the payload is null
+ *
+ * @param {*} payload
+ * @returns {payload is null}
+ */
+export declare function isNull(payload: any): payload is null;
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+export declare function isPlainObject(payload: any): payload is PlainObject;
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+export declare function isObject(payload: any): payload is PlainObject;
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is { [K in any]: never }}
+ */
+export declare function isEmptyObject(payload: any): payload is {
+    [K in any]: never;
+};
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+export declare function isFullObject(payload: any): payload is PlainObject;
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+export declare function isAnyObject(payload: any): payload is PlainObject;
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T this must be passed in < >
+ * @param {*} payload
+ * @returns {payload is T}
+ */
+export declare function isObjectLike<T extends PlainObject>(payload: any): payload is T;
+/**
+ * Returns whether the payload is a function (regular or async)
+ *
+ * @param {*} payload
+ * @returns {payload is AnyFunction}
+ */
+export declare function isFunction(payload: any): payload is AnyFunction;
+/**
+ * Returns whether the payload is an array
+ *
+ * @param {any} payload
+ * @returns {payload is any[]}
+ */
+export declare function isArray(payload: any): payload is any[];
+/**
+ * Returns whether the payload is a an array with at least 1 item
+ *
+ * @param {*} payload
+ * @returns {payload is any[]}
+ */
+export declare function isFullArray(payload: any): payload is any[];
+/**
+ * Returns whether the payload is a an empty array
+ *
+ * @param {*} payload
+ * @returns {payload is []}
+ */
+export declare function isEmptyArray(payload: any): payload is [];
+/**
+ * Returns whether the payload is a string
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+export declare function isString(payload: any): payload is string;
+/**
+ * Returns whether the payload is a string, BUT returns false for ''
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+export declare function isFullString(payload: any): payload is string;
+/**
+ * Returns whether the payload is ''
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+export declare function isEmptyString(payload: any): payload is string;
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export declare function isNumber(payload: any): payload is number;
+/**
+ * Returns whether the payload is a positive number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export declare function isPositiveNumber(payload: any): payload is number;
+/**
+ * Returns whether the payload is a negative number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export declare function isNegativeNumber(payload: any): payload is number;
+/**
+ * Returns whether the payload is a boolean
+ *
+ * @param {*} payload
+ * @returns {payload is boolean}
+ */
+export declare function isBoolean(payload: any): payload is boolean;
+/**
+ * Returns whether the payload is a regular expression (RegExp)
+ *
+ * @param {*} payload
+ * @returns {payload is RegExp}
+ */
+export declare function isRegExp(payload: any): payload is RegExp;
+/**
+ * Returns whether the payload is a Map
+ *
+ * @param {*} payload
+ * @returns {payload is Map<any, any>}
+ */
+export declare function isMap(payload: any): payload is Map<any, any>;
+/**
+ * Returns whether the payload is a WeakMap
+ *
+ * @param {*} payload
+ * @returns {payload is WeakMap<any, any>}
+ */
+export declare function isWeakMap(payload: any): payload is WeakMap<any, any>;
+/**
+ * Returns whether the payload is a Set
+ *
+ * @param {*} payload
+ * @returns {payload is Set<any>}
+ */
+export declare function isSet(payload: any): payload is Set<any>;
+/**
+ * Returns whether the payload is a WeakSet
+ *
+ * @param {*} payload
+ * @returns {payload is WeakSet<any>}
+ */
+export declare function isWeakSet(payload: any): payload is WeakSet<any>;
+/**
+ * Returns whether the payload is a Symbol
+ *
+ * @param {*} payload
+ * @returns {payload is symbol}
+ */
+export declare function isSymbol(payload: any): payload is symbol;
+/**
+ * Returns whether the payload is a Date, and that the date is valid
+ *
+ * @param {*} payload
+ * @returns {payload is Date}
+ */
+export declare function isDate(payload: any): payload is Date;
+/**
+ * Returns whether the payload is a Blob
+ *
+ * @param {*} payload
+ * @returns {payload is Blob}
+ */
+export declare function isBlob(payload: any): payload is Blob;
+/**
+ * Returns whether the payload is a File
+ *
+ * @param {*} payload
+ * @returns {payload is File}
+ */
+export declare function isFile(payload: any): payload is File;
+/**
+ * Returns whether the payload is a Promise
+ *
+ * @param {*} payload
+ * @returns {payload is Promise<any>}
+ */
+export declare function isPromise(payload: any): payload is Promise<any>;
+/**
+ * Returns whether the payload is an Error
+ *
+ * @param {*} payload
+ * @returns {payload is Error}
+ */
+export declare function isError(payload: any): payload is Error;
+/**
+ * Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`)
+ *
+ * @param {*} payload
+ * @returns {payload is typeof NaN}
+ */
+export declare function isNaNValue(payload: any): payload is typeof NaN;
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
+ *
+ * @param {*} payload
+ * @returns {(payload is boolean | null | undefined | number | string | symbol)}
+ */
+export declare function isPrimitive(payload: any): payload is boolean | null | undefined | number | string | symbol;
+/**
+ * Returns true whether the payload is null or undefined
+ *
+ * @param {*} payload
+ * @returns {(payload is null | undefined)}
+ */
+export declare const isNullOrUndefined: TypeGuard<any, null | undefined>;
+export declare function isOneOf<A, B extends A, C extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>): TypeGuard<A, B | C>;
+export declare function isOneOf<A, B extends A, C extends A, D extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>): TypeGuard<A, B | C | D>;
+export declare function isOneOf<A, B extends A, C extends A, D extends A, E extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>, d: TypeGuard<A, E>): TypeGuard<A, B | C | D | E>;
+export declare function isOneOf<A, B extends A, C extends A, D extends A, E extends A, F extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>, d: TypeGuard<A, E>, e: TypeGuard<A, F>): TypeGuard<A, B | C | D | E | F>;
+/**
+ * Does a generic check to check that the given payload is of a given type.
+ * In cases like Number, it will return true for NaN as NaN is a Number (thanks javascript!);
+ * It will, however, differentiate between object and null
+ *
+ * @template T
+ * @param {*} payload
+ * @param {T} type
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ * @returns {payload is T}
+ */
+export declare function isType<T extends AnyFunction | AnyClass>(payload: any, type: T): payload is T;
+export {};