import * as React from "react";
import { ComponentType } from "react";
import { _BaseNodeRenderer, BaseRendererMap, NodeRendererProps, TreeRendererMap } from "./BaseRenderer";
import { TreeNode } from "../tree/types";
export type InferItemType<R> = R extends React.ComponentType<{
    item: infer Item1;
    node: TreeNode;
}> ? Item1 : R extends React.ComponentType<{
    item: infer Item;
}> ? Item : "Make sure the Renderer renders the correct item type e.g. (props:{item:Item, node: TreeNode}) => React.ReactNode";
export type FlatItemToRender<Rm extends BaseRendererMap<any>, K extends keyof Rm = keyof Rm, Item = InferItemType<Rm[K]>> = {
    item: Item;
    type: K;
};
export type ItemToRender<Rm extends BaseRendererMap<any>, K extends keyof Rm = keyof Rm, Item = InferItemType<Rm[K]>> = FlatItemToRender<Rm, K> & {
    _children?: ItemToRender<Rm>[];
};
export type _GenericRenderer<Rm extends BaseRendererMap<any>, ItemType extends ItemToRender<Rm> = ItemToRender<Rm>> = {
    rendererMap: Rm;
    items: ItemType[];
};
export declare class BaseAdapter<T = any, R extends React.ComponentType<T> = React.ComponentType<T>> {
    data: any;
    constructor(data: any);
    setData(data: object): this;
    filter<K>(obj: K, key: keyof K): boolean;
    getChildren: <K extends object>(obj: K) => (keyof K)[];
    isParent: (obj: any) => boolean;
    getFilteredChildren<K>(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>;
}
type NestedType<T = any> = {
    item: T;
    _children: NestedObjectOfType<T>[];
};
type NestedObjectOfType<T = any> = T | NestedType<T>;
type ListData<I> = I[];
type AdapterData<D> = D | (() => D);
declare class BaseAdapterBuilder<I, Data> {
    data: Data;
    treeNodeRenderer: ComponentType<NodeRendererProps<I>>;
    getChildrenKeys: (obj: any) => (any[]);
    isParent: (obj: any) => (boolean);
    adjust: ((obj: any) => {
        data: any;
        deltaPath: string;
    });
    setData(data: Data): this;
}
declare class ListSingleAdapterBuilder<ItemType = any> extends BaseAdapterBuilder<ItemType, AdapterData<ListData<ItemType>>> {
    readonly renderer: _BaseNodeRenderer<ItemType>;
    constructor(renderer: _BaseNodeRenderer<ItemType>);
    nested(): ListSingleAdapterBuilder<NestedObjectOfType<ItemType>>;
    build(): Adapter<any, NodeRendererProps<any>>;
}
declare class ListMultiAdapterBuilder<Rm extends TreeRendererMap, ItemType extends FlatItemToRender<Rm> = FlatItemToRender<Rm>> extends BaseAdapterBuilder<ItemType, AdapterData<ListData<ItemType>>> {
    readonly rendererMap: Rm;
    constructor(rendererMap: Rm);
    nested(): ListMultiAdapterBuilder<Rm, ItemToRender<Rm>>;
    noGeneralOnClick(): ListMultiAdapterBuilder<Rm, ItemToRender<Rm>>;
    build(): Adapter<any, NodeRendererProps<any>>;
}
type NestedTreeData<I> = {
    [k: string]: I | TreeData<I>;
};
type TreeData<I> = NestedTreeData<I>;
declare class TreeSingleAdapterBuilder<RenderItemType = any> extends BaseAdapterBuilder<RenderItemType, AdapterData<TreeData<RenderItemType>>> {
    readonly renderer: _BaseNodeRenderer<RenderItemType>;
    constructor(renderer: _BaseNodeRenderer<RenderItemType>);
    treeNodeRenderer: (props: NodeRendererProps<RenderItemType>) => React.JSX.Element;
    build(): Adapter<any, NodeRendererProps<any>>;
}
declare class ListAdapterBuilder {
    singleRender<Item>(renderer: _BaseNodeRenderer<Item>): ListSingleAdapterBuilder<Item>;
    multiRender<Rm extends TreeRendererMap>(rendererMap: Rm): ListMultiAdapterBuilder<Rm, FlatItemToRender<Rm, keyof Rm, InferItemType<Rm[keyof Rm]>>>;
}
declare class TreeAdapterBuilder {
    singleRender<Item>(renderer: _BaseNodeRenderer<Item>): TreeSingleAdapterBuilder<Item>;
}
declare class MainAdapterBuilder {
    list(): ListAdapterBuilder;
    tree(): TreeAdapterBuilder;
}
export declare function AdapterBuilder(): MainAdapterBuilder;
export {};