import { Component, Descriptor as Desc, Descriptor, Property as Prop, RenderFunction } from 'hybrids';
import { emit } from './events.js';
import { Disposable as Disp, Fn, Type } from './factories/disposable.js';
import { HostedMutationCallback } from './factories/mo.js';
import { slotted } from './refs/slotted.js';
type Connect<E, V = undefined> = Descriptor<E, V>['connect'];
/**
 * Create a type-curried builder for Hybrid components.
 * @category Define
 * @typeParam E - host element type
 * @returns type-curried helpers for building Hybrid components.
 */
export declare const HybridBuilder: <E extends HTMLElement>() => {
    prop: <V = any>(property: Prop<E, V>) => Prop<E, V>;
    be: <V = any>(value: Desc<E, V>["value"]) => Desc<E, V>;
    disposable: <V extends Disp = Disp>(Ctor: Type<Disp> | Fn<Disp>) => Prop<E, V>;
    effect: <V = any>(property: Prop<E, V>, ...effects: Desc<E, V>["observe"][]) => Prop<E, V>;
    mo: <V = any>(prop: Prop<E, V>, init: MutationObserverInit & {
        callback?: HostedMutationCallback<E>;
    }) => Desc<E, V>;
    mouse: ({ target, clamp, }?: {
        target?: Element;
        clamp?: boolean;
    }) => Desc<E, {
        x: number;
        y: number;
    }>;
    reflect: <V = any>(prop: Prop<E, V>, bidirectional?: boolean) => {
        reflect: boolean;
        connect(host: any, key: any, invalidate: any): () => void;
        value: V | ((host: E & HTMLElement) => V) | ((host: E & HTMLElement, value: any) => V);
        observe?(host: E & HTMLElement, value: V, lastValue: V): void;
    };
    ro: <V = any>(prop: Prop<E, V>) => Desc<E, V>;
    ref: (query: string) => Desc<unknown, E>;
    refs: (queryAll: string) => Desc<unknown, E[]>;
    slotted: typeof slotted;
    render: (renderer: RenderFunction<E>) => RenderFunction<E>;
    shadow: (value: RenderFunction<E>) => {
        value: RenderFunction<E>;
        shadow: boolean;
    };
    alpine: {
        (string: any, ...parts: any[]): import("hybrids").UpdateFunctionWithMethods<E>;
        engine: any;
        resolve: any;
        set: any;
        transition: any;
        host: typeof import("./template/alpine/x-host.js").xHost;
        prop: typeof import("./template/alpine/x-prop.js").xProp;
        config(Alp: typeof import("alpinejs"), directives?: Record<string, import("alpinejs").DirectiveCallback>): void;
    } | (<E_1>(_: E_1) => void);
    html: {
        (string: any, ...parts: any[]): import("hybrids").UpdateFunctionWithMethods<E>;
        engine: any;
        resolve: any;
        set: any;
        transition: any;
        host: typeof import("./template/alpine/x-host.js").xHost;
        prop: typeof import("./template/alpine/x-prop.js").xProp;
        config(Alp: typeof import("alpinejs"), directives?: Record<string, import("alpinejs").DirectiveCallback>): void;
    } | {
        (parts: TemplateStringsArray, ...args: unknown[]): import("hybrids").UpdateFunctionWithMethods<E>;
        set<E_1>(property: keyof E_1, valueOrPath?: any): import("hybrids").EventHandler<E_1>;
        set<E_1, M>(property: M, valueOrPath: string | null): import("hybrids").EventHandler<E_1>;
        resolve<E_1>(promise: Promise<any>, placeholder?: import("hybrids").UpdateFunction<E_1>, delay?: number): import("hybrids").UpdateFunction<E_1>;
        transition<E_1>(template: import("hybrids").UpdateFunction<E_1>): import("hybrids").UpdateFunction<E_1>;
        msg(parts: TemplateStringsArray, ...args: unknown[]): string;
    };
    xhost: <V = any>(prop: Prop<E, V>) => {
        connect(host: any, _key: any): void;
        observe(host: any, value: any, last: any): void;
        value: V | ((host: E & HTMLElement) => V) | ((host: E & HTMLElement, value: any) => V);
        reflect?: boolean | ((value: V) => string);
    };
    hy: {
        print: (data: any, space?: string | number) => import("hybrids").UpdateFunctionWithMethods<unknown>;
        if: <E_1>(condition: boolean | (() => boolean), frag: import("hybrids").UpdateFunctionWithMethods<E_1>, fallback?: import("hybrids").UpdateFunctionWithMethods<E_1>) => import("hybrids").UpdateFunctionWithMethods<E_1>;
        regex: <E_1, R extends RegExp>(regexp: R, frag: (match: RegExpExecArray) => import("hybrids").UpdateFunctionWithMethods<E_1>, fallback?: import("hybrids").UpdateFunctionWithMethods<E_1>) => (value: string) => import("hybrids").UpdateFunctionWithMethods<E_1>;
        map: <E_1, T>(items: T[] | ((...args: any[]) => T[]), predicate: (item: T, i: number, arr: T[]) => import("hybrids").UpdateFunctionWithMethods<E_1>) => import("hybrids").UpdateFunctionWithMethods<E_1>[];
        case: <E_1, T_1 extends number | string | symbol>(value: T_1, cases: Record<T_1, import("hybrids").UpdateFunctionWithMethods<E_1>> & {
            default?: import("hybrids").UpdateFunctionWithMethods<E_1>;
        }) => import("hybrids").UpdateFunctionWithMethods<E_1>;
        keyvalue: <E_1>(record: Record<any, any>, template: (key: any, value: any) => import("hybrids").UpdateFunctionWithMethods<E_1>) => import("hybrids").UpdateFunctionWithMethods<E_1>[];
    };
    emit: typeof emit;
    set: <Ev extends Event = Event>(property: keyof E, extractor?: (e: Ev) => E[typeof property]) => (host: E, e: Event) => E[keyof E];
    stop: <T_2 = any>(handler: (host: E, e: CustomEvent<T_2>) => void) => (host: E & HTMLElement, e: CustomEvent<T_2>) => void;
    prevent: <T_2 = any>(handler: (host: E, e: CustomEvent<T_2>) => void) => (host: E & HTMLElement, e: CustomEvent<T_2>) => void;
    define: (component: Component<E>) => Component<E>;
    compile: (component: Component<E>) => import("hybrids").HybridElement<E>;
};
/**
 * Build and define a web component with helpers.
 * @function
 * @category Define
 * @param factory a function which returns a component definition.
 * @typeParam E - host element type
 * @returns the defined component or null if the tag is already defined.
 */
export declare function build<E extends HTMLElement>(factory: (builder: ReturnType<typeof HybridBuilder<E>> & {
    onconnect: (...connectors: Connect<E>[]) => void;
    ondisconnect: (...disconnectors: Connect<E>[]) => void;
}) => Component<E>): Component<E> | null;
export declare namespace build {
    var compile: <E extends HTMLElement>(factory: (builder: ReturnType<typeof HybridBuilder<E>>) => Component<E>) => import("hybrids").HybridElement<E>;
}
export {};