@types/yallist

constructor();

constructor(list: Yallist.ForEachIterable<T>);

constructor(...items: T[]);

head: Yallist.Node<T>;

length: number;

static Node: Yallist.NodeConstructor;

tail: Yallist.Node<T>;

[Symbol.iterator]: () => Iterator<T>;

static create: {
    <T>(): Yallist<T>;
    <T>(list: Yallist.ForEachIterable<T>): Yallist<T>;
    <T>(...items: T[]): Yallist<T>;
};

forEach: <U = this>(
    callbackFn: (this: U, value: T, index: number, list: this) => void,
    thisArg?: U
) => void;

forEachReverse: <U = this>(
    callbackFn: (this: U, value: T, index: number, list: this) => void,
    thisArg?: U
) => void;

get: (n: number) => T | undefined;

getReverse: (n: number) => T | undefined;

map: <U = this, R = T>(
    callbackFn: (this: U, value: T, list: this) => R,
    thisArg?: U
) => Yallist<R>;

mapReverse: <U = this, R = T>(
    callbackFn: (this: U, value: T, list: this) => R,
    thisArg?: U
) => Yallist<R>;

pop: () => T | undefined;

push: (...items: T[]) => number;

pushNode: (node: Yallist.Node<T>) => void;

reduce: <U = T>(
    fn: (previousValue: U, currentValue: T, index: number) => U,
    initialValue?: U
) => U;

reduceReverse: <U = T>(
    fn: (previousValue: U, currentValue: T, index: number) => U,
    initialValue?: U
) => U;

removeNode: (node: Yallist.Node<T>) => void;

reverse: () => this;

shift: () => T | undefined;

slice: (from?: number, to?: number) => Yallist<T>;

sliceReverse: (from?: number, to?: number) => Yallist<T>;

splice: (start: number, deleteCount: number, ...nodes: T[]) => T[];

toArray: () => T[];

toArrayReverse: () => T[];

unshift: (...items: T[]) => number;

unshiftNode: (node: Yallist.Node<T>) => void;

forEach: (callbackFn: (item: T) => void) => void;

list?: Yallist<T> | undefined;

next: Node<T> | null;

prev: Node<T> | null;

value: T;

new <T>(value: T, prev?: Node<T>, next?: Node<T>, list?: Yallist<T>): Node<T>;

<T>(value: T, prev?: Node<T>, next?: Node<T>, list?: Yallist<T>): Node<T>;