@bemedev/types/lib/types/arrays.d.ts

Type definitions for Bemedev projects

import type { AnyArray, ExcludeArray, ExtractArray, IndexesOfArray, ReduceDeepArray, ReverseArray, RuA, TupleOf } from './arrays.types';
import type { UnionToTuple } from './commons.types';
export declare const arrays: import("../utils.js").FnBasic<(<T extends AnyArray>(..._: T) => T[number][]), {
    readonly low: <T>(..._: T[]) => T[];
    readonly is: <T>(_?: T) => T extends unknown[] ? true : false;
    readonly indexes: import("../utils.js").FnBasic<(<const T extends RuA>(..._: T) => UnionToTuple<IndexesOfArray<T>>), {
        readonly union: <const T extends RuA>(..._: T) => IndexesOfArray<T>;
    }>;
    readonly lengthOf: <const T extends RuA>(_?: T) => T["length"];
    readonly tupleOf: import("../utils.js").FnBasic<(<const T extends RuA>(..._: T) => T), {
        readonly number: import("../utils.js").FnBasic<(<const T, N extends number>(_?: T, __?: N) => TupleOf<T, N>), {
            readonly is: <const U, N extends number>(_?: U, __?: N) => <T>(_?: T) => T extends TupleOf<U, N> ? true : false;
        }>;
        readonly is: <const T>(_?: T) => T extends RuA ? true : false;
    }>;
    readonly reduce: import("../utils.js").FnBasic<(<T>(_: T | readonly T[] | T[]) => T), {
        readonly deep: <T>(_?: T) => ReduceDeepArray<T>;
    }>;
    readonly reverse: <T extends RuA>(..._: T) => ReverseArray<T>;
    readonly toArray: <T>(_?: T) => AnyArray<T>;
    readonly freeze: <const T extends RuA>(..._: T) => Readonly<T>;
    readonly extract: <const T extends AnyArray, const U extends T[number][]>(_?: T, ...__: U) => ExtractArray<T, U[number]>;
    readonly exclude: <const T extends AnyArray, const U extends T[number][]>(_?: T, ...__: U) => ExcludeArray<T, U[number]>;
    readonly forceCast: (_?: unknown) => unknown[];
    readonly dynamic: <T extends unknown[]>(_?: T) => T;
    readonly type: unknown[];
}>;
//# sourceMappingURL=arrays.d.ts.map