import * as React from 'react';
import { ComponentType } from 'react';
import { TS_Object } from '@nu-art/ts-common';
import { _BaseNodeRenderer, NodeRendererProps } from './BaseRenderer.js';
export type TreeNode = {
    propKey: string;
    item: any;
    adapter: Adapter;
    path: string;
    expandToggler: (e: React.MouseEvent, expand?: boolean) => void;
    expandFromNode: (exapnd?: boolean) => void;
    expanded: boolean;
};
export type ListData<I> = I[];
export type ListItem<I> = {
    item: I;
    _children?: ListItem<I>[];
};
export type NestedListItem<I> = {
    item: I;
    _children?: NestedListData<I>[];
};
export type NestedListData<I> = I | NestedListItem<I>;
export type TreeData<I> = {
    [k: string]: I | TreeData<I>;
};
type TreeItem<TreeMap> = {
    [K in keyof TreeMap]: {
        type: K;
        item: TreeMap[K];
        _children?: TreeItem<TreeMap>[];
        alwaysExpanded?: boolean;
    };
}[keyof TreeMap];
export type TreeType<TreeMap> = {
    map: TreeMap;
    action: {
        [K in keyof TreeMap]: (item: TreeMap[K]) => Promise<any> | any;
    };
    nodeRenderer: {
        [K in keyof TreeMap]: React.ComponentType<NodeRendererProps<TreeMap[K]>>;
    };
    renderer: {
        [K in keyof TreeMap]: React.ComponentType<{
            item: TreeMap[K];
        }>;
    };
    rendererV3: {
        [K in keyof TreeMap]: React.ComponentType<TreeMap[K]>;
    };
    nodeTypesMap: {
        [K in keyof TreeMap]: {
            type: K;
            item: TreeMap[K];
            _children?: TreeItem<TreeMap>[];
        };
    };
    nodeType: TreeItem<TreeMap>;
};
type AdapterData<D> = D | (() => D);
export declare class BaseAdapter<T = any> {
    data: any;
    childrenKey?: string;
    constructor(data: any);
    setData(data: object): this;
    filter: <K = any>(obj: K, key: keyof K) => boolean;
    isParent: (obj: any) => boolean;
    hadChildren: (obj: any) => boolean;
    getFilteredChildren<K extends TS_Object>(obj: K): (keyof K)[] | [];
    adjust: ((obj: any) => {
        data: any;
        deltaPath: string;
    });
    clone(baseAdapter: this): this;
}
export declare class Adapter<T = any, I extends NodeRendererProps<T> = NodeRendererProps<T>> extends BaseAdapter<I> {
    hideRoot: boolean;
    treeNodeRenderer: _BaseNodeRenderer<any>;
    setTreeNodeRenderer(renderer: any): this;
    resolveRenderer(propKey: string): _BaseNodeRenderer<I>;
}
declare abstract class BaseAdapterBuilder<Data> {
    data: Data;
    treeNodeRenderer: ComponentType<NodeRendererProps>;
    multiRenderer: boolean;
    expandCollapseRenderer: ComponentType<NodeRendererProps>;
    protected filter: <K = any>(obj: K, key: keyof K) => boolean;
    childrenKey?: string;
    constructor();
    setData(data: Data): this;
    setNodeRenderer(treeNodeRenderer: ComponentType<NodeRendererProps>): this;
    setExpandCollapseRenderer(expandCollapseRenderer: ComponentType<NodeRendererProps>): this;
    setChildrenKey: (childrenKey: string) => this;
    setFilter(filter: <K = any>(obj: K, key: keyof K) => boolean): void;
    protected defaultExpandCollapseRenderer: (props: NodeRendererProps) => import("react/jsx-runtime").JSX.Element;
    protected defaultTreeNodeRenderer: (props: NodeRendererProps) => import("react/jsx-runtime").JSX.Element;
    protected abstract resolveRenderer(type: string): _BaseNodeRenderer<any>;
}
declare class ListSingleAdapterBuilder<ItemType = any> extends BaseAdapterBuilder<AdapterData<ListData<ItemType>>> {
    readonly renderer: _BaseNodeRenderer<ItemType>;
    constructor(renderer: _BaseNodeRenderer<ItemType>);
    protected resolveRenderer(type?: string): _BaseNodeRenderer<any>;
    nested(): ListSingleAdapterBuilder<NestedListData<ItemType>>;
    build(): Adapter<any, NodeRendererProps<any>>;
}
declare class MultiTypeAdapterBuilder<TreeMap extends TreeType<any>> extends BaseAdapterBuilder<TreeMap['nodeType']> {
    readonly rendererMap: TreeMap['nodeRenderer'];
    private _hideRoot;
    constructor(rendererMap: TreeMap['nodeRenderer']);
    protected resolveRenderer: (type?: string) => _BaseNodeRenderer<any>;
    tree(): MultiTypeAdapterBuilder<TreeMap>;
    hideRoot(): this;
    build(): Adapter<any, NodeRendererProps<any>>;
}
declare class TreeSingleAdapterBuilder<RenderItemType = any> extends BaseAdapterBuilder<AdapterData<TreeData<RenderItemType>>> {
    readonly renderer: _BaseNodeRenderer<RenderItemType>;
    private _hideRoot;
    constructor(renderer: _BaseNodeRenderer<RenderItemType>);
    protected resolveRenderer(type?: string): _BaseNodeRenderer<any>;
    hideRoot(): this;
    build(): Adapter<any, NodeRendererProps<any>>;
}
declare class ListAdapterBuilder {
    singleRender<Item>(renderer: _BaseNodeRenderer<Item>): ListSingleAdapterBuilder<Item>;
    multiRender<TreeMap extends TreeType<any>>(rendererMap: TreeMap['nodeRenderer']): MultiTypeAdapterBuilder<TreeMap>;
    multiRenderV3<TreeMap extends TreeType<any>>(rendererMap: TreeMap['nodeRenderer']): MultiTypeAdapterBuilder<TreeMap>;
}
declare class TreeAdapterBuilder {
    singleRender<Item>(renderer: _BaseNodeRenderer<Item>): TreeSingleAdapterBuilder<Item>;
    multiRender<TreeMap extends TreeType<any>>(rendererMap: TreeMap['nodeRenderer']): MultiTypeAdapterBuilder<TreeMap>;
}
declare class _AdapterBuilder {
    list(): ListAdapterBuilder;
    tree(): TreeAdapterBuilder;
}
export declare function AdapterBuilder(): _AdapterBuilder;
export declare function SimpleTreeAdapter<T>(options: TreeData<T>, renderer: (node: NodeRendererProps<T>) => React.ReactElement): Adapter<any, NodeRendererProps<any>>;
export declare function SimpleListAdapter<T>(options: T[], renderer: (node: NodeRendererProps<T>) => React.ReactElement): Adapter<any, NodeRendererProps<any>>;
export {};