@odoo/owl 3.0.0-alpha.26 → 3.0.0-alpha.29

package/dist/types/common/owl_error.d.ts

@@ -1,3 +0,0 @@
-export declare class OwlError extends Error {
-    cause?: any;
-}

package/dist/types/common/utils.d.ts

@@ -1,8 +0,0 @@
-/**
- * Parses an XML string into an XML document, throwing errors on parser errors
- * instead of returning an XML document containing the parseerror.
- *
- * @param xml the string to parse
- * @returns an XML document corresponding to the content of the string
- */
-export declare function parseXML(xml: string): XMLDocument;

package/dist/types/compiler/code_generator.d.ts

@@ -1,134 +0,0 @@
-import { AST, ASTComment, ASTComponent, ASTDebug, ASTDomNode, ASTLog, ASTMulti, ASTTCall, ASTTCallBlock, ASTTCallSlot, ASTText, ASTTForEach, ASTTif, ASTTKey, ASTTOut, ASTTranslation, ASTTranslationContext, ASTTSet, EventHandlers } from "./parser";
-type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
-export interface Config {
-    translateFn?: (s: string, translationCtx: string) => string;
-    translatableAttributes?: string[];
-    dev?: boolean;
-}
-interface CodeGenOptions extends Config {
-    name?: string;
-    hasGlobalValues: boolean;
-}
-declare class BlockDescription {
-    static nextBlockId: number;
-    varName: string;
-    blockName: string;
-    dynamicTagName: string | null;
-    isRoot: boolean;
-    hasDynamicChildren: boolean;
-    children: BlockDescription[];
-    data: string[];
-    dom?: Node;
-    currentDom?: Element;
-    childNumber: number;
-    target: CodeTarget;
-    type: BlockType;
-    parentVar: string;
-    id: number;
-    constructor(target: CodeTarget, type: BlockType);
-    insertData(str: string, prefix?: string): number;
-    insert(dom: Node): void;
-    generateExpr(expr: string): string;
-    asXmlString(): string;
-}
-interface Context {
-    block: BlockDescription | null;
-    index: number | string;
-    forceNewBlock: boolean;
-    translate: boolean;
-    translationCtx: string;
-    tKeyExpr: string | null;
-    nameSpace?: string;
-    tModelSelectedExpr?: string;
-    inPreTag?: boolean;
-}
-declare class CodeTarget {
-    name: string;
-    indentLevel: number;
-    loopLevel: number;
-    loopCtxVars: string[];
-    tSetVars: Map<string, number>;
-    code: string[];
-    hasRoot: boolean;
-    deferReturn: boolean;
-    needsScopeProtection: boolean;
-    on: EventHandlers | null;
-    constructor(name: string, on?: EventHandlers | null);
-    addLine(line: string, idx?: number): void;
-    generateCode(): string;
-    currentKey(ctx: Context): string;
-}
-export declare class CodeGenerator {
-    blocks: BlockDescription[];
-    nextBlockId: number;
-    isDebug: boolean;
-    targets: CodeTarget[];
-    target: CodeTarget;
-    templateName?: string;
-    dev: boolean;
-    translateFn: (s: string, translationCtx: string) => string;
-    translatableAttributes: string[];
-    ast: AST;
-    staticDefs: {
-        id: string;
-        expr: string;
-    }[];
-    slotNames: Set<String | Symbol>;
-    helpers: Set<string>;
-    constructor(ast: AST, options: CodeGenOptions);
-    generateCode(): string;
-    compileInNewTarget(prefix: string, ast: AST, ctx: Context, on?: EventHandlers | null): string;
-    addLine(line: string, idx?: number): void;
-    define(varName: string, expr: string): void;
-    insertAnchor(block: BlockDescription, index?: number): void;
-    createBlock(parentBlock: BlockDescription | null, type: BlockType, ctx: Context): BlockDescription;
-    insertBlock(expression: string, block: BlockDescription, ctx: Context): void;
-    translate(str: string, translationCtx: string): string;
-    /**
-     * @returns the newly created block name, if any
-     */
-    compileAST(ast: AST, ctx: Context): string | null;
-    compileDebug(ast: ASTDebug, ctx: Context): string | null;
-    compileLog(ast: ASTLog, ctx: Context): string | null;
-    compileComment(ast: ASTComment, ctx: Context): string;
-    compileText(ast: ASTText, ctx: Context): string;
-    generateHandlerCode(rawEvent: string, handler: string): string;
-    compileTDomNode(ast: ASTDomNode, ctx: Context): string;
-    compileZero(): string;
-    compileTOut(ast: ASTTOut, ctx: Context): string;
-    compileTIfBranch(content: AST, block: BlockDescription, ctx: Context): void;
-    compileTIf(ast: ASTTif, ctx: Context, nextNode?: ASTDomNode): string;
-    compileTForeach(ast: ASTTForEach, ctx: Context): string;
-    compileTKey(ast: ASTTKey, ctx: Context): string | null;
-    compileMulti(ast: ASTMulti, ctx: Context): string | null;
-    compileTCall(ast: ASTTCall, ctx: Context): string;
-    compileTCallBlock(ast: ASTTCallBlock, ctx: Context): string;
-    compileTSet(ast: ASTTSet, ctx: Context): null;
-    generateComponentKey(currentKey?: string): string;
-    /**
-     * Formats a prop name and value into a string suitable to be inserted in the
-     * generated code. For example:
-     *
-     * Name              Value            Result
-     * ---------------------------------------------------------
-     * "number"          "state"          "number: ctx['state']"
-     * "something"       ""               "something: undefined"
-     * "some-prop"       "state"          "'some-prop': ctx['state']"
-     * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
-     */
-    formatProp(name: string, value: string, attrsTranslationCtx: {
-        [name: string]: string;
-    } | null, translationCtx: string): string;
-    formatPropObject(obj: {
-        [prop: string]: any;
-    }, attrsTranslationCtx: {
-        [name: string]: string;
-    } | null, translationCtx: string): string[];
-    getPropString(props: string[], dynProps: string | null): string;
-    compileComponent(ast: ASTComponent, ctx: Context): string;
-    wrapWithEventCatcher(expr: string, on: EventHandlers): string;
-    compileTCallSlot(ast: ASTTCallSlot, ctx: Context): string;
-    compileTTranslation(ast: ASTTranslation, ctx: Context): string | null;
-    compileTTranslationContext(ast: ASTTranslationContext, ctx: Context): string | null;
-}
-export {};

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

@@ -1,13 +0,0 @@
-import type { BDom } from "../runtime/blockdom";
-import type { TemplateSet } from "../runtime/template_set";
-import { Config } from "./code_generator";
-export type CustomDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
-export type Template = (context: any, vnode: any, key?: string) => BDom;
-export type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
-interface CompileOptions extends Config {
-    name?: string;
-    customDirectives?: CustomDirectives;
-    hasGlobalValues: boolean;
-}
-export declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
-export {};

package/dist/types/compiler/inline_expressions.d.ts

@@ -1,35 +0,0 @@
-type TKind = "LEFT_BRACE" | "RIGHT_BRACE" | "LEFT_BRACKET" | "RIGHT_BRACKET" | "LEFT_PAREN" | "RIGHT_PAREN" | "COMMA" | "VALUE" | "TEMPLATE_STRING" | "SYMBOL" | "OPERATOR" | "COLON";
-interface Token {
-    type: TKind;
-    value: string;
-    originalValue?: string;
-    size?: number;
-    varName?: string;
-    replace?: Function;
-    isLocal?: boolean;
-}
-/**
- * Convert a javascript expression (as a string) into a list of tokens. For
- * example: `tokenize("1 + b")` will return:
- * ```js
- *  [
- *   {type: "VALUE", value: "1"},
- *   {type: "OPERATOR", value: "+"},
- *   {type: "SYMBOL", value: "b"}
- * ]
- * ```
- */
-export declare function tokenize(expr: string): Token[];
-interface ProcessedExpr {
-    expr: string;
-    freeVariables: string[] | null;
-}
-/**
- * Processes a javascript expression: compiles variable lookups and detects
- * top-level arrow functions with their free variables, all in a single pass.
- */
-export declare function processExpr(expr: string): ProcessedExpr;
-export declare function compileExpr(expr: string): string;
-export declare const INTERP_REGEXP: RegExp;
-export declare function interpolate(s: string): string;
-export {};

package/dist/types/compiler/parser.d.ts

@@ -1,170 +0,0 @@
-import { CustomDirectives } from ".";
-export type EventHandlers = {
-    [eventName: string]: string;
-};
-export type Attrs = {
-    [attrs: string]: string;
-};
-export declare const enum ASTType {
-    Text = 0,
-    Comment = 1,
-    DomNode = 2,
-    Multi = 3,
-    TIf = 4,
-    TSet = 5,
-    TCall = 6,
-    TOut = 7,
-    TForEach = 8,
-    TKey = 9,
-    TComponent = 10,
-    TDebug = 11,
-    TLog = 12,
-    TCallSlot = 13,
-    TCallBlock = 14,
-    TTranslation = 15,
-    TTranslationContext = 16
-}
-interface BaseAST {
-    type: ASTType;
-    hasNoRepresentation?: true;
-}
-export interface ASTText extends BaseAST {
-    type: ASTType.Text;
-    value: string;
-}
-export interface ASTComment extends BaseAST {
-    type: ASTType.Comment;
-    value: string;
-}
-interface TModelInfo {
-    expr: string;
-    targetAttr: string;
-    eventType: "change" | "click" | "input";
-    shouldTrim: boolean;
-    shouldNumberize: boolean;
-    hasDynamicChildren: boolean;
-    specialInitTargetAttr: string | null;
-    isProxy: boolean;
-}
-export interface ASTDomNode extends BaseAST {
-    type: ASTType.DomNode;
-    tag: string;
-    content: AST[];
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-    ref: string | null;
-    on: EventHandlers | null;
-    model: TModelInfo | null;
-    dynamicTag: string | null;
-    ns: string | null;
-}
-export interface ASTMulti extends BaseAST {
-    type: ASTType.Multi;
-    content: AST[];
-}
-export interface ASTTOut extends BaseAST {
-    type: ASTType.TOut;
-    expr: string;
-    body: AST[] | null;
-}
-export interface ASTTif extends BaseAST {
-    type: ASTType.TIf;
-    condition: string;
-    content: AST;
-    tElif: {
-        condition: string;
-        content: AST;
-    }[] | null;
-    tElse: AST | null;
-}
-export interface ASTTSet extends BaseAST {
-    type: ASTType.TSet;
-    name: string;
-    value: string | null;
-    defaultValue: string | null;
-    body: AST[] | null;
-    hasNoRepresentation: true;
-}
-export declare const enum ForEachNoFlag {
-    First = 1,
-    Last = 2,
-    Index = 4,
-    Value = 8
-}
-export interface ASTTForEach extends BaseAST {
-    type: ASTType.TForEach;
-    collection: string;
-    elem: string;
-    body: AST;
-    noFlags: number;
-    key: string | null;
-}
-export interface ASTTKey extends BaseAST {
-    type: ASTType.TKey;
-    expr: string;
-    content: AST;
-}
-export interface ASTTCall extends BaseAST {
-    type: ASTType.TCall;
-    name: string;
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-    body: AST | null;
-    context: string | null;
-}
-interface SlotDefinition {
-    content: AST | null;
-    scope: string | null;
-    on: EventHandlers | null;
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-}
-export interface ASTComponent extends BaseAST {
-    type: ASTType.TComponent;
-    name: string;
-    isDynamic: boolean;
-    dynamicProps: string | null;
-    on: EventHandlers | null;
-    props: {
-        [name: string]: string;
-    } | null;
-    propsTranslationCtx: {
-        [name: string]: string;
-    } | null;
-    slots: {
-        [name: string]: SlotDefinition;
-    } | null;
-}
-export interface ASTTCallSlot extends BaseAST {
-    type: ASTType.TCallSlot;
-    name: string;
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-    on: EventHandlers | null;
-    defaultContent: AST | null;
-}
-export interface ASTTCallBlock extends BaseAST {
-    type: ASTType.TCallBlock;
-    name: string;
-}
-export interface ASTDebug extends BaseAST {
-    type: ASTType.TDebug;
-    content: AST | null;
-}
-export interface ASTLog extends BaseAST {
-    type: ASTType.TLog;
-    expr: string;
-    content: AST | null;
-}
-export interface ASTTranslation extends BaseAST {
-    type: ASTType.TTranslation;
-    content: AST | null;
-}
-export interface ASTTranslationContext extends BaseAST {
-    type: ASTType.TTranslationContext;
-    content: AST | null;
-    translationCtx: string;
-}
-export type AST = ASTText | ASTComment | ASTDomNode | ASTMulti | ASTTif | ASTTSet | ASTTCall | ASTTOut | ASTTForEach | ASTTKey | ASTComponent | ASTTCallSlot | ASTTCallBlock | ASTLog | ASTDebug | ASTTranslation | ASTTranslationContext;
-export declare function parse(xml: string | Element, customDir?: CustomDirectives): AST;
-export {};

package/dist/types/compiler/standalone/index.d.ts

@@ -1,2 +0,0 @@
-import "./setup_jsdom";
-export declare function compileTemplates(paths: string[]): Promise<string>;

package/dist/types/compiler/standalone/setup_jsdom.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/index.d.ts

@@ -1 +0,0 @@
-export * from "./runtime";

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

@@ -1,53 +0,0 @@
-import { ComponentConstructor } from "./component";
-import { ComponentNode } from "./component_node";
-import { PluginConstructor, PluginManager } from "./plugin_manager";
-import { GetProps } from "./props";
-import { proxy, toRaw } from "./reactivity/proxy";
-import { Fiber, MountOptions, RootFiber } from "./rendering/fibers";
-import { Scheduler } from "./rendering/scheduler";
-import { Resource } from "./resource";
-import { TemplateSet, TemplateSetConfig } from "./template_set";
-import { validateTarget } from "./utils";
-type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
-interface RootConfig<P> {
-    props?: P;
-}
-export interface AppConfig extends TemplateSetConfig {
-    name?: string;
-    plugins?: PluginConstructor[] | Resource<PluginConstructor>;
-    config?: Record<string, any>;
-    test?: boolean;
-}
-declare global {
-    interface Window {
-        __OWL_DEVTOOLS__: {
-            apps: Set<App>;
-            Fiber: typeof Fiber;
-            RootFiber: typeof RootFiber;
-            toRaw: typeof toRaw;
-            proxy: typeof proxy;
-        };
-    }
-}
-import type { MountTarget } from "./blockdom";
-interface Root<T extends ComponentConstructor> {
-    node: ComponentNode;
-    promise: Promise<ComponentInstance<T>>;
-    mount(target: MountTarget, options?: MountOptions): Promise<ComponentInstance<T>>;
-    destroy(): void;
-}
-export declare class App extends TemplateSet {
-    static validateTarget: typeof validateTarget;
-    static apps: Set<App>;
-    static version: string;
-    name: string;
-    scheduler: Scheduler;
-    roots: Set<Root<any>>;
-    pluginManager: PluginManager;
-    constructor(config?: AppConfig);
-    createRoot<T extends ComponentConstructor>(Root: T, config?: RootConfig<GetProps<ComponentInstance<T>>>): Root<T>;
-    destroy(): void;
-    _handleError(error: any): void;
-}
-export declare function mount<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
-export {};

package/dist/types/runtime/blockdom/attributes.d.ts

@@ -1,8 +0,0 @@
-import type { Setter } from "./block_compiler";
-export declare function createAttrUpdater(attr: string): Setter<HTMLElement>;
-export declare function attrsSetter(this: HTMLElement, attrs: any): void;
-export declare function attrsUpdater(this: HTMLElement, attrs: any, oldAttrs: any): void;
-export declare function setClass(this: HTMLElement, val: any): void;
-export declare function updateClass(this: HTMLElement, val: any, oldVal: any): void;
-export declare function setStyle(this: HTMLElement, val: any): void;
-export declare function updateStyle(this: HTMLElement, val: any, oldVal: any): void;

package/dist/types/runtime/blockdom/block_compiler.d.ts

@@ -1,20 +0,0 @@
-import type { VNode } from "./index";
-type BlockType = (data?: any[], children?: VNode[]) => VNode;
-/**
- * Compiling blocks is a multi-step process:
- *
- * 1. build an IntermediateTree from the HTML element. This intermediate tree
- *    is a binary tree structure that encode dynamic info sub nodes, and the
- *    path required to reach them
- * 2. process the tree to build a block context, which is an object that aggregate
- *    all dynamic info in a list, and also, all ref indexes.
- * 3. process the context to build appropriate builder/setter functions
- * 4. make a dynamic block class, which will efficiently collect references and
- *    create/update dynamic locations/children
- *
- * @param str
- * @returns a new block type, that can build concrete blocks
- */
-export declare function createBlock(str: string): BlockType;
-export type Setter<T = any> = (this: T, value: any) => void;
-export {};

package/dist/types/runtime/blockdom/config.d.ts

@@ -1,8 +0,0 @@
-export declare function filterOutModifiersFromData(dataList: any[]): {
-    modifiers: string[];
-    data: any[];
-};
-export declare const config: {
-    shouldNormalizeDom: boolean;
-    mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
-};

package/dist/types/runtime/blockdom/event_catcher.d.ts

@@ -1,7 +0,0 @@
-import type { VNode } from "./index";
-type EventsSpec = {
-    [name: string]: number;
-};
-type Catcher = (child: VNode, handlers: any[]) => VNode;
-export declare function createCatcher(eventsSpec: EventsSpec): Catcher;
-export {};

package/dist/types/runtime/blockdom/events.d.ts

@@ -1,8 +0,0 @@
-type EventHandlerSetter = (this: HTMLElement, data: any) => void;
-interface EventHandlerCreator {
-    setup: EventHandlerSetter;
-    update: EventHandlerSetter;
-    remove: (this: HTMLElement) => void;
-}
-export declare function createEventHandler(rawEvent: string): EventHandlerCreator;
-export {};

package/dist/types/runtime/blockdom/html.d.ts

@@ -1,17 +0,0 @@
-import type { VNode } from "./index";
-declare class VHtml {
-    html: string;
-    parentEl?: HTMLElement | undefined;
-    content: ChildNode[];
-    constructor(html: string);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VHtml | null, afterNode: Node | null): void;
-    patch(other: VHtml): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node;
-    toString(): string;
-}
-export declare function html(str: string): VNode<VHtml>;
-export {};

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

@@ -1,26 +0,0 @@
-export { config } from "./config";
-export { toggler } from "./toggler";
-export { createBlock } from "./block_compiler";
-export { list } from "./list";
-export { multi } from "./multi";
-export { text, comment } from "./text";
-export { html } from "./html";
-export { createCatcher } from "./event_catcher";
-export type MountTarget = HTMLElement | ShadowRoot;
-export interface VNode<T = any> {
-    mount(parent: MountTarget, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: MountTarget): void;
-    moveBeforeVNode(other: T | null, afterNode: Node | null): void;
-    patch(other: T, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    el?: undefined | HTMLElement | Text;
-    parentEl?: undefined | HTMLElement;
-    isOnlyChild?: boolean | undefined;
-    key?: any;
-}
-export type BDom = VNode<any>;
-export declare function mount(vnode: VNode, fixture: MountTarget, afterNode?: Node | null): void;
-export declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
-export declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;

package/dist/types/runtime/blockdom/list.d.ts

@@ -1,18 +0,0 @@
-import type { VNode } from "./index";
-declare class VList {
-    children: VNode[];
-    anchor: Node | undefined;
-    parentEl?: HTMLElement | undefined;
-    isOnlyChild?: boolean | undefined;
-    constructor(children: VNode[]);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VList | null, afterNode: Node | null): void;
-    patch(other: VList, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function list(children: VNode[]): VNode<VList>;
-export {};

package/dist/types/runtime/blockdom/multi.d.ts

@@ -1,17 +0,0 @@
-import type { VNode } from "./index";
-export declare class VMulti {
-    children: (VNode | undefined)[];
-    anchors?: Node[] | undefined;
-    parentEl?: HTMLElement | undefined;
-    isOnlyChild?: boolean | undefined;
-    constructor(children: (VNode | undefined)[]);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VMulti | null, afterNode: Node | null): void;
-    patch(other: VMulti, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function multi(children: (VNode | undefined)[]): VNode<VMulti>;

package/dist/types/runtime/blockdom/text.d.ts

@@ -1,26 +0,0 @@
-import type { VNode } from "./index";
-declare abstract class VSimpleNode {
-    text: string | String;
-    parentEl?: HTMLElement | undefined;
-    el?: any;
-    constructor(text: string | String);
-    mountNode(node: Node, parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VText | null, afterNode: Node | null): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node;
-    toString(): string | String;
-}
-declare class VText extends VSimpleNode {
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    patch(other: VText): void;
-}
-declare class VComment extends VSimpleNode {
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    patch(): void;
-}
-export declare function text(str: string | String): VNode<VText>;
-export declare function comment(str: string): VNode<VComment>;
-export declare function toText(value: any): string;
-export {};

package/dist/types/runtime/blockdom/toggler.d.ts

@@ -1,17 +0,0 @@
-import type { VNode } from "./index";
-declare class VToggler {
-    key: string;
-    child: VNode;
-    parentEl?: HTMLElement | undefined;
-    constructor(key: string, child: VNode);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: VToggler | null, afterNode: Node | null): void;
-    patch(other: VToggler, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function toggler(key: string, child: VNode): VNode<VToggler>;
-export {};

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

@@ -1,17 +0,0 @@
-import type { ComponentNode } from "./component_node";
-interface StaticComponentProperties {
-    template: string;
-    components?: {
-        [componentName: string]: ComponentConstructor;
-    };
-}
-export interface ComponentConstructor extends StaticComponentProperties {
-    new (node: ComponentNode): Component;
-}
-export declare class Component {
-    static template: string;
-    __owl__: ComponentNode;
-    constructor(node: ComponentNode);
-    setup(): void;
-}
-export {};