function arguments(it: unknown): it is IArguments;

import { isArguments } from "jsr:@nick/is/arguments";

function foo() {
  console.log(isArguments(arguments)); // true
  console.log(isArguments([1, 2, 3])); // false
}

function array<T>(a: unknown, test?: Predicate<T>): a is T[];

import { isArray, isNumber, isString } from "jsr:@nick/is";
import { expectType } from "jsr:@nick/is/type/expect";

const arr: unknown[] = ["a", "b", "c"];

if (isArray(arr, isString)) {
  console.log(arr, "is an array of strings");
  //           ^? const arr: string[]
  expectType<string[]>(arr);
} else if (isArray(arr, isNumber)) {
  console.log(arr, "is an array of numbers");
  //           ^? const arr: number[]
  expectType<number[]>(arr);
} else {
  console.log(arr, "is not an array of strings or numbers");
  //           ^? const arr: unknown[]
  expectType<unknown[]>(arr);
}

function arrayBuffer(it: unknown): it is ArrayBuffer;

import { isArrayBuffer } from "jsr:@nick/is/array-buffer";

const buffer = new ArrayBuffer(8);
const shared = new SharedArrayBuffer(8);
const array = new Uint8Array(buffer);

isArrayBuffer(buffer); // true
isArrayBuffer(shared); // false
isArrayBuffer(array); // false
isArrayBuffer(array.buffer); // true

function arrayBufferLike(it: unknown): it is ArrayBufferLike;

import { isArrayBufferLike } from "jsr:@nick/is/any-array-buffer";

const buffer = new ArrayBuffer(8);
const shared = new SharedArrayBuffer(8);
const array = new Uint8Array(buffer);

isArrayBufferLike(buffer); // true
isArrayBufferLike(shared); // true
isArrayBufferLike(array); // false
isArrayBufferLike(array.buffer); // true

function arrayBufferView(it: unknown): it is ArrayBufferView;

import { isArrayBufferView } from "jsr:@nick/is/array-buffer-view";

const buffer = new ArrayBuffer(8);
const view = new DataView(buffer);
const array = new Uint8Array(buffer);

isArrayBufferView(buffer); // false
isArrayBufferView(view); // true
isArrayBufferView(array); // true

function arrayIterator<T>(it: unknown): it is ArrayIterator<T>;

import { isArrayIterator } from "jsr:@nick/is/array-iterator";

const array = ["foo", "bar", "foo"];
const iter = array[Symbol.iterator]();
console.log(isArrayIterator(iterator)); // true
console.log(isArrayIterator(array)); // false

function arrayLike<T>(it: unknown): it is ArrayLike<T>;

import { isArrayLike } from "jsr:@nick/is/array-like";

isArrayLike([]); // true
isArrayLike("abc"); // true
isArrayLike({ length: 0 }); // true
isArrayLike({ length: 1, 0: "a" }); // true
isArrayLike({ length: Infinity }); // false
isArrayLike({ length: -1 }); // false

function arrayLikeObject<T>(it: unknown): it is ArrayLikeObject<T>;

import { isArrayLikeObject } from "jsr:@nick/is/array-like";

isArrayLikeObject([]); // true
isArrayLikeObject({ length: 0 }); // true
isArrayLikeObject({ length: 1, 0: "a" }); // true

// strings are not considered ArrayLike objects
isArrayLikeObject("abc"); // false

// length must be a finite unsigned integer
isArrayLikeObject({ length: Infinity }); // false

// length must be non-negative
isArrayLikeObject({ length: -1 }); // false

// length cannot be a non-number or NaN
isArrayLikeObject({ length: "a" }); // false
isArrayLikeObject({ length: NaN }); // false

// functions are not considered ArrayLike objects, despite meeting the
// requirements for the 'length' property. this is because they are not
// indexed collections like an array or string.
isArrayLikeObject(() => {});

function asyncDisposable(it: unknown): it is AsyncDisposable;

import { isAsyncDisposable } from "@nick/is/async_disposable";

const disposable = {
  [Symbol.dispose]() {
    return;
  },
};

const asyncDisposable = {
  async [Symbol.asyncDispose]() {
    await Promise.resolve();
  },
};

isAsyncDisposable(disposable); // false
isAsyncDisposable(asyncDisposable); // true

function asyncFunction<T = any>(it: unknown): it is AsyncFunction<T>;

function asyncGenerator<T = unknown, TReturn = any, TNext = unknown>(
  it: unknown,
): it is AsyncGenerator<T, TReturn, TNext>;

import { isAsyncGenerator } from "jsr:@nick/is/async-generator";

async function* genFn() {
  yield await Promise.resolve(1);
}
const gen = genFn();

console.log(isAsyncGenerator(gen)); // true
console.log(isAsyncGenerator(genFn)); // false

function asyncGeneratorFunction(it: unknown): it is AsyncGeneratorFunction;

import {
  isAsyncGeneratorFunction,
} from "jsr:@nick/is/async-generator-function";

const genFnAsync = async function* () {
  yield 1;
};
isAsyncGeneratorFunction(genFnAsync); // true

const genObjAsync = genFnAsync();
isAsyncGeneratorFunction(genObjAsync); // false

const genFn = function* () {
  yield 1;
};
isAsyncGeneratorFunction(genFn); // false

const genObj = genFn();
isAsyncGeneratorFunction(genObj); // false

function asyncIterable<T>(it: unknown): it is AsyncIterable<T>;

import { isAsyncIterable } from "jsr:@nick/is/async-iterable";

const iter = (async function* () {
  yield 1;
})();
console.log(isAsyncIterable(iter)); // true

function asyncIterableIterator<T>(it: unknown): it is AsyncIterableIterator<T>;

import isAsyncIterableIterator from "jsr:@nick/is/async-iterable-iterator";

const iter = (async function* () {
  yield 1;
})();
console.log(isAsyncIterableIterator(iter)); // true
console.log(isAsyncIterableIterator(iter[Symbol.asyncIterator]())); // true

function asyncIterableObject<T>(it: unknown): it is AsyncIterableObject<T>;

import { isAsyncIterableObject } from "jsr:@nick/is/async-iterable-object";

// synchronous iterables will not pass
console.log(isAsyncIterableObject([1, 2])); // false
console.log(isAsyncIterableObject(new Map())); // false
console.log(isAsyncIterableObject(new Set())); // false

// non-object iterables will not pass
console.log(isAsyncIterableObject("foo")); // false

// only asynchronous iterable objects will pass
const iter = {
  async *[Symbol.asyncIterator]() {
    yield await Promise.resolve(1);
  },
};
console.log(isAsyncIterableObject(iter)); // true

import { isAsyncIterableObject } from "jsr:@nick/is/async-iterable-object";

const kv = await Deno.openKv();
console.log(isAsyncIterableObject(kv)); // false

const iter = kv.list({ prefix: [] });
console.log(isAsyncIterableObject(iter)); // true

kv.close();

function asyncIterator<T>(it: unknown): it is AsyncIterator<T>;

import { isAsyncIterator } from "jsr:@nick/is/async-iterator";

const iter = (async function* () {
  yield 1;
})();
console.log(isAsyncIterator(iter)); // true
console.log(isAsyncIterator(iter[Symbol.asyncIterator]())); // true

function bigint(it: unknown): it is bigint;

import { isBigInt } from "jsr:@nick/is/bigint";

const x: unknown = 123n;
if (isBigInt(x)) {
  console.log(x + 1n);
  //          ^? const x: bigint
}

function bigInt(it: unknown): it is bigint;

import { isBigInt } from "jsr:@nick/is/bigint";

const x: unknown = 123n;
if (isBigInt(x)) {
  console.log(x + 1n);
  //          ^? const x: bigint
}

function bigInt64Array(it: unknown): it is BigInt64Array;

import { isBigInt64Array } from "jsr:@nick/is/bigint64array";

const arr = new BigInt64Array(8);
isBigInt64Array(arr); // true
isBigInt64Array(arr.buffer); // false

function bigintObject(it: unknown): it is BigInt;

import { isBigIntObject } from "jsr:@nick/is/bigint-object";

isBigIntObject(Object(BigInt("2"))); // true

isBigIntObject(BigInt("2")); // false
isBigIntObject(2n); // false

function bigIntObject(it: unknown): it is BigInt;

import { isBigIntObject } from "jsr:@nick/is/bigint-object";

isBigIntObject(Object(BigInt("2"))); // true

isBigIntObject(BigInt("2")); // false
isBigIntObject(2n); // false

function bigUint64Array(it: unknown): it is BigUint64Array;

import { isBigUint64Array } from "jsr:@nick/is/biguint64array";

const arr = new BigUint64Array(8);
isBigUint64Array(arr); // true
isBigUint64Array(arr.buffer); // false

function boolean(it: unknown): it is boolean;

import { isBoolean } from "jsr:@nick/is/boolean";
isBoolean("true"); // false
isBoolean(true); // true

function booleanObject(it: unknown): it is Boolean;

import { isBooleanObject } from "jsr:@nick/is/boolean-object";

isBooleanObject(Object(true)); // true
isBooleanObject(new Boolean(true)); // true

isBooleanObject(Boolean(true)); // false
isBooleanObject(true); // false

function both<L, R>(
  left: (it: any, ...args: any[]) => it is L,
  right: (it: any, ...args: any[]) => it is R,
): (it: unknown) => it is L & R;

import { is, isBoth } from "@nick/is";

// creating a custom type guard by hand
const isEmpty = <T>(
  it: T,
): it is T & { readonly length: 0 } => (
  "length" in Object(it) && Object(it).length === 0
);

// composing a custom type guard with `isBoth`
const isEmptyString = isBoth(is.string, isEmpty);
//    ^? const isEmptyString: (it: unknown) => it is string & { readonly length: 0 }

// using the custom type guard
isEmptyString(""); // true
isEmptyString("foo"); // false
isEmptyString([]); // false

function boxedPrimitive<T extends BoxedPrimitive>(
  it: T | {} | null | undefined,
): it is T;

import { isBoxedPrimitive } from "jsr:@nick/is/boxed-primitive";

isBoxedPrimitive(new String("abc")); // true
isBoxedPrimitive(new Number(42)); // true
isBoxedPrimitive(new Boolean(true)); // true

isBoxedPrimitive("abc"); // false
isBoxedPrimitive(42); // false
isBoxedPrimitive(true); // false

function boxedPrimitive(it: unknown): it is BoxedPrimitive;

function boxedPrimitive(it: unknown): it is BoxedPrimitive;

function bufferSource(it: unknown): it is BufferSource;

import { isBufferSource } from "jsr:@nick/is/buffer-source";

const buffer = new ArrayBuffer(8);
const view = new DataView(buffer);
const array = new Uint8Array(buffer);

isBufferSource(buffer); // true
isBufferSource(view); // true
isBufferSource(array); // true

function class<T, A extends readonly unknown[] = readonly any[], P extends  object | null = Is<T,  object | null>>(it: unknown): it is Class<T, A, P>;

import { isClass } from "jsr:@nick/is/class";

class Foo {}
console.log(isClass(Foo)); // true

const Bar = function () {
  this.foo = "bar";
  return this;
};
console.log(isClass(Bar)); // false

const Baz = () => {};
console.log(isClass(Baz)); // false

function closer(it: unknown): it is Closer;

import { isCloser } from "jsr:@nick/is/closer";

const file = await Deno.open("file.txt");
isCloser(file); // true

const socket = new WebSocket("ws://example.com");
isCloser(socket); // true

function constructor<T>(it: unknown): it is Constructor<T>;

import { isConstructor } from "jsr:@nick/is/constructor";

class Foo {}
console.log(isConstructor(Foo)); // true
console.log(isConstructor(Foo.prototype.constructor)); // true
console.log(isConstructor(class {})); // true
console.log(isConstructor(function () {})); // true

console.log(isConstructor({})); // false
console.log(isConstructor(null)); // false
console.log(isConstructor(Foo.prototype)); // false
console.log(isConstructor(() => new Foo())); // false

function dataView(it: unknown): it is DataView;

import { isDataView } from "jsr:@nick/is/data-view";

const buffer = new ArrayBuffer(8);
const view = new DataView(buffer);
console.log(isDataView(view)); // true
console.log(isDataView(buffer)); // false

function date(it: unknown): it is Date;

import { isDate } from "jsr:@nick/is/date";

isDate(new Date()); // true
isDate(new Date(0)); // true
isDate(new Date("2021-01-01")); // true

function dateString(it: unknown): it is DateString;

import { isDateString } from "@nick/is/date_string";

console.assert(isDateString("4/20/2024"), "it works!");
console.assert(isDateString("2024-04-20"), "it works!");
console.assert(isDateString("02.32.2025"), "wtf lol");

function defined<T>(it: T | undefined): it is T;

import { isDefined } from "jsr:@nick/is/defined";

isDefined(null); // true
isDefined(undefined); // false
isDefined(0); // true
isDefined(void 0); // false
isDefined(""); // true

import { isDefined } from "jsr:@nick/is/defined";

let value: number | undefined;
if (isDefined(value)) {
  value += 1;
  // ^? let value: number
} else {
  value;
  // ^? let value: undefined
  value = 0;
  // ^? let value: number | undefined
}

function disposable(it: unknown): it is Disposable;

import { isDisposable } from "@nick/is/disposable";

const disposable = {
  [Symbol.dispose]() {
    return;
  },
};

const asyncDisposable = {
  async [Symbol.asyncDispose]() {
    await Promise.resolve();
  },
};

isDisposable(disposable); // true
isDisposable(asyncDisposable); // false

function either<L, R>(
  left: (it: any, ...args: any[]) => it is L,
  right: (it: any, ...args: any[]) => it is R,
): (it: unknown) => it is L | R;

import { isEither, isString, isSymbol } from "@nick/is";

// creating a custom type guard that checks for strings or symbols
const isStringOrSymbol = isEither(isString, isSymbol);
//    ^? const isStringOrSymbol: (it: unknown) => it is string | symbol

// using the custom type guard
isStringOrSymbol("foo"); // true
isStringOrSymbol(Symbol.iterator); // true
isStringOrSymbol(123); // false

function empty(it: string): it is "";

import { isEmpty } from "@nick/is/empty";

isEmpty(""); // true
isEmpty("a"); // false

function empty(it: readonly unknown[]): it is readonly [];

import { isEmpty } from "@nick/is/empty";

isEmpty([]); // true
isEmpty([1]); // false

function empty<U extends ArrayLike<any>>(it: U): it is U & {
  readonly length: 0;
};

import { isEmpty } from "@nick/is/empty";

isEmpty([]); // true
isEmpty([1]); // false

function empty(it: unknown): it is {
  [K in undefined]: never;
};

import { isEmpty } from "@nick/is/empty";

isEmpty({}); // true
isEmpty({ a: 1 }); // false

function empty(it: unknown): it is
  | ""
  | {
    length: 0;
  }
  | {
    [K in undefined]: never;
  };

import { isEmpty } from "@nick/is/empty";

isEmpty({}); // true
isEmpty([]); // true
isEmpty(""); // true

isEmpty({ a: 1 }); // false
isEmpty([1]); // false
isEmpty("a"); // false

function enum<T extends EnumLike>(it: T | unknowns): it is Enum<T>;

import { isEnum } from "@nick/is/enum";

enum Foo {
  Bar, // 0
  Baz, // 1
  Qux, // 2
  // implicit reverse mapping:
  // 0: "Bar", 1: "Baz", 2: "Qux",
}

isEnum(Foo); // true

const obj = { Bar: 0, Baz: 1, Qux: 2 };
isEnum(obj); // false

function enum<T extends EnumLike = EnumLike>(it: unknown): it is Enum<T>;

function enum(it: unknown): it is Enum;

function error(it: unknown): it is Error;

import { isError } from "jsr:@nick/is/error";

const err = new Error("Something went wrong");
console.log(isError(err)); // true
console.log(isError(err.message)); // false

function even<T extends Numeric>(it: T): IsEven<T>;

import { isEven } from "@nick/is/even";

isEven(0); // true
isEven(1); // false
isEven(2n); // true
isEven(3n); // false

function even(it: number | `${number}`): it is Even<number>;

import { isEven } from "@nick/is/even";

isEven(0); // true
isEven(1); // false
isEven(2n); // true
isEven(3n); // false

function even(it: bigint | `${bigint}`): it is Even<bigint>;

import { isEven } from "@nick/is/even";

isEven(0); // true
isEven(1); // false
isEven(2n); // true
isEven(3n); // false

function even(it: unknown): it is Even;

import { isEven } from "@nick/is/even";

isEven(0); // true
isEven(1); // false
isEven(2n); // true
isEven(3n); // false

function extendedSetLike<T>(it: unknown): it is ExtendedSetLike<T>;

function falsy(it: unknown): it is Falsy;

import { isFalsy } from "@nick/is/falsy";

isFalsy(null); // true
isFalsy(undefined); // true
isFalsy(0); // true
isFalsy(""); // true
isFalsy(false); // true
isFalsy([]); // false

function finite<N = number>(it: N): it is Finite<N>;

import { isFinite } from "jsr:@nick/is/integer";

console.log(isFinite(0)); // true
console.log(isFinite(1)); // true
console.log(isFinite(-1)); // true
console.log(isFinite(1.5)); // true
console.log(isFinite(NaN)); // false
console.log(isFinite(Infinity)); // false

function finite(it: unknown): it is Finite;

import { isFinite } from "jsr:@nick/is/integer";

console.log(isFinite(0)); // true
console.log(isFinite(1)); // true
console.log(isFinite(-1)); // true
console.log(isFinite(1.5)); // true
console.log(isFinite(NaN)); // false
console.log(isFinite(Infinity)); // false

function finiteInteger<N = number>(it: N): it is FiniteInteger<N>;

import { isFiniteInteger } from "jsr:@nick/is/integer";

console.log(isFiniteInteger(0)); // true
console.log(isFiniteInteger(1)); // true
console.log(isFiniteInteger(-1)); // true
console.log(isFiniteInteger(1.5)); // false
console.log(isFiniteInteger(NaN)); // false
console.log(isFiniteInteger(Infinity)); // false

function finiteInteger(it: unknown): it is FiniteInteger;

import { isFiniteInteger } from "jsr:@nick/is/integer";

console.log(isFiniteInteger(0)); // true
console.log(isFiniteInteger(1)); // true
console.log(isFiniteInteger(-1)); // true
console.log(isFiniteInteger(1.5)); // false
console.log(isFiniteInteger(NaN)); // false
console.log(isFiniteInteger(Infinity)); // false

function float<N = number>(it: N): it is Float<N>;

import { isFloat } from "@nick/is/float";

isFloat(1); // false
isFloat(1.0); // false
isFloat(1.1); // true
isFloat(1.00001e1); // true

function float(it: unknown): it is Float;

import { isFloat } from "@nick/is/float";

isFloat(0); // true
isFloat(1); // false
isFloat(1.0); // false
isFloat(1.1); // true
isFloat(1.00001e1); // true

function float16<N = number>(it: N): it is Float16<N>;

import { isFloat16 } from "@nick/is/float16";

isFloat16(1); // true
isFloat16(1.5); // true
isFloat16(3.140625); // true
isFloat16(NaN); // false
isFloat16(1.1); // false
isFloat16(Math.PI); // false
isFloat16(Infinity); // false

function float16(it: unknown): it is Float16;

function float16(it: any): it is Float16;

function float16Array(it: unknown): it is Float16Array;

import { isFloat16Array } from "jsr:@nick/is/float16array";

const arr = new Float16Array(8);
isFloat16Array(arr); // true
isFloat16Array(arr.buffer); // false

function float32<N = number>(it: N): it is Float32<N>;

import { isFloat32 } from "@nick/is/float32";

isFloat32(1); // false
isFloat32(1.0); // false
isFloat32(1.1); // true
isFloat32(1.00001e1); // true

function float32(it: unknown): it is Float32;

import { isFloat32 } from "@nick/is/float32";

isFloat32(1); // false
isFloat32(1.0); // false
isFloat32(1.1); // true
isFloat32(1.00001e1); // true

function float32Array(it: unknown): it is Float32Array;

import { isFloat32Array } from "jsr:@nick/is/float32array";

const arr = new Float32Array(8);
isFloat32Array(arr); // true
isFloat32Array(arr.buffer); // false

function float64<N = number>(it: N): it is Float64<N>;

import { isFloat64 } from "jsr:@nick/is/float64";

console.log(isFloat64(1.5)); // true
console.log(isFloat64(0)); // false
console.log(isFloat64(1)); // false
console.log(isFloat64(-1)); // false
console.log(isFloat64(NaN)); // false
console.log(isFloat64(Infinity)); // false

function float64(it: unknown): it is Float64;

import { isFloat64 } from "jsr:@nick/is/float64";

console.log(isFloat64(1.5)); // true
console.log(isFloat64(0)); // false
console.log(isFloat64(1)); // false
console.log(isFloat64(-1)); // false
console.log(isFloat64(NaN)); // false
console.log(isFloat64(Infinity)); // false

function float64Array(it: unknown): it is Float64Array;

import { isFloat64Array } from "jsr:@nick/is/float64array";

const arr = new Float64Array(8);
isFloat64Array(arr); // true
isFloat64Array(arr.buffer); // false

function function<T extends FunctionOrConstructor>(it:  T | unknowns): it is FunctionOrConstructor<any, any, any> extends T ? Function : T;

import { isFunction } from "jsr:@nick/is/function";

console.log(isFunction(() => {})); // true
console.log(isFunction(function () {})); // true
console.log(isFunction(class {})); // true
console.log(isFunction(new Function())); // true
console.log(isFunction({})); // false
console.log(isFunction(1)); // false

function function<T = any, A extends readonly any[] = any[]>(it:  Fn<T, A> | unknowns): it is Fn<T, A>;

function function<T = any, A extends readonly any[] = any[], R = any>(it:  ThisFn<T, A, R> | unknowns): it is ThisFn<T, A, R>;

function function(it: unknown): it is Function;