import { type Http, Injector, Interpolate, SimpleInjector, type Subscription } from '@akala/core';
/**
 * Function type for rendering and managing template instances.
 * @template T - Type of the controller object.
 * @param target - Data context object for template interpolation.
 * @param parent - Parent DOM element or shadow root to append template elements.
 * @param controller - Controller object for managing template lifecycle.
 * @returns Disposable instance to clean up template bindings.
 */
export interface templateFunction {
    <T extends Partial<Disposable>>(target: object, parent: HTMLElement | ShadowRoot, controller: T): Disposable;
    /**
     * Replace the current template with new markup.
     * @param markup - New template string to compile and render.
     */
    hotReplace(markup: string): void;
    /**
     * Watch for data changes and trigger re-renders.
     * @param target - Data object to observe.
     * @param handler - Callback executed when data changes.
     * @param trigger - Whether to invoke handler immediately.
     * @returns Subscription to stop watching.
     */
    watch(target: object, handler: () => void, trigger?: boolean): Subscription;
}
/**
 * Defines a DOM composition strategy for template elements.
 * @template TOptions - Type of configuration options.
 */
export interface Composer<TOptions = unknown> {
    /**
     * CSS selector(s) identifying elements this composer applies to.
     */
    selector: string | string[];
    /**
     * Extracts configuration options from a parent context.
     * @param options - Parent configuration object.
     * @returns Parsed configuration options for this composer.
     */
    optionGetter(options: object): TOptions;
    /**
     * Applies composition logic to selected elements.
     * @param items - Elements to compose.
     * @param options - Configuration options.
     * @param futureParent - Target container for composed elements.
     * @returns Disposable to manage composition lifecycle.
     */
    apply(items: Element, options?: TOptions, futureParent?: Element | DocumentFragment): Disposable;
}
export declare function composer(selector: string, optionName?: string): ClassDecorator;
export declare function composer(selector: (new () => Composer)): void;
export declare function composer(selector: Composer): void;
declare const cache: SimpleInjector;
export { cache as templateCache };
export declare class Template {
    private interpolator;
    private http;
    private templateInjector;
    /**
     * Registered DOM behavior composers.
     * @type {Composer[]}
     */
    static composers: Composer[];
    /**
     * Template service constructor.
     * @param interpolator - Handles expression interpolation in templates
     * @param http - HTTP client for loading external templates
     * @param templateInjector - Dependency injector for template options resolution
     */
    constructor(interpolator: Interpolate, http: Http, templateInjector: Injector);
    /**
     * Enables hot template reloading during development
     */
    enableHotReplacement: boolean;
    /**
     * Retrieves and caches template functions.
     * @param t - Template URL or markup string
     * @param registerTemplate - Whether to cache the result
     * @returns Resolved template function
     */
    get(t: string | PromiseLike<string>, registerTemplate?: boolean): Promise<templateFunction>;
    static buildElements(string: any): ArrayLike<HTMLElement>;
    build(markup: string): templateFunction;
    /**
     * Applies all registered composers to a collection of elements.
     * @param items - Elements to process
     * @param root - Context container for composition
     * @param options - Global configuration options
     * @returns Combined disposable for all compositions
     */
    static composeAll(items: ArrayLike<Element>, root?: Element | DocumentFragment, options?: object): Disposable;
    /**
     * Applies a specific composer to elements.
     * @param composer - Composition strategy to use
     * @param items - Elements to process
     * @param root - Composition context container
     * @param options - Configuration options for the composer
     * @returns Combined disposable for all compositions
     */
    static compose<TOptions>(composer: Composer<TOptions>, items: ArrayLike<Element>, root?: Element | DocumentFragment, options?: TOptions): Disposable;
}
/**
 * Manages multiple disposables as a single unit.
 */
export declare class CompositeDisposable implements Disposable {
    private disposables;
    constructor(disposables: Disposable[]);
    /**
     * Disposes all contained disposables.
     */
    [Symbol.dispose](): void;
}
/**
 * Filters elements matching given selectors.
 * @param items - Elements to filter
 * @param selectors - CSS selectors to match
 * @returns Elements matching the selectors
 */
export declare function filter<T extends Element = Element>(items: ArrayLike<T>, selectors: string | string[]): T[];