import { MaybeReactive, MaybeReactiveProps } from '../reactive/types';
import { MaybeArray } from '../utils/array';
import { AddStylesArgs } from './styles';
import { PrimitiveType } from '../utils/primitive';
import { VComponent, WithHtml } from '../component/component';
import { IDocument } from '../render/window';
import { PartialExcept } from '../utils/partial-except';

type TagName = keyof HTMLElementTagNameMap;
export type Listener = Exclude<{
    [K in keyof HTMLElement]: K extends `on${infer E}` ? E : never;
}[keyof HTMLElement], undefined>;
export type EventHandlerKey = `on${Capitalize<Listener>}`;
type EventHandler = (e?: Event) => void;
export type EventHandlers = {
    [K in Listener]?: EventHandler;
};
export type AddClassesArgs = MaybeArray<MaybeReactive<string | undefined>> | Record<string, MaybeReactive<boolean>>;
export type ComponentChildren = (VComponent | MaybeReactive<PrimitiveType>)[];
type CreateDomElementProps<T extends TagName> = {
    type: T;
    children: ComponentChildren;
    handlers?: EventHandlers;
    className?: AddClassesArgs;
    styles?: AddStylesArgs;
};
export declare class VDomComponent<T extends TagName> implements VComponent {
    private _doc;
    private type;
    private children;
    private className?;
    private styles?;
    private handlers?;
    private otherAttributes;
    constructor(_doc: IDocument, type: T, children: ComponentChildren, className?: AddClassesArgs, styles?: AddStylesArgs | undefined, handlers?: EventHandlers | undefined, otherAttributes: Record<string, unknown>);
    private _html;
    get html(): HTMLElementTagNameMap[T];
    private get reactiveChildren();
    addClass(newClasses?: AddClassesArgs): this;
    addStyles(newStyles: AddStylesArgs): this;
    on(newEventHandlers: EventHandlers): this;
    private options;
    withOptions(options: Partial<MaybeReactiveProps<HTMLElementTagNameMap[T]>>): this;
    private _addOptionsToElement;
    parent: WithHtml;
    init(parent: WithHtml): void;
    private _rerenderOnChanges;
    private sub;
    private _updateOptionsReactively;
    renderOnce(): HTMLElementTagNameMap[T];
    destroy(): void;
    readonly __type = "V_COMPONENT";
}
export declare const _createDomElement: <T extends keyof HTMLElementTagNameMap>(props: PartialExcept<CreateDomElementProps<T>, 'type'>, injections?: {
    doc: IDocument;
}) => VDomComponent<T>;
export declare const createDomElement: <T extends keyof HTMLElementTagNameMap>(type: T, injections?: {
    doc?: IDocument;
}) => (...children: (VComponent | MaybeReactive<PrimitiveType>)[]) => VDomComponent<T>;
export declare const addEventListenersToElement: (element: HTMLElement, handlers: EventHandlers) => void;
export {};