type sel = string;
export declare const contentTypes: any;
export type DOMTYPE = Node;
export type FILTER_FN<T extends DOMTYPE> = (el: T, i: number, list: T[]) => boolean;
export type TARGET<WHICHNODE extends DOMTYPE = DOMTYPE, WHICHARRAY extends DOMTYPE = any> = DOMArray<WHICHARRAY> | WHICHNODE | WHICHNODE[] | string;
export type CONFIG = {
    document: Document;
    cssSelectAll(nodes: DOMTYPE[], selector: sel): Element[];
    cssSelectOne(nodes: DOMTYPE[], selector: sel): Element | null;
    cssIs(node: DOMTYPE, selector: sel): boolean;
};
export declare const defaultConfig: CONFIG;
export declare class DOMArray<T extends DOMTYPE = DOMTYPE> {
    protected list: T[];
    protected config: CONFIG;
    ['constructor']: typeof DOMArray;
    [index: number]: T | undefined;
    constructor(list?: T[], config?: CONFIG);
    static from<T extends DOMTYPE = DOMTYPE>(list: T[], config?: CONFIG): DOMArray<T>;
    static fromHtml(html: string, config?: CONFIG): DOMArray<Element>;
    newFromList<NEWT extends DOMTYPE>(list: NEWT[]): DOMArray<NEWT>;
    newFromHtml(html: string): DOMArray<Element>;
    newFromXml(xml: string): DOMArray<Element>;
    [Symbol.iterator](): Iterator<T>;
    concat(...args: T[]): DOMArray<T>;
    get length(): number;
    slice(start?: number, end?: number): DOMArray<T>;
    splice(start: number, deleteCount?: number): DOMArray<T>;
    get DOMArray(): true;
    get document(): Document | undefined;
    add(content: string): DOMArray<T | Element>;
    add(content: T | T[] | DOMArray<T>): DOMArray<T>;
    addClass(className: string): DOMArray<T>;
    removeClass(className: string): DOMArray<T>;
    after(...contents: AnyNodable[]): DOMArray<T>;
    append(...contents: AnyNodable[]): DOMArray<T>;
    prepend(...contents: AnyNodable[]): DOMArray<T>;
    arrayFilter(fn: (item: T, i: number, arr: T[]) => boolean): DOMArray<T>;
    arrayFind(predicate: (value: T, index: number, arr: T[]) => boolean, thisArg?: DOMArray<T>): T | undefined;
    arrayMap<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: unknown): U[];
    attr(): Record<string, string>;
    attr(name: string, value?: string | number): string | null;
    attr(attrs: Record<string, string | number | undefined>): null;
    setAttrNS(name: string, value: string | number): DOMArray<T>;
    defineNamespace(prefix: string, uri: string): DOMArray<T>;
    before(...contents: AnyNodable[]): DOMArray<T>;
    children(selector?: sel): DOMArray<Element>;
    clone({ deep }?: {
        deep?: boolean | undefined;
    }): DOMArray<T>;
    closest(target: TARGET<Element, Element> | FILTER_FN<Element>): DOMArray<Element>;
    contents(): DOMArray<Node>;
    css(): CSSStyleDeclaration;
    css(propertyName: string): string;
    css(propertyName: string, value: string): DOMArray<T>;
    forEach(callbackfn: (value: T, index: number, array: T[]) => void): void;
    each(fn: (el: T, i: number, list: T[]) => void): DOMArray<T>;
    empty(): DOMArray<T>;
    nodeAt(index?: number): Node | null;
    elementAt(index?: number): Element | null;
    eq(index: number): DOMArray<T>;
    filter(target?: sel | FILTER_FN<T>): DOMArray<T>;
    find<FOUND extends Element = Element>(selector: sel): DOMArray<FOUND>;
    find(element: T): DOMArray<T>;
    find(target: sel | T): DOMArray<Element> | DOMArray<T>;
    findFirst(selector: string): DOMArray<Element>;
    first(): DOMArray<T>;
    last(): DOMArray<T>;
    has(thing: string | Node | Node[] | DOMArray<Element> | DOMArray<Node>): DOMArray<Element>;
    html(): string;
    html(str: string): DOMArray<T>;
    xml({ delimiter }?: {
        delimiter?: string | undefined;
    }): string;
    outerHtml(delimiter?: string): string;
    index(target: ArrayLike<Node> | Node | DOMArray<Node> | ArrayLike<Element> | Element | DOMArray<Element>): number;
    is(target: TARGET<Node> | FILTER_FN<T>): boolean;
    get isTextNode(): boolean;
    get isEmpty(): boolean;
    get notEmpty(): boolean;
    map<U extends DOMTYPE>(callback: (el: T, i: number, list: DOMArray<T>) => U): DOMArray<U>;
    matches(target: string | RegExp, maybeGetText?: (a: Node, b?: number, c?: DOMArray<T>) => string): DOMArray<T>;
    /**
     *  Get the immediately following sibling of each element
     *  in the set of matched elements. If a selector is
     *  provided, it retrieves the next sibling only if it
     *  matches that selector.
     *
     * @param {string} [selector] - If specified filter for
     * sibling.
     *
     * @see {@link http://api.jquery.com/next/}
     */
    next(selector?: sel): DOMArray<Element>;
    nextSibling(): DOMArray<Node>;
    nextSiblings(selector?: sel): DOMArray<Node>;
    nextAll(selector?: sel): DOMArray<Element>;
    nextUntil(target: TARGET<Element> | FILTER_FN<Element>): DOMArray<Element>;
    not(target: TARGET<Node> | FILTER_FN<T>): DOMArray<T>;
    parent(selector?: sel): DOMArray<Element>;
    parents(selector?: sel | FILTER_FN<Element>): DOMArray<Element>;
    parentsUntil(input: DOMArray<Element> | Element | Element[] | string | ((el: Element) => boolean), filter?: sel | FILTER_FN<Element>): DOMArray<Element>;
    /**
     * Get the immediately preceding sibling of each element
     * in the set of matched elements. If a selector is
     * provided, it retrieves the previous sibling only if it
     * matches that selector.
     *
     * @param {string} [selector] - If specified filter for
     * sibling.
     *
     * @see {@link http://api.jquery.com/prev/}
     */
    prev(selector?: sel): DOMArray<Element>;
    previousSiblings(selector?: sel): DOMArray<Node>;
    previousSibling(): DOMArray<Node>;
    prevAll(selector?: sel): DOMArray<Element>;
    prevUntil(target: TARGET<Element> | FILTER_FN<Element>): DOMArray<Element>;
    query(selector: sel): DOMArray<Element>;
    queryAll(selector: sel): DOMArray<Element>;
    remove(): DOMArray<T>;
    removeAttr(name: string): DOMArray<T>;
    replaceWith(content: AnyNodable): DOMArray<T>;
    siblings(selector?: sel): DOMArray<Element>;
    sliceUntil(target: TARGET<Element> | FILTER_FN<T>): DOMArray<T>;
    text(): string;
    text(newText: string): DOMArray<T>;
    unwrap(): DOMArray<T>;
    without(selector: sel): DOMArray<T>;
    wrap(target: Nodable<Element>): void;
    toArray(): Array<T>;
    toElements(): Element[];
    toSelector(): string;
    static isDOMArray<WHICH extends DOMTYPE = DOMTYPE>(thing: unknown): thing is DOMArray<WHICH>;
}
type ThingFn = (d?: Document) => Text | Element;
type Nodable<T extends Node> = string | T | T[] | DOMArray<T> | ThingFn;
type AnyNodable = string | Element | Text | Node | Element[] | Text[] | Node[] | DOMArray<Element> | DOMArray<Node> | DOMArray<Text> | ThingFn;
export {};