import { TemplateInstance } from 'lit-html';
import { CompiledTemplate, CompiledTemplateResult } from 'lit-html';
export interface TemplateFunction {
    (model: object): unknown;
}
/**
 * A Renderer is responsible for rendering a block call, like
 * <template name="foo">
 */
export interface Renderer {
    (model: any, handlers: TemplateHandlers, renderers: Renderers): unknown;
}
export interface Renderers {
    [name: string]: Renderer;
}
/**
 * A TemplateHandlers is responsible for rendering control flow like
 * <template type="if" if="{{x}}">
 */
export type TemplateHandler = (template: HTMLTemplateElement, model: object, handlers: TemplateHandlers, renderers: Renderers) => unknown;
export interface TemplateHandlers {
    [name: string]: TemplateHandler;
}
export declare const ifHandler: TemplateHandler;
export declare const repeatHandler: TemplateHandler;
export declare const defaultHandlers: TemplateHandlers;
/**
 * @returns {Function} a template function of the form (model) => TemplateResult
 */
export declare const prepareTemplate: (template: HTMLTemplateElement, handlers?: TemplateHandlers, renderers?: Renderers, superTemplate?: HTMLTemplateElement) => TemplateFunction;
export interface RenderOptions {
    renderers?: Renderers;
    extends?: HTMLTemplateElement;
}
/**
 * Renders a template element containing a Stampino template.
 *
 * This is a convenience function wrapper around:
 *
 * ```
 * import {render} from 'lit';
 * const templateFn = prepareTemplate(templateEl);
 * render(templateFn(model), container);
 * ```
 */
export declare const render: (template: HTMLTemplateElement, container: HTMLElement, model: any, handlers?: TemplateHandlers) => void;
/**
 * Evaluates the given template and returns its result
 *
 * @param template
 * @param model
 * @param handlers
 * @param renderers
 * @returns
 */
export declare const evaluateTemplate: (template: HTMLTemplateElement, model: any, handlers?: TemplateHandlers, renderers?: Renderers) => CompiledTemplateResult;
type TemplatePart = TemplateInstance['_$template']['parts'][0];
type StampinoTemplatePart = TemplatePart & {
    update: PartUpdater;
};
type PartUpdater = (model: object, handlers: TemplateHandlers, blocks: Renderers) => unknown;
interface StampinoTemplate extends CompiledTemplate {
    parts: Array<StampinoTemplatePart>;
    renderers: Renderers;
}
export declare const getLitTemplate: (template: HTMLTemplateElement) => StampinoTemplate;
export {};
//# sourceMappingURL=stampino.d.ts.map