if (typeof variable === 'object' && variable !== null && !Array.isArray(variable) && Object.keys(variable)?.length) {
}

if (is.object.not.empty(variable)) {
}

$method = 'ANY_METHOD_NAME';

is[$method]();
is[$method][$method]();
is[$method].or[$method]();
is[$method].not[$method]();

$model = 'ANY_MODEL_WICH_DECLARE_IN_PACKAGE_BY_DECORATOR'; // Decorator: @RegisterInIs()

is[$model]();
is[$model][$model]();
is[$model].or[$model]();
is[$model].not[$model]();

// And yes, you can mix:

is[$cmd][$model]();
is[$model].or[$cmd]();
is[$cmd].not[$model]();

import {IsConfig} from './index';

is.array([]); // true

is.bigInt(1n); // true

is.boolean(false); // true

is.compare({a: 1}, {a: 1}); // true
is.compare({a: 1}, {}); // false
is.compare({}, {a: 1}); // false
is.compare({}, {}); // true

is.Date(new Date()); // true

is.empty(''); // true
is.empty(' '); // true
is.empty(new Map()); // true
is.empty({}); // true
is.empty([]); // true

is.Error(new Error()); // true

is.EvalError(new EvalError()); // true

is.false(false); // true

is.DataView(new DataView(new ArrayBuffer(16), 0)); // true

is.falsy(''); // true

// This method will check if the argument is equal to the base type: Function
is.Function(() => {
}); // true

// This method checks not only if the argument is a function, but also if the argument is an asynchronous function or a generative
is.function(() => {
}); // true

is.instanceof(new Boolean(false), Boolean); // true

is.Map(new Map()); // true

is.null(null); // true

is.number(0); // true

is.object({}); // true

is.ReferenceError(new ReferenceError()); // true

is.RegExp(new RegExp()); // true

is.Set(new Set()); // true

is.string(''); // true

is.symbol(Symbol()); // true

is.SyntaxError(new SyntaxError()); // true

is.true(true); // true

is.truthy(1); // true

is.TypeError(new TypeError()); // true

is.undefined(undefined); // true

is.URIError(new URIError()); // true

is.WeakMap(new WeakMap()); // true

is.WeakSet(new WeakSet()); // true

is.len_5('words') // true
is.len_4('words') // false
is.len_gt_4('words') // true
is.len_lt_5('words') // false
is.len_lte_5('words') // true
is.len_gte_5('words') // true
is.len_gt_4_lt_6('words') // true
is.len_gte_5_lt_6('words') // true
is.len_gt_4_lte_5('words') // true

// You can also configure global package settings
IsConfig.error.enabled = false; // In this case, all console.error will be disabled, they are enabled by default.

// If you need to change the regex say for macAddress, here is an example:
IsConfig.regex.macAddress = /[Your regex]/;

// If you don't want the package to fight in the global context, then do it like this:
IsConfig.useGlobalContext = false;

is.array.empty([]); // true

is.bigInt.or.number(-1); // true

is.boolean.or.truthy('false'); // true

is.false.or.falsy(''); // true

is.null.or.undefined(null); // true

is.object.or.Function({}); // true
is.object.or.function({}); // true

is.string.or.true.or.symbol(true); // true

is.object.not.empty({ a: 1 }); // true

is.not.object({}); // false

is.not.number(1n); // true

@RegisterInIs({
  className: 'person', // You can customize the model name, i.e.: is.person((new Person())) // true
})
class PersonModel {}

@RegisterInIs({
  className: 'woman',
})
class WomanModel extends PersonModel {}

@RegisterInIs({
  className: 'man',
})
class ManModel extends PersonModel {}

@RegisterInIs()
class AddressModel {}

const person = new PersonModel();
const man = new ManModel();
const woman = new WomanModel();
const address = new AddressModel();

is.person(person); // true

is.person(man); // true

is.person(woman); // true

is.person(address); // false

is.man(person); // false

is.woman(person); // false

is.AddressModel(address); // true

is.woman.or.man(woman); // true

is.not.woman(man); // true

is.not.man(man); // false

// Good Example: Cart

@RegisterInIs()
class Cart {
  public size: number = 0;
}

const cart: Cart = new Cart();
is.Cart.empty(cart); // true
cart.size = 1;
is.Cart.empty(cart); // false

// Bad Example: Cart

@RegisterInIs()
class CartTwo {
  public total: number = 0;
}

const cartTwo: CartTwo = new CartTwo();
is.CartTwo.empty(cartTwo); // false
cartTwo.size = 1;
is.CartTwo.empty(cartTwo); // false

@RegisterInIs({
  customMethod: 'customNameOfMethod',
})
class PostModel {
  public static customNameOfMethod(argument: unknown): argument is PostModel {
    return `Hello ${argument}`;
  }
}

is.PostModel('world'); // Returns: Hello world

const onlyNumbers: number[] = [0, 1, '', 'test'];
console.log(onlyNumbers.filter(is.number)); // [0, 1]

const onlyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyStringList.filter(is.string)); // ['', 'test']

const onlyNotEmptyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyNotEmptyStringList.filter(is.string.not.empty)); // ['test']

const onlyNumbers: number[] = [0, 1, '', 'test'];
console.log(onlyNumbers.some(is.string.or.object)); // true

const onlyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyStringList.some(is.not.symbol)); // false

const onlyNotEmptyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyNotEmptyStringList.some(is.string.empty)); // true

const onlyNumbers: number[] = [0, 1, '', 'test'];
console.log(onlyNumbers.every(is.string.or.number)); // true

const onlyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyStringList.every(is.string)); // false

const onlyNotEmptyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyNotEmptyStringList.every(is.not.object)); // true

const stream$: Stream<boolean> = new Stream<boolean>();

stream$.pipe(filter(is.boolean)).subscribe(console.log); // true, false

stream$.next([false]); // Bad[README.ua.md](README.ua.md)
stream$.next(0); // Bad

stream$.next(true); // Good

stream$.next({ false: false }); // Bad

stream$.next(false); // Good

stream$.next(1); // Bad
stream$.next('false'); // Bad