@odoo/owl 3.0.0-alpha.2 → 3.0.0-alpha.20

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

@@ -0,0 +1,33 @@
+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 untrack<T>(fn: (...args: any[]) => T): T;

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

@@ -0,0 +1,6 @@
+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/derived.d.ts

@@ -0,0 +1,7 @@
+import { Opts, Derived } from "./computations";
+import { ReactiveValue } from "./signal";
+export declare function derived<T>(fn: () => T, opts?: Opts): ReactiveValue<T>;
+export declare function setSignalHooks(hooks: {
+    onDerived: (derived: Derived<any, any>) => void;
+}): void;
+export declare function resetSignalHooks(): void;

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

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

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

@@ -0,0 +1,47 @@
+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/reactivity.d.ts

@@ -0,0 +1,46 @@
+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 const targets: WeakMap<object, object>;
+/**
+ * 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

@@ -0,0 +1,31 @@
+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/reactivity/signals.d.ts

@@ -0,0 +1,30 @@
+import { Atom, Computation, Derived, Opts } from "../../common/types";
+type SignalFunction<T> = () => T;
+export interface Signal<T> extends SignalFunction<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(value: T): void;
+    /**
+     * Call the updater function (if given) to update the signal value.
+     * If the updater value is not given, then all computations that depends on
+     * this signal will be invalidated and effects will rerun.
+     */
+    update(updater?: (value: T) => T): void;
+}
+export declare function signal<T>(value: T, opts?: Opts): Signal<T>;
+export declare function effect<T>(fn: () => T, opts?: Opts): () => void;
+export declare function derived<T>(fn: () => T, opts?: Opts): () => T;
+export declare function onReadAtom(atom: Atom): void;
+export declare function onWriteAtom(atom: Atom): void;
+export declare function withoutReactivity<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;
+export declare function getCurrentComputation(): Computation<any> | undefined;
+export declare function setComputation(computation: Computation | undefined): void;
+export declare function runWithComputation<T>(computation: Computation, fn: () => T): T;
+export declare function setSignalHooks(hooks: {
+    onDerived: (derived: Derived<any, any>) => void;
+}): void;
+export declare function resetSignalHooks(): void;
+export {};

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

@@ -0,0 +1,48 @@
+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 const targets: WeakMap<object, object>;
+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 state<T extends Target>(target: T): T;
+export {};

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

@@ -1,3 +1,4 @@
+import type { Callback } from "./utils";
 declare type Target = object;
 declare type Reactive<T extends Target> = T;
 /**
@@ -14,6 +15,16 @@ export declare function markRaw<T extends Target>(value: T): T;
  * @returns the underlying value
  */
 export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
+/**
+ * Clears all subscriptions of the Reactives associated with a given callback.
+ *
+ * @param callback the callback for which the reactives need to be cleared
+ */
+export declare function clearReactivesForCallback(callback: Callback): void;
+export declare function getSubscriptions(callback: Callback): {
+    target: object;
+    keys: (string | number | symbol)[];
+}[];
 export declare const targets: WeakMap<object, object>;
 /**
  * Creates a reactive proxy for an object. Reading data on the reactive object
@@ -42,5 +53,5 @@ export declare const targets: WeakMap<object, object>;
  *  reactive has changed
  * @returns a proxy that tracks changes to it
  */
-export declare function reactive<T extends Target>(target: T): T;
+export declare function reactive<T extends Target>(target: T, callback?: Callback): T;
 export {};

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

@@ -1,15 +1,24 @@
-import { Schema } from "./validation";
-declare type Fn<T> = () => T;
-export declare class Registry<T> {
-    _map: {
-        [key: string]: [number, T];
-    };
-    _name: string;
-    _schema?: Schema;
-    items: Fn<T[]>;
-    entries: Fn<[string, T][]>;
-    constructor(name?: string, schema?: Schema);
-    set(key: string, value: T, sequence?: number): void;
-    get(key: string, defaultValue?: T): T;
-}
-export {};
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,37 @@
+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;
+    _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

@@ -0,0 +1,21 @@
+import type { ComponentNode } from "../component_node";
+import { Fiber, RootFiber } from "./fibers";
+export declare class Scheduler {
+    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+    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;
+    processFiber(fiber: RootFiber): void;
+}

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

@@ -0,0 +1,51 @@
+import { OwlError } from "../../common/owl_error";
+import { App } from "../app";
+import { BDom, createCatcher, toggler } from "../blockdom";
+import { ComponentNode } from "../component_node";
+import { Portal } from "../portal";
+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 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;
+    Portal: typeof Portal;
+    callTemplate: typeof callTemplate;
+};
+export {};

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

@@ -0,0 +1,18 @@
+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/signals.d.ts

@@ -1,8 +1,9 @@
 import { Atom, Computation, Derived, Opts } from "../common/types";
-export declare function signal<T>(value: T, opts?: Opts): {
-    readonly get: () => T;
-    readonly set: (newValue: T | ((prevValue: T) => T)) => void;
-};
+type SignalFunction<T> = () => T;
+export interface Signal<T> extends SignalFunction<T> {
+    set(value: T): void;
+}
+export declare function signal<T>(value: T, opts?: Opts): Signal<T>;
 export declare function effect<T>(fn: () => T, opts?: Opts): () => void;
 export declare function derived<T>(fn: () => T, opts?: Opts): () => T;
 export declare function onReadAtom(atom: Atom): void;
@@ -15,3 +16,4 @@ export declare function setSignalHooks(hooks: {
     onDerived: (derived: Derived<any, any>) => void;
 }): void;
 export declare function resetSignalHooks(): void;
+export {};

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

@@ -1,10 +1,11 @@
-import type { Component } from "./component";
-export declare const enum STATUS {
-    NEW = 0,
-    MOUNTED = 1,
-    CANCELLED = 2,
-    DESTROYED = 3
-}
-declare type STATUS_DESCR = "new" | "mounted" | "cancelled" | "destroyed";
-export declare function status(component: Component): STATUS_DESCR;
-export {};
+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/suspense.d.ts

@@ -0,0 +1,5 @@
+import { Component } from "./component";
+export declare function suspenseTemplate(app: any, bdom: any, helpers: any): (ctx: any, node: any, key?: string) => any;
+export declare class Suspense extends Component {
+    static template: string;
+}

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

@@ -1,40 +1,36 @@
-import { compile, Template, TemplateFunction } from "../compiler";
-import { Portal } from "./portal";
-import type { customDirectives } from "../common/types";
-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[];
-    Portal: typeof Portal;
-    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;
-    _compileTemplate(name: string, template: string | Element): ReturnType<typeof compile>;
-    callTemplate(owner: any, subTemplate: string, ctx: any, parent: any, key: any): any;
-}
-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;
-}
+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;
+}