@odoo/owl 3.0.0-alpha.25 → 3.0.0-alpha.28

package/dist/types/runtime/component_node.d.ts

@@ -1,59 +0,0 @@
-import type { App } from "./app";
-import { BDom, VNode } from "./blockdom";
-import { Component, ComponentConstructor } from "./component";
-import { PluginManager } from "./plugin_manager";
-import { ComputationAtom } from "./reactivity/computations";
-import { Fiber, MountFiber, MountOptions } from "./rendering/fibers";
-import { STATUS } from "./status";
-type LifecycleHook = Function;
-export declare class ComponentNode implements VNode<ComponentNode> {
-    el?: HTMLElement | Text | undefined;
-    app: App;
-    fiber: Fiber | null;
-    component: Component;
-    bdom: BDom | null;
-    status: STATUS;
-    forceNextRender: boolean;
-    parentKey: string | null;
-    props: Record<string, any>;
-    defaultProps: Record<string, any>;
-    renderFn: Function;
-    parent: ComponentNode | null;
-    children: {
-        [key: string]: ComponentNode;
-    };
-    willStart: LifecycleHook[];
-    willUpdateProps: LifecycleHook[];
-    willUnmount: LifecycleHook[];
-    mounted: LifecycleHook[];
-    willPatch: LifecycleHook[];
-    patched: LifecycleHook[];
-    willDestroy: LifecycleHook[];
-    signalComputation: ComputationAtom;
-    computations: ComputationAtom[];
-    pluginManager: PluginManager;
-    constructor(C: ComponentConstructor, props: Record<string, any>, app: App, parent: ComponentNode | null, parentKey: string | null);
-    mountComponent(target: any, options?: MountOptions): void;
-    initiateRender(fiber: Fiber | MountFiber): Promise<void>;
-    render(deep: boolean): Promise<void>;
-    cancel(): void;
-    _cancel(): void;
-    destroy(): void;
-    _destroy(): void;
-    updateAndRender(props: Record<string, any>, parentFiber: Fiber): Promise<void>;
-    /**
-     * Finds a child that has dom that is not yet updated, and update it. This
-     * method is meant to be used only in the context of repatching the dom after
-     * a mounted hook failed and was handled.
-     */
-    updateDom(): void;
-    firstNode(): Node | undefined;
-    mount(parent: HTMLElement, anchor: ChildNode): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
-    patch(): void;
-    _patch(): void;
-    beforeRemove(): void;
-    remove(): void;
-}
-export {};

package/dist/types/runtime/context.d.ts

@@ -1,36 +0,0 @@
-import type { App } from "./app";
-import { type ComponentNode } from "./component_node";
-import { PluginManager } from "./plugin_manager";
-import { STATUS } from "./status";
-interface ComponentContext {
-    type: "component";
-    app: App;
-    componentName: string;
-    node: ComponentNode;
-    status: STATUS;
-}
-interface PluginContext {
-    type: "plugin";
-    app: App;
-    manager: PluginManager;
-    status: STATUS;
-}
-type Contexts = {
-    plugin: PluginContext;
-    component: ComponentContext;
-};
-type Context = Contexts[keyof Contexts];
-export declare let contextStack: Context[];
-export declare function saveContext(): () => void;
-export declare function getContext<K extends keyof Contexts>(type?: K): K extends string ? Contexts[K] : Context;
-export interface CapturedContext {
-    run<T = void>(callback: () => T): T;
-    protectAsync<P extends any[], R>(callback: (...args: P) => Promise<R>): (...args: P) => Promise<R>;
-    runWithAsyncProtection<T>(callback: () => Promise<T>): Promise<T>;
-}
-/**
- * Captures the current context and gives methods to run
- * functions within the captured context.
- */
-export declare function useContext(): CapturedContext;
-export {};

package/dist/types/runtime/event_handling.d.ts

@@ -1 +0,0 @@
-export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;

package/dist/types/runtime/hooks.d.ts

@@ -1,32 +0,0 @@
-import { App } from "./app";
-import { effect } from "./reactivity/effect";
-import { Signal } from "./reactivity/signal";
-/**
- * This hook will run a callback when a component is mounted and patched, and
- * will run a cleanup function before patching and before unmounting the
- * the component.
- *
- * @template T
- * @param {Effect<T>} effect the effect to run on component mount and/or patch
- * @param {()=>[...T]} [computeDependencies=()=>[NaN]] a callback to compute
- *      dependencies that will decide if the effect needs to be cleaned up and
- *      run again. If the dependencies did not change, the effect will not run
- *      again. The default value returns an array containing only NaN because
- *      NaN !== NaN, which will cause the effect to rerun on every patch.
- */
-export declare function useEffect(fn: Parameters<typeof effect>[0]): void;
-/**
- * When a component needs to listen to DOM Events on element(s) that are not
- * part of his hierarchy, we can use the `useListener` hook.
- * It will immediately add the listener, and remove it whenever the plugin or
- * component is destroyed.
- *
- * Example:
- *  a menu needs to listen to the click on window to be closed automatically
- *
- * Usage:
- *  in the constructor of the OWL component that needs to be notified,
- *  `useListener(window, 'click', () => this._doSomething());`
- * */
-export declare function useListener(target: EventTarget | Signal<EventTarget | null>, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
-export declare function useApp(): App;

package/dist/types/runtime/index.d.ts

@@ -1,46 +0,0 @@
-import { createBlock, html, list, mount as blockMount, multi, patch, remove, text, toggler, comment } from "./blockdom";
-export { Resource, useResource } from "./resource";
-export { Registry } from "./registry";
-export declare const blockDom: {
-    config: {
-        shouldNormalizeDom: boolean;
-        mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
-    };
-    mount: typeof blockMount;
-    patch: typeof patch;
-    remove: typeof remove;
-    list: typeof list;
-    multi: typeof multi;
-    text: typeof text;
-    toggler: typeof toggler;
-    createBlock: typeof createBlock;
-    html: typeof html;
-    comment: typeof comment;
-};
-export { App, mount } from "./app";
-export { xml } from "./template_set";
-export { Component } from "./component";
-export type { ComponentConstructor } from "./component";
-export { props } from "./props";
-export type { GetProps } from "./props";
-export { status } from "./status";
-export { proxy, markRaw, toRaw } from "./reactivity/proxy";
-export { untrack, type ReactiveValue } from "./reactivity/computations";
-export { signal, type Signal } from "./reactivity/signal";
-export { computed } from "./reactivity/computed";
-export { effect } from "./reactivity/effect";
-export { useEffect, useListener, useApp } from "./hooks";
-export { batched, EventBus, htmlEscape, whenReady, markup } from "./utils";
-export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, onWillDestroy, onError, } from "./lifecycle_hooks";
-export { assertType, validateType } from "./validation";
-export { types } from "./types";
-export { OwlError } from "../common/owl_error";
-export { config, plugin, providePlugins } from "./plugin_hooks";
-export type { PluginInstance } from "./plugin_hooks";
-export { Plugin } from "./plugin_manager";
-export type { PluginConstructor } from "./plugin_manager";
-export { useContext } from "./context";
-export type { CapturedContext } from "./context";
-export declare const __info__: {
-    version: string;
-};

package/dist/types/runtime/lifecycle_hooks.d.ts

@@ -1,10 +0,0 @@
-export declare function onWillStart(fn: () => Promise<void> | void | any): void;
-export declare function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any): void;
-export declare function onMounted(fn: () => void | any): void;
-export declare function onWillPatch(fn: () => any | void): void;
-export declare function onPatched(fn: () => void | any): void;
-export declare function onWillUnmount(fn: () => void | any): void;
-export declare function onWillDestroy(fn: () => void | any): void;
-type OnErrorCallback = (error: any) => void | any;
-export declare function onError(callback: OnErrorCallback): void;
-export {};

package/dist/types/runtime/plugin_hooks.d.ts

@@ -1,6 +0,0 @@
-import { PluginConstructor } from "./plugin_manager";
-import { Resource } from "./resource";
-export type PluginInstance<T extends PluginConstructor> = Omit<InstanceType<T>, "setup">;
-export declare function plugin<T extends PluginConstructor>(pluginType: T): PluginInstance<T>;
-export declare function config<T = any>(name: string, type?: T): T;
-export declare function providePlugins(pluginConstructors: PluginConstructor[] | Resource<PluginConstructor>, config?: Record<string, any>): void;

package/dist/types/runtime/plugin_manager.d.ts

@@ -1,36 +0,0 @@
-import { App } from "./app";
-import { ComputationAtom } from "./reactivity/computations";
-import { Resource } from "./resource";
-import { STATUS } from "./status";
-export interface PluginConstructor {
-    new (...args: any[]): Plugin;
-    id: string;
-}
-export declare class Plugin {
-    private static _shadowId;
-    static get id(): string;
-    static set id(shadowId: string);
-    __owl__: PluginManager;
-    constructor(manager: PluginManager);
-    setup(): void;
-}
-interface PluginManagerOptions {
-    parent?: PluginManager | null;
-    config?: Record<string, any>;
-}
-export declare class PluginManager {
-    app: App;
-    config: Record<string, any>;
-    onDestroyCb: Function[];
-    computations: ComputationAtom[];
-    plugins: Record<string, Plugin>;
-    status: STATUS;
-    constructor(app: App, options?: PluginManagerOptions);
-    destroy(): void;
-    getPluginById<T extends Plugin>(id: string): T | null;
-    getPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
-    startPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
-    startPlugins(pluginConstructors: PluginConstructor[]): void;
-}
-export declare function startPlugins(manager: PluginManager, plugins: PluginConstructor[] | Resource<PluginConstructor>): void;
-export {};

package/dist/types/runtime/props.d.ts

@@ -1,21 +0,0 @@
-import { GetOptionalEntries, KeyedObject, PrettifyShape, ResolveObjectType } from "./types";
-declare const isProps: unique symbol;
-export type WithDefaults<T, D> = T & Required<D>;
-export type Props<T extends {}> = T & {
-    [isProps]: true;
-};
-type GetPropsDefaults<T extends object> = PrettifyShape<GetOptionalEntries<T>>;
-type GetPropsWithOptionals<T> = T extends Props<infer P> ? (P extends WithDefaults<infer R, any> ? R : P) : never;
-export type GetProps<T> = {
-    [K in keyof T]: T[K] extends {
-        [isProps]: true;
-    } ? (x: GetPropsWithOptionals<T[K]>) => void : never;
-}[keyof T] extends (x: infer I) => void ? {
-    [K in keyof I]: I[K];
-} : never;
-export declare function props(): Props<Record<string, any>>;
-export declare function props<const Keys extends string[]>(keys: Keys): Props<ResolveObjectType<Keys>>;
-export declare function props<const Keys extends string[], Defaults>(keys: Keys, defaults: Defaults & GetPropsDefaults<KeyedObject<Keys>>): Props<WithDefaults<ResolveObjectType<Keys>, Defaults>>;
-export declare function props<Shape extends {}>(shape: Shape): Props<ResolveObjectType<Shape>>;
-export declare function props<Shape extends {}, Defaults>(shape: Shape, defaults: Defaults & GetPropsDefaults<Shape>): Props<WithDefaults<ResolveObjectType<Shape>, Defaults>>;
-export {};

package/dist/types/runtime/reactivity/computations.d.ts

@@ -1,34 +0,0 @@
-export interface ReactiveValue<TRead, TWrite = TRead> {
-    (): TRead;
-    /**
-     * Update the value of the reactive with a new value. If the new value is different
-     * from the previous values, all computations that depends on this reactive will
-     * be invalidated, and effects will rerun.
-     */
-    set(nextValue: TWrite): void;
-}
-export declare enum ComputationState {
-    EXECUTED = 0,
-    STALE = 1,
-    PENDING = 2
-}
-export interface Atom<T = any> {
-    observers: Set<ComputationAtom>;
-    value: T;
-}
-export interface ComputationAtom<T = any> extends Atom<T> {
-    compute: () => T;
-    isDerived: boolean;
-    sources: Set<Atom>;
-    state: ComputationState;
-}
-export declare const atomSymbol: unique symbol;
-export declare function createComputation(compute: () => any, isDerived: boolean, state?: ComputationState): ComputationAtom;
-export declare function onReadAtom(atom: Atom): void;
-export declare function onWriteAtom(atom: Atom): void;
-export declare function getCurrentComputation(): ComputationAtom<any> | undefined;
-export declare function setComputation(computation: ComputationAtom | undefined): void;
-export declare function updateComputation(computation: ComputationAtom): void;
-export declare function removeSources(computation: ComputationAtom): void;
-export declare function disposeComputation(computation: ComputationAtom): void;
-export declare function untrack<T>(fn: (...args: any[]) => T): T;

package/dist/types/runtime/reactivity/computed.d.ts

@@ -1,6 +0,0 @@
-import { ReactiveValue } from "./computations";
-interface ComputedOptions<TWrite> {
-    set?(value: TWrite): void;
-}
-export declare function computed<TRead, TWrite = TRead>(getter: () => TRead, options?: ComputedOptions<TWrite>): ReactiveValue<TRead, TWrite>;
-export {};

package/dist/types/runtime/reactivity/effect.d.ts

@@ -1 +0,0 @@
-export declare function effect<T>(fn: () => T): () => void;

package/dist/types/runtime/reactivity/proxy.d.ts

@@ -1,47 +0,0 @@
-import { Atom } from "./computations";
-type Target = object;
-type Reactive<T extends Target> = T;
-/**
- * Mark an object or array so that it is ignored by the reactivity system
- *
- * @param value the value to mark
- * @returns the object itself
- */
-export declare function markRaw<T extends Target>(value: T): T;
-/**
- * Given a proxy objet, return the raw (non proxy) underlying object
- *
- * @param value a proxy value
- * @returns the underlying value
- */
-export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
-export declare function proxifyTarget<T extends Target>(target: T, atom: Atom | null): T;
-/**
- * Creates a reactive proxy for an object. Reading data on the proxy object
- * subscribes to changes to the data. Writing data on the object will cause the
- * notify callback to be called if there are suscriptions to that data. Nested
- * objects and arrays are automatically made reactive as well.
- *
- * Whenever you are notified of a change, all subscriptions are cleared, and if
- * you would like to be notified of any further changes, you should go read
- * the underlying data again. We assume that if you don't go read it again after
- * being notified, it means that you are no longer interested in that data.
- *
- * Subscriptions:
- * + Reading a property on an object will subscribe you to changes in the value
- *    of that property.
- * + Accessing an object's keys (eg with Object.keys or with `for..in`) will
- *    subscribe you to the creation/deletion of keys. Checking the presence of a
- *    key on the object with 'in' has the same effect.
- * - getOwnPropertyDescriptor does not currently subscribe you to the property.
- *    This is a choice that was made because changing a key's value will trigger
- *    this trap and we do not want to subscribe by writes. This also means that
- *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
- *
- * @param target the object for which to create a proxy proxy
- * @param callback the function to call when an observed property of the
- *  proxy has changed
- * @returns a proxy that tracks changes to it
- */
-export declare function proxy<T extends Target>(target: T): T;
-export {};

package/dist/types/runtime/reactivity/signal.d.ts

@@ -1,31 +0,0 @@
-import { ReactiveValue } from "./computations";
-export interface Signal<T> extends ReactiveValue<T> {
-    /**
-     * Update the value of the signal with a new value. If the new value is different
-     * from the previous values, all computations that depends on this signal will
-     * be invalidated, and effects will rerun.
-     */
-    set(nextValue: T): void;
-}
-interface SignalOptions<T> {
-    type?: T;
-}
-declare function invalidateSignal(signal: Signal<any>): void;
-declare function signalArray<T>(initialValue: T[], options?: SignalOptions<T>): Signal<T[]>;
-declare function signalObject<T extends Record<PropertyKey, any>>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
-interface MapSignalOptions<K, V> {
-    name?: string;
-    keyType?: K;
-    valueType?: V;
-}
-declare function signalMap<K, V>(initialValue: Map<K, V>, options?: MapSignalOptions<K, V>): Signal<Map<K, V>>;
-declare function signalSet<T>(initialValue: Set<T>, options?: SignalOptions<T>): Signal<Set<T>>;
-export declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
-export declare namespace signal {
-    var invalidate: typeof invalidateSignal;
-    var Array: typeof signalArray;
-    var Map: typeof signalMap;
-    var Object: typeof signalObject;
-    var Set: typeof signalSet;
-}
-export {};

package/dist/types/runtime/registry.d.ts

@@ -1,24 +0,0 @@
-interface RegistryOptions<T> {
-    name?: string;
-    validation?: T;
-}
-export declare class Registry<T> {
-    private _map;
-    private _name;
-    private _validation?;
-    constructor(options?: RegistryOptions<T>);
-    entries: import(".").ReactiveValue<[string, T][], [string, T][]>;
-    items: import(".").ReactiveValue<T[], T[]>;
-    addById<U extends {
-        id: string;
-    } & T>(item: U, options?: {
-        sequence?: number;
-    }): Registry<T>;
-    add(key: string, value: T, options?: {
-        sequence?: number;
-    }): Registry<T>;
-    get(key: string, defaultValue?: T): T;
-    delete(key: string): void;
-    has(key: string): boolean;
-}
-export {};

package/dist/types/runtime/rendering/error_handling.d.ts

@@ -1,13 +0,0 @@
-import type { ComponentNode } from "../component_node";
-import type { Fiber } from "./fibers";
-export declare const fibersInError: WeakMap<Fiber, any>;
-export declare const nodeErrorHandlers: WeakMap<ComponentNode, ((error: any, finalize: Function) => void)[]>;
-type ErrorParams = {
-    error: any;
-} & ({
-    node: ComponentNode;
-} | {
-    fiber: Fiber;
-});
-export declare function handleError(params: ErrorParams): void;
-export {};

package/dist/types/runtime/rendering/fibers.d.ts

@@ -1,36 +0,0 @@
-import { BDom } from "../blockdom";
-import type { ComponentNode } from "../component_node";
-export declare function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber;
-export declare function makeRootFiber(node: ComponentNode): Fiber;
-export declare class Fiber {
-    node: ComponentNode;
-    bdom: BDom | null;
-    root: RootFiber | null;
-    parent: Fiber | null;
-    children: Fiber[];
-    appliedToDom: boolean;
-    deep: boolean;
-    childrenMap: ComponentNode["children"];
-    constructor(node: ComponentNode, parent: Fiber | null);
-    render(): void;
-}
-export declare class RootFiber extends Fiber {
-    counter: number;
-    willPatch: Fiber[];
-    patched: Fiber[];
-    mounted: Fiber[];
-    locked: boolean;
-    complete(): void;
-    setCounter(newValue: number): void;
-}
-type Position = "first-child" | "last-child";
-export interface MountOptions {
-    position?: Position;
-}
-export declare class MountFiber extends RootFiber {
-    target: HTMLElement;
-    position: Position;
-    constructor(node: ComponentNode, target: HTMLElement, options?: MountOptions);
-    complete(): void;
-}
-export {};

package/dist/types/runtime/rendering/scheduler.d.ts

@@ -1,20 +0,0 @@
-import type { ComponentNode } from "../component_node";
-import { Fiber, RootFiber } from "./fibers";
-export declare class Scheduler {
-    static requestAnimationFrame: (callback: FrameRequestCallback) => number;
-    tasks: Set<RootFiber>;
-    requestAnimationFrame: Window["requestAnimationFrame"];
-    frame: number;
-    delayedRenders: Fiber[];
-    cancelledNodes: Set<ComponentNode>;
-    processing: boolean;
-    constructor();
-    addFiber(fiber: Fiber): void;
-    scheduleDestroy(node: ComponentNode): void;
-    /**
-     * Process all current tasks. This only applies to the fibers that are ready.
-     * Other tasks are left unchanged.
-     */
-    flush(): void;
-    processTasks(): void;
-}

package/dist/types/runtime/rendering/template_helpers.d.ts

@@ -1,51 +0,0 @@
-import { OwlError } from "../../common/owl_error";
-import { App } from "../app";
-import { BDom, createCatcher, toggler } from "../blockdom";
-import { ComponentNode } from "../component_node";
-import { markRaw } from "../reactivity/proxy";
-/**
- * This file contains utility functions that will be injected in each template,
- * to perform various useful tasks in the compiled code.
- */
-declare function withDefault(value: any, defaultValue: any): any;
-declare function callSlot(ctx: any, parent: any, key: string, name: string, dynamic: boolean, extra: any, defaultContent?: (ctx: any, node: any, key: string) => BDom): BDom;
-declare function withKey(elem: any, k: string): any;
-declare function prepareList(collection: unknown): [unknown[], unknown[], number, undefined[]];
-declare function toNumber(val: string): number | string;
-declare function shallowEqual(l1: any[], l2: any[]): boolean;
-declare class LazyValue {
-    fn: any;
-    ctx: any;
-    component: any;
-    node: any;
-    key: any;
-    constructor(fn: any, ctx: any, component: any, node: any, key: any);
-    evaluate(): any;
-    toString(): any;
-}
-export declare function safeOutput(value: any, defaultValue?: any): ReturnType<typeof toggler>;
-declare function createRef(ref: any): (el: HTMLElement | null, previousEl: HTMLElement | null) => void;
-declare function callHandler(fn: any, ctx: any, ev: Event): void;
-declare function modelExpr(value: any): any;
-declare function createComponent<P extends Record<string, any>>(app: App, name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
-declare function callTemplate(subTemplate: string, owner: any, app: App, ctx: any, parent: any, key: any): any;
-export declare const helpers: {
-    withDefault: typeof withDefault;
-    zero: symbol;
-    callSlot: typeof callSlot;
-    withKey: typeof withKey;
-    prepareList: typeof prepareList;
-    shallowEqual: typeof shallowEqual;
-    toNumber: typeof toNumber;
-    LazyValue: typeof LazyValue;
-    safeOutput: typeof safeOutput;
-    createCatcher: typeof createCatcher;
-    markRaw: typeof markRaw;
-    OwlError: typeof OwlError;
-    createRef: typeof createRef;
-    modelExpr: typeof modelExpr;
-    createComponent: typeof createComponent;
-    callTemplate: typeof callTemplate;
-    callHandler: typeof callHandler;
-};
-export {};

package/dist/types/runtime/resource.d.ts

@@ -1,18 +0,0 @@
-interface ResourceOptions<T> {
-    name?: string;
-    validation?: T;
-}
-export declare class Resource<T> {
-    private _items;
-    private _name?;
-    private _validation?;
-    constructor(options?: ResourceOptions<T>);
-    items: import(".").ReactiveValue<T[], T[]>;
-    add(item: T, options?: {
-        sequence?: number;
-    }): Resource<T>;
-    delete(item: T): Resource<T>;
-    has(item: T): boolean;
-}
-export declare function useResource<T>(r: Resource<T>, elements: T[]): void;
-export {};

package/dist/types/runtime/status.d.ts

@@ -1,11 +0,0 @@
-import type { Component } from "./component";
-import { Plugin } from "./plugin_manager";
-export declare const enum STATUS {
-    NEW = 0,
-    MOUNTED = 1,// is ready, and in DOM. It has a valid el
-    CANCELLED = 2,
-    DESTROYED = 3
-}
-type STATUS_DESCR = "new" | "started" | "mounted" | "cancelled" | "destroyed";
-export declare function status(entity: Component | Plugin): STATUS_DESCR;
-export {};

package/dist/types/runtime/template_set.d.ts

@@ -1,36 +0,0 @@
-import { CustomDirectives, Template, TemplateFunction } from "../compiler";
-export interface TemplateSetConfig {
-    dev?: boolean;
-    translatableAttributes?: string[];
-    translateFn?: (s: string, translationCtx: string) => string;
-    templates?: string | Document | Record<string, string>;
-    getTemplate?: (s: string) => Element | Function | string | void;
-    customDirectives?: CustomDirectives;
-    globalValues?: object;
-}
-export declare class TemplateSet {
-    static registerTemplate(name: string, fn: TemplateFunction): void;
-    dev: boolean;
-    rawTemplates: typeof globalTemplates;
-    templates: {
-        [name: string]: Template;
-    };
-    getRawTemplate?: (s: string) => Element | Function | string | void;
-    translateFn?: (s: string, translationCtx: string) => string;
-    translatableAttributes?: string[];
-    customDirectives: CustomDirectives;
-    runtimeUtils: object;
-    hasGlobalValues: boolean;
-    constructor(config?: TemplateSetConfig);
-    addTemplate(name: string, template: string | Element): void;
-    addTemplates(xml: string | Document): void;
-    getTemplate(name: string): Template;
-    private _compileTemplate;
-}
-export declare const globalTemplates: {
-    [key: string]: string | Element | TemplateFunction;
-};
-export declare function xml(...args: Parameters<typeof String.raw>): string;
-export declare namespace xml {
-    var nextId: number;
-}