/*!
 * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
 * Licensed under the MIT License.
 */
/**
 * Represents a node in a doubly linked list.
 * @internal
 */
export interface ListNode<T> {
    /**
     * The list this node belongs to, or undefined if not attached.
     */
    readonly list: DoublyLinkedList<T> | undefined;
    /**
     * The data value stored in this node.
     */
    readonly data: T;
    /**
     * The next node in the list, or undefined if this is the last node.
     */
    readonly next: ListNode<T> | undefined;
    /**
     * The previous node in the list, or undefined if this is the first node.
     */
    readonly prev: ListNode<T> | undefined;
    /**
     * Removes this node from its list.
     * @returns The removed node, or undefined if not in a list.
     */
    remove(): ListNode<T> | undefined;
}
/**
 * Represents a range of nodes in a doubly linked list.
 * @internal
 */
export interface ListNodeRange<T> {
    /**
     * The first node in the range.
     */
    first: ListNode<T>;
    /**
     * The last node in the range.
     */
    last: ListNode<T>;
}
/**
 * A doubly linked list implementation with array-like methods and node access.
 * @typeParam T - The type of data stored in the list nodes.
 * @internal
 */
export declare class DoublyLinkedList<T> implements Iterable<ListNode<T>>, // try to match array signature and semantics where possible
Pick<ListNode<T>[], "pop" | "shift" | "length" | "includes"> {
    /**
     * Creates a new doubly linked list optionally initialized with values.
     * @param values - Optional iterable of values to populate the list.
     */
    constructor(values?: Iterable<T>);
    /**
     * Finds the first node matching the predicate.
     * @param predicate - Function to test each node.
     * @returns The first matching node, or undefined if none found.
     */
    find(predicate: (value: ListNode<T>, obj: DoublyLinkedList<T>) => boolean): ListNode<T> | undefined;
    /**
     * Returns an iterable that maps each node to a new value.
     * @param callbackfn - Function to produce a new value for each node.
     */
    map<U>(callbackfn: (value: ListNode<T>) => U): Iterable<U>;
    /**
     * Inserts items after the specified node.
     * @param preceding - The node to insert after.
     * @param items - Items to insert.
     * @returns The range of newly inserted nodes.
     */
    insertAfter(preceding: ListNode<T>, ...items: T[]): ListNodeRange<T>;
    /**
     * Removes and returns the last node in the list.
     * @returns The removed node, or undefined if the list is empty.
     */
    pop(): ListNode<T> | undefined;
    /**
     * Appends items to the end of the list.
     * @param items - Items to append.
     * @returns The range of newly inserted nodes.
     */
    push(...items: T[]): ListNodeRange<T>;
    /**
     * Removes and returns the first node in the list.
     * @returns The removed node, or undefined if the list is empty.
     */
    shift(): ListNode<T> | undefined;
    /**
     * Inserts items at the start of the list.
     * @param items - Items to insert.
     * @returns The range of newly inserted nodes.
     */
    unshift(...items: T[]): ListNodeRange<T>;
    /**
     * Removes nodes starting at `start` until `end` or `count` is reached.
     * @param start - The node to start removing from.
     * @param countOrEnd - The number of nodes to remove or the end node.
     * @returns A new list containing the removed nodes.
     */
    splice(start: ListNode<T>, countOrEnd?: ListNode<T> | number): DoublyLinkedList<T>;
    /**
     * Checks if the node is in this list.
     * @param node - The node to check.
     * @returns True if the node is in the list.
     */
    includes(node: ListNode<T> | undefined): node is ListNode<T>;
    private _includes;
    private _remove;
    /**
     * Removes the specified node from the list.
     * @param node - The node to remove.
     * @returns The removed node, or undefined if not in the list.
     */
    remove(node: ListNode<T> | undefined): ListNode<T> | undefined;
    [Symbol.iterator](): IterableIterator<ListNode<T>>;
    private _len;
    private readonly headNode;
    /**
     * The number of nodes in the list.
     */
    get length(): number;
    /**
     * Whether the list is empty.
     */
    get empty(): boolean;
    /**
     * The first node in the list, or undefined if empty.
     */
    get first(): ListNode<T> | undefined;
    /**
     * The last node in the list, or undefined if empty.
     */
    get last(): ListNode<T> | undefined;
}
/**
 * Iterates over the nodes of a `DoublyLinkedList`, calling the provided visitor function for each node.
 * Iteration starts at the specified node (or at the head/tail if not provided) and proceeds forward or backward.
 * If the visitor returns `false`, iteration stops early.
 *
 * @typeParam T - The type of data stored in the list nodes.
 * @param list - The list to walk.
 * @param visitor - Function called for each node. If it returns `false`, iteration stops.
 * @param start - Optional node to start iteration from. If not provided, starts at the first (or last if `forward` is false) node.
 * @param forward - If `true` (default), iterates forward; if `false`, iterates backward.
 * @returns `false` if iteration was stopped early by the visitor, otherwise `true`.
 *
 * @internal
 */
export declare function walkList<T>(list: DoublyLinkedList<T>, visitor: (node: ListNode<T>) => boolean | void, start?: ListNode<T>, forward?: boolean): boolean;
/**
 * Creates a lazily evaluated iterable which returns values while the predicate returns true,
 * and stops iterating at the first value where the predicate is false.
 * @param start - the node to start the iteration from
 * @param includePredicate - determine if the current value be included in the iteration or stop if iteration
 *
 * @internal
 */
export declare function iterateListValuesWhile<T>(start: ListNode<T> | undefined, includePredicate: (n: ListNode<T>) => boolean): Iterable<T>;
//# sourceMappingURL=list.d.ts.map