import type { ViewModel } from '../main/view-model.js';
import type { PopupOptions, PopupRender } from '../views/layout/popup.js';
import { Dictionary } from './dict.js';
export type RenderContext = ReturnType<typeof createRenderContext>;
type RenderFunction = (el: HTMLElement | DocumentFragment, props: RenderProps, data?: any, context?: any) => Promise<any> | void;
type NormalizedViewPropsFunction = (data: any, context: {
    props: RenderProps;
    context: any;
}) => any;
type DefineViewRender = RenderFunction | RawViewConfig;
type ViewUsage = any;
export type RawViewConfig = SingleViewConfig | RenderFunction | string | RawViewConfig[];
export type NormalizedViewConfig = SingleViewConfig | SingleViewConfig[];
type ClassNameFn = (data: any, context: any) => string | false | null | undefined;
type queryFn = (data: any, context: any) => any;
type query = string | queryFn | boolean;
type ConfigTransitionTreeNode = {
    value: any;
    deps: ConfigTransitionTreeNode[];
};
type RootViewInfo = {
    name: string;
    [key: string]: any;
};
type ViewTreeNode = {
    parent: ViewTreeNode | null;
    children: ViewTreeNode[];
    node?: Node | null;
    view?: ViewInfo;
    viewRoot?: RootViewInfo;
};
export interface ViewOptions {
    tag: string | false | null;
    render: DefineViewRender;
    usage: ViewUsage;
    props: NormalizedViewPropsFunction | string;
}
export type ViewOptionsWithoutRender = Exclude<ViewOptions, 'render'>;
export interface NormalizedViewOptions {
    tag: string | null | undefined;
    usage?: ViewUsage;
    props?: NormalizedViewPropsFunction;
}
interface View {
    name: string | false;
    options: NormalizedViewOptions;
    render: RenderFunction;
}
export interface SingleViewConfig {
    view: string | RenderFunction;
    when?: query;
    context?: query;
    data?: query;
    whenData?: query;
    className?: string | ClassNameFn | (string | ClassNameFn)[];
    tooltip?: TooltipConfig | RawViewConfig;
    [key: string]: any;
}
type RenderPropsForbiddenKeys = 'view' | 'when' | 'context' | 'data' | 'whenData' | 'postRender' | 'className' | 'tooltip';
type RenderProps = {
    [K in string]: K extends RenderPropsForbiddenKeys ? never : any;
};
type PropsTransition = {
    props: any;
    fn: NormalizedViewPropsFunction & {
        query?: string;
    };
};
interface ViewInfo {
    config: NormalizedViewConfig;
    skipped?: 'when' | 'whenData';
    props?: any;
    inputData: any;
    inputDataIndex?: number;
    data: any;
    context: any;
}
export type TooltipConfig = Partial<{
    showDelay: boolean | number;
    className: string;
    position: PopupOptions['position'];
    positionMode: PopupOptions['positionMode'];
    pointerOffsetX: number;
    pointerOffsetY: number;
    content: RawViewConfig;
}>;
export declare function isRawViewConfig(value: unknown): value is RawViewConfig;
declare function createRenderContext(viewRenderer: ViewRenderer, name: string): {
    name: string;
    normalizeConfig: any;
    ensureValidConfig: any;
    composeConfig: any;
    propsFromConfig: any;
    computeClassName: any;
    applyComputedClassName: any;
    render: any;
    listLimit: any;
    renderList: any;
    maybeMoreButtons: any;
    renderMoreButton: any;
    tooltip(el: HTMLElement, config: RenderProps, data?: any, context?: any): void;
};
declare function createTooltip(host: ViewModel): ViewPopup;
type PopupShowArgs = [triggerEl: HTMLElement, render?: PopupRender, showImmediately?: boolean];
export declare class ViewPopup {
    el: HTMLElement;
    position: TooltipConfig['position'];
    positionMode: TooltipConfig['positionMode'];
    pointerOffsetX: TooltipConfig['pointerOffsetX'];
    pointerOffsetY: TooltipConfig['pointerOffsetY'];
    constructor(config: Partial<PopupOptions>);
    toggle(...args: PopupShowArgs): void;
    show(...args: PopupShowArgs): Promise<void>;
    hide(): void;
}
export declare class ViewRenderer extends Dictionary<View> {
    host: ViewModel;
    defaultRenderErrorRenderer: View;
    viewEls: WeakMap<Node, ViewInfo>;
    fragmentEls: WeakMap<Node, ViewInfo[]>;
    tooltip: ReturnType<typeof createTooltip> | null;
    Popup: typeof ViewPopup;
    constructor(host: ViewModel);
    define(name: string, render: DefineViewRender, options?: ViewOptionsWithoutRender): Readonly<View>;
    define(name: string, options: ViewOptions): Readonly<View>;
    normalizeConfig(config: RawViewConfig | RenderFunction): SingleViewConfig | SingleViewConfig[] | null;
    badConfig(config: any, error: Error): SingleViewConfig;
    ensureValidConfig(config: any): NormalizedViewConfig;
    composeConfig(config: any, extension: any): NormalizedViewConfig;
    propsFromConfig(config: SingleViewConfig, data: any, context: any, fn?: NormalizedViewPropsFunction | null | false | undefined): Record<string, any>;
    render(container: HTMLElement | DocumentFragment, config: RawViewConfig, data?: any, context?: any, dataIndex?: number): Promise<void>;
    listLimit(value: any, defaultValue: number): number | false;
    renderList(container: HTMLElement, itemConfig: RawViewConfig, data: any[], context: any, offset: number | undefined, limit: number | false | undefined, moreContainer: HTMLElement): Promise<void[]>;
    maybeMoreButtons(container: HTMLElement, beforeEl: Node | null, count: number, offset: number, limit: number, renderMore: (offset: number, limit: number) => any): HTMLSpanElement | null;
    renderMoreButton(container: HTMLElement, caption: string, fn: () => void): void;
    attachTooltip(el: HTMLElement, config: TooltipConfig | RawViewConfig, data?: any, context?: any): void;
    adoptFragment(fragment: DocumentFragment, probe: Node): void;
    setViewRoot(node: HTMLElement, name: string, props: Record<string, any>): void;
    getViewTree(ignore: Node[]): ViewTreeNode[];
    getViewStackTrace(el: Node): ViewInfo[] | null;
    getViewConfigTransitionTree(value: any): ConfigTransitionTreeNode;
    getViewPropsTransition(value: any): null | PropsTransition & {
        query: string | null;
    };
}
export {};