@odoo/owl 2.8.1 → 3.0.0-alpha.10

package/dist/types/owl.d.ts

@@ -14,7 +14,7 @@ declare class VToggler {
 }
 declare function toggler(key: string, child: VNode): VNode<VToggler>;
 
-declare type BlockType = (data?: any[], children?: VNode[]) => VNode;
+type BlockType = (data?: any[], children?: VNode[]) => VNode;
 /**
  * Compiling blocks is a multi-step process:
  *
@@ -119,12 +119,54 @@ interface VNode<T = any> {
     isOnlyChild?: boolean | undefined;
     key?: any;
 }
-declare type BDom = VNode<any>;
+type BDom = VNode<any>;
 declare function mount$1(vnode: VNode, fixture: HTMLElement, afterNode?: Node | null): void;
 declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
 declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;
 
-declare type BaseType = {
+declare enum ComputationState {
+    EXECUTED = 0,
+    STALE = 1,
+    PENDING = 2
+}
+type Computation<T = any> = {
+    compute?: () => T;
+    state: ComputationState;
+    sources: Set<Atom | Derived<any, any>>;
+    isEager?: boolean;
+    isDerived?: boolean;
+    value: T;
+    childrenEffect?: Computation[];
+} & Opts;
+type Opts = {
+    name?: string;
+};
+type Atom<T = any> = {
+    value: T;
+    observers: Set<Computation>;
+} & Opts;
+interface Derived<Prev, Next = Prev> extends Atom<Next>, Computation<Next> {
+}
+declare function untrack<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;
+
+type ReactiveValue<T> = () => T;
+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(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;
+}
+declare function signal<T>(value: T, opts?: Opts): Signal<T>;
+
+type BaseType = {
     new (...args: any[]): any;
 } | true | "*";
 interface TypeInfo {
@@ -135,15 +177,15 @@ interface TypeInfo {
     element?: TypeDescription;
     values?: TypeDescription;
 }
-declare type ValueType = {
+type ValueType = {
     value: any;
 };
-declare type TypeDescription = BaseType | TypeInfo | ValueType | TypeDescription[];
-declare type SimplifiedSchema = string[];
-declare type NormalizedSchema = {
+type TypeDescription = BaseType | TypeInfo | ValueType | TypeDescription[];
+type SimplifiedSchema = string[];
+type NormalizedSchema = {
     [key: string]: TypeDescription;
 };
-declare type Schema = SimplifiedSchema | NormalizedSchema;
+type Schema = SimplifiedSchema | NormalizedSchema;
 /**
  * Main validate function
  */
@@ -152,6 +194,67 @@ declare function validate(obj: {
 }, spec: Schema): void;
 declare function validateType(key: string, value: any, descr: TypeDescription): string | null;
 
+declare class Resource<T> {
+    private _items;
+    private _name;
+    private _type?;
+    constructor(name?: string, type?: TypeDescription);
+    items: ReactiveValue<T[]>;
+    add(item: T, sequence?: number): Resource<T>;
+    remove(item: T): Resource<T>;
+    has(item: T): boolean;
+}
+declare function useResource<T>(r: Resource<T>, elements: T[]): void;
+
+declare class Registry<T> {
+    _map: Signal<{
+        [key: string]: [number, T];
+    }>;
+    _name: string;
+    _type?: TypeDescription;
+    constructor(name?: string, type?: TypeDescription);
+    entries: ReactiveValue<[string, T][]>;
+    items: ReactiveValue<T[]>;
+    addById<U extends {
+        id: string;
+    } & T>(item: U, sequence?: number): Registry<T>;
+    add(key: string, value: T, sequence?: number): Registry<T>;
+    get(key: string, defaultValue?: T): T;
+    remove(key: string): void;
+    has(key: string): boolean;
+}
+
+declare const enum STATUS {
+    NEW = 0,
+    MOUNTED = 1,
+    CANCELLED = 2,
+    DESTROYED = 3
+}
+type STATUS_DESCR = "new" | "started" | "mounted" | "cancelled" | "destroyed";
+declare function status(): () => STATUS_DESCR;
+
+interface PluginConstructor {
+    new (): Plugin;
+    id: string;
+}
+declare class Plugin {
+    static id: string;
+    setup(): void;
+}
+declare class PluginManager {
+    private children;
+    private parent;
+    private plugins;
+    private onDestroyCb;
+    status: STATUS;
+    constructor(parent: PluginManager | null);
+    destroy(): void;
+    getPluginById<T extends Plugin>(id: string): T | null;
+    getPlugin<T extends PluginConstructor>(pluginType: T): InstanceType<T> | null;
+    startPlugins(pluginTypes: PluginConstructor[]): Plugin[];
+}
+declare function plugin<T extends PluginConstructor>(pluginType: T): InstanceType<T>;
+
 declare class Fiber {
     node: ComponentNode;
     bdom: BDom | null;
@@ -174,7 +277,7 @@ declare class RootFiber extends Fiber {
     complete(): void;
     setCounter(newValue: number): void;
 }
-declare type Position = "first-child" | "last-child";
+type Position = "first-child" | "last-child";
 interface MountOptions {
     position?: Position;
 }
@@ -185,116 +288,24 @@ declare class MountFiber extends RootFiber {
     complete(): void;
 }
 
-declare type Callback = () => void;
-/**
- * Creates a batched version of a callback so that all calls to it in the same
- * microtick will only call the original callback once.
- *
- * @param callback the callback to batch
- * @returns a batched version of the original callback
- */
-declare function batched(callback: Callback): Callback;
-declare function validateTarget(target: HTMLElement | ShadowRoot): void;
-declare class EventBus extends EventTarget {
-    trigger(name: string, payload?: any): void;
-}
-declare function whenReady(fn?: any): Promise<void>;
-declare function loadFile(url: string): Promise<string>;
-declare class Markup extends String {
-}
-declare function htmlEscape(str: any): Markup;
-declare function markup(strings: TemplateStringsArray, ...placeholders: unknown[]): Markup;
-declare function markup(value: string): Markup;
-
-declare type Target = object;
-declare 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
- */
-declare function markRaw<T extends Target>(value: T): T;
-/**
- * Given a reactive objet, return the raw (non reactive) underlying object
- *
- * @param value a reactive value
- * @returns the underlying value
- */
-declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
-declare function getSubscriptions(callback: Callback): {
-    target: object;
-    keys: (string | number | symbol)[];
-}[];
-/**
- * Creates a reactive proxy for an object. Reading data on the reactive 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 reactive proxy
- * @param callback the function to call when an observed property of the
- *  reactive has changed
- * @returns a proxy that tracks changes to it
- */
-declare function reactive<T extends Target>(target: T, callback?: Callback): T;
-
-declare const enum STATUS {
-    NEW = 0,
-    MOUNTED = 1,
-    CANCELLED = 2,
-    DESTROYED = 3
-}
-declare type STATUS_DESCR = "new" | "mounted" | "cancelled" | "destroyed";
-declare function status(component: Component): STATUS_DESCR;
-
 declare function useComponent(): Component;
-/**
- * Creates a reactive object that will be observed by the current component.
- * Reading data from the returned object (eg during rendering) will cause the
- * component to subscribe to that data and be rerendered when it changes.
- *
- * @param state the state to observe
- * @returns a reactive object that will cause the component to re-render on
- *  relevant changes
- * @see reactive
- */
-declare function useState<T extends object>(state: T): T;
-declare type LifecycleHook = Function;
-declare class ComponentNode<P extends Props = any, E = any> implements VNode<ComponentNode<P, E>> {
+type LifecycleHook = Function;
+declare class ComponentNode implements VNode<ComponentNode> {
     el?: HTMLElement | Text | undefined;
     app: App;
     fiber: Fiber | null;
-    component: Component<P, E>;
+    component: Component;
     bdom: BDom | null;
     status: STATUS;
     forceNextRender: boolean;
     parentKey: string | null;
-    props: P;
-    nextProps: P | null;
+    name: string;
+    props: Record<string, any>;
     renderFn: Function;
     parent: ComponentNode | null;
-    childEnv: Env;
     children: {
         [key: string]: ComponentNode;
     };
-    refs: any;
     willStart: LifecycleHook[];
     willUpdateProps: LifecycleHook[];
     willUnmount: LifecycleHook[];
@@ -302,7 +313,9 @@ declare class ComponentNode<P extends Props = any, E = any> implements VNode<Com
     willPatch: LifecycleHook[];
     patched: LifecycleHook[];
     willDestroy: LifecycleHook[];
-    constructor(C: ComponentConstructor<P, E>, props: P, app: App, parent: ComponentNode | null, parentKey: string | null);
+    signalComputation: Computation;
+    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>;
@@ -310,58 +323,41 @@ declare class ComponentNode<P extends Props = any, E = any> implements VNode<Com
     _cancel(): void;
     destroy(): void;
     _destroy(): void;
-    updateAndRender(props: P, parentFiber: Fiber): Promise<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;
-    /**
-     * Sets a ref to a given HTMLElement.
-     *
-     * @param name the name of the ref to set
-     * @param el the HTMLElement to set the ref to. The ref is not set if the el
-     *  is null, but useRef will not return elements that are not in the DOM
-     */
-    setRef(name: string, el: HTMLElement | null): void;
     firstNode(): Node | undefined;
     mount(parent: HTMLElement, anchor: ChildNode): void;
     moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: ComponentNode<P, E> | null, afterNode: Node | null): void;
+    moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
     patch(): void;
     _patch(): void;
     beforeRemove(): void;
     remove(): void;
-    get name(): string;
-    get subscriptions(): ReturnType<typeof getSubscriptions>;
 }
 
-declare type Props = {
-    [key: string]: any;
-};
 interface StaticComponentProperties {
     template: string;
-    defaultProps?: any;
-    props?: Schema;
     components?: {
         [componentName: string]: ComponentConstructor;
     };
 }
-declare type ComponentConstructor<P extends Props = any, E = any> = (new (props: P, env: E, node: ComponentNode) => Component<P, E>) & StaticComponentProperties;
-declare class Component<Props = any, Env = any> {
+interface ComponentConstructor extends StaticComponentProperties {
+    new (node: ComponentNode): Component;
+}
+declare class Component {
     static template: string;
-    static props?: Schema;
-    static defaultProps?: any;
-    props: Props;
-    env: Env;
     __owl__: ComponentNode;
-    constructor(props: Props, env: Env, node: ComponentNode);
+    constructor(node: ComponentNode);
     setup(): void;
     render(deep?: boolean): void;
 }
 
-declare type ErrorParams = {
+type ErrorParams = {
     error: any;
 } & ({
     node: ComponentNode;
@@ -370,6 +366,51 @@ declare type ErrorParams = {
 });
 declare function handleError(params: ErrorParams): void;
 
+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
+ */
+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
+ */
+declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): 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
+ */
+declare function proxy<T extends Target>(target: T): T;
+
 declare class Scheduler {
     static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
     tasks: Set<RootFiber>;
@@ -390,31 +431,92 @@ declare class Scheduler {
     processFiber(fiber: RootFiber): void;
 }
 
-declare type customDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
-
 interface Config {
     translateFn?: (s: string, translationCtx: string) => string;
     translatableAttributes?: string[];
     dev?: boolean;
 }
 
-declare type Template = (context: any, vnode: any, key?: string) => BDom;
-declare type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
+type CustomDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
+type Template = (context: any, vnode: any, key?: string) => BDom;
+type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
 interface CompileOptions extends Config {
     name?: string;
-    customDirectives?: customDirectives;
+    customDirectives?: CustomDirectives;
     hasGlobalValues: boolean;
 }
 declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
 
+type ConstructorTypedPropsValidation<T = any> = new (...args: any) => T;
+type UnionTypedPropsValidation = ReadonlyArray<TypedPropsValidation>;
+type OptionalSchemaTypedPropsValidation<O extends boolean> = {
+    optional: O;
+};
+type DefaultValuedSchemaTypedPropsValidation<T> = {
+    defaultValue: T;
+};
+type ValidableSchemaTypedPropsValidation = {
+    validate(value: any): boolean;
+};
+type TypeSchemaTypedPropsValidation<T> = {
+    type: new (...args: any) => T;
+};
+type MapSchemaTypedPropsValidation = {
+    type: ObjectConstructor;
+    shape: PropsValidation;
+};
+type RecordSchemaTypedPropsValidation = {
+    type: ObjectConstructor;
+    values: TypedPropsValidation;
+};
+type ArraySchemaTypedPropsValidation = {
+    type: ArrayConstructor;
+    element: TypedPropsValidation;
+};
+type SchemaTypedPropsValidation<T, O extends boolean> = {
+    type?: new (...args: any) => T;
+    optional?: O;
+    defaultValue?: T;
+    validate?(value: T): boolean;
+    shape?: PropsValidation;
+    values?: TypedPropsValidation;
+    element?: TypedPropsValidation;
+};
+type ValueTypedPropsValidation<T = any> = {
+    value: T;
+};
+type TypedPropsValidation = true | ConstructorTypedPropsValidation | UnionTypedPropsValidation | SchemaTypedPropsValidation<any, boolean> | ValueTypedPropsValidation;
+type RecordPropsValidation = Record<string, TypedPropsValidation>;
+type KeysPropsValidation = readonly string[];
+type PropsValidation = RecordPropsValidation | KeysPropsValidation;
+type ConvertTypedPropsValidation<V extends TypedPropsValidation> = V extends true ? any : V extends ConstructorTypedPropsValidation<infer I> ? I : V extends UnionTypedPropsValidation ? V[number] : V extends MapSchemaTypedPropsValidation ? ConvertPropsValidation<V["shape"]> : V extends RecordSchemaTypedPropsValidation ? Record<string, ConvertTypedPropsValidation<V["values"]>> : V extends ArraySchemaTypedPropsValidation ? ConvertTypedPropsValidation<V["element"]>[] : V extends TypeSchemaTypedPropsValidation<infer I> ? I : V extends ValueTypedPropsValidation<infer T> ? T : V extends DefaultValuedSchemaTypedPropsValidation<infer T> ? T : V extends OptionalSchemaTypedPropsValidation<boolean> ? any : V extends ValidableSchemaTypedPropsValidation ? any : never;
+type ConvertPropsValidation<V extends PropsValidation> = V extends KeysPropsValidation ? {
+    [K in V[number] as K extends `${infer N}?` ? N : never]?: any;
+} & {
+    [K in V[number] as K extends `${string}?` ? never : K]: any;
+} : V extends RecordPropsValidation ? {
+    [K in keyof V as V[K] extends OptionalSchemaTypedPropsValidation<true> ? K : never]?: ConvertTypedPropsValidation<V[K]>;
+} & {
+    [K in keyof V as V[K] extends OptionalSchemaTypedPropsValidation<true> ? never : K]: ConvertTypedPropsValidation<V[K]>;
+} : never;
+declare const isProps: unique symbol;
+type IsPropsObj = {
+    [isProps]: true;
+};
+type Props<T, V extends PropsValidation> = IsPropsObj & (unknown extends T ? ConvertPropsValidation<V> : T);
+type GetProps<T extends Component> = {
+    [K in keyof T]: T[K] extends IsPropsObj ? (x: Omit<T[K], typeof isProps>) => void : never;
+}[keyof T] extends (x: infer I) => void ? {
+    [K in keyof I]: I[K];
+} : never;
+declare function props<T = unknown, V extends PropsValidation = PropsValidation>(validation?: V): Props<T, V>;
+
 declare class Portal extends Component {
     static template: string;
-    static props: {
-        readonly target: {
-            readonly type: StringConstructor;
-        };
-        readonly slots: true;
-    };
+    props: Props<unknown, {
+        target: StringConstructor;
+        slots: true;
+    }>;
     setup(): void;
 }
 
@@ -424,7 +526,7 @@ interface TemplateSetConfig {
     translateFn?: (s: string, translationCtx: string) => string;
     templates?: string | Document | Record<string, string>;
     getTemplate?: (s: string) => Element | Function | string | void;
-    customDirectives?: customDirectives;
+    customDirectives?: CustomDirectives;
     globalValues?: object;
 }
 declare class TemplateSet {
@@ -438,7 +540,7 @@ declare class TemplateSet {
     translateFn?: (s: string, translationCtx: string) => string;
     translatableAttributes?: string[];
     Portal: typeof Portal;
-    customDirectives: customDirectives;
+    customDirectives: CustomDirectives;
     runtimeUtils: object;
     hasGlobalValues: boolean;
     constructor(config?: TemplateSetConfig);
@@ -456,17 +558,36 @@ declare namespace xml {
     var nextId: number;
 }
 
-interface Env {
-    [key: string]: any;
+type Callback = () => void;
+/**
+ * Creates a batched version of a callback so that all calls to it in the same
+ * microtick will only call the original callback once.
+ *
+ * @param callback the callback to batch
+ * @returns a batched version of the original callback
+ */
+declare function batched(callback: Callback): Callback;
+declare function validateTarget(target: HTMLElement | ShadowRoot): void;
+declare class EventBus extends EventTarget {
+    trigger(name: string, payload?: any): void;
+}
+declare function whenReady(fn?: any): Promise<void>;
+declare class Markup extends String {
 }
-interface RootConfig<P, E> {
+declare function htmlEscape(str: any): Markup;
+declare function markup(strings: TemplateStringsArray, ...placeholders: unknown[]): Markup;
+declare function markup(value: string): Markup;
+
+type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
+interface RootConfig<P> {
+    pluginManager?: PluginManager;
     props?: P;
-    env?: E;
 }
-interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
+interface AppConfig extends TemplateSetConfig {
     name?: string;
+    plugins?: (typeof Plugin)[];
+    pluginManager?: PluginManager;
     test?: boolean;
-    warnIfNoStaticProps?: boolean;
 }
 declare global {
     interface Window {
@@ -475,65 +596,39 @@ declare global {
             Fiber: typeof Fiber;
             RootFiber: typeof RootFiber;
             toRaw: typeof toRaw;
-            reactive: typeof reactive;
+            proxy: typeof proxy;
         };
     }
 }
-interface Root<P extends Props, E> {
-    node: ComponentNode<P, E>;
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E>>;
+type MountTarget = HTMLElement | ShadowRoot;
+interface Root<T extends ComponentConstructor> {
+    node: ComponentNode;
+    promise: Promise<ComponentInstance<T>>;
+    mount(target: MountTarget, options?: MountOptions): Promise<ComponentInstance<T>>;
     destroy(): void;
 }
-declare class App<T extends abstract new (...args: any) => any = any, P extends object = any, E = any> extends TemplateSet {
+declare class App extends TemplateSet {
     static validateTarget: typeof validateTarget;
-    static apps: Set<App<any, any, any>>;
+    static apps: Set<App>;
     static version: string;
     name: string;
-    Root: ComponentConstructor<P, E>;
-    props: P;
-    env: E;
     scheduler: Scheduler;
-    subRoots: Set<ComponentNode>;
-    root: ComponentNode<P, E> | null;
-    warnIfNoStaticProps: boolean;
-    constructor(Root: ComponentConstructor<P, E>, config?: AppConfig<P, E>);
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>>;
-    createRoot<Props extends object, SubEnv = any>(Root: ComponentConstructor<Props, E>, config?: RootConfig<Props, SubEnv>): Root<Props, SubEnv>;
-    makeNode(Component: ComponentConstructor, props: any): ComponentNode;
-    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, options?: MountOptions): any;
+    roots: Set<Root<any>>;
+    pluginManager: PluginManager;
+    constructor(config?: AppConfig);
+    createRoot<T extends ComponentConstructor>(Root: T, config?: RootConfig<GetProps<ComponentInstance<T>>>): Root<T>;
+    makeNode<T extends ComponentConstructor>(Component: T, props: GetProps<ComponentInstance<T>>): ComponentNode;
+    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, resolve: (c: any) => void, reject: (e: any) => void, options?: MountOptions): void;
     destroy(): void;
-    createComponent<P extends Props>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+    createComponent<P extends Record<string, any>>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
     handleError(...args: Parameters<typeof handleError>): void;
 }
-declare function mount<T extends abstract new (...args: any) => any = any, P extends object = any, E = any>(C: T & ComponentConstructor<P, E>, target: HTMLElement, config?: AppConfig<P, E> & MountOptions): Promise<Component<P, E> & InstanceType<T>>;
+declare function mount<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
+
+declare function computed<T>(fn: () => T, opts?: Opts): ReactiveValue<T>;
+
+declare function effect<T>(fn: () => T, opts?: Opts): () => void;
 
-/**
- * The purpose of this hook is to allow components to get a reference to a sub
- * html node or component.
- */
-declare function useRef<T extends HTMLElement = HTMLElement>(name: string): {
-    el: T | null;
-};
-/**
- * This hook is useful as a building block for some customized hooks, that may
- * need a reference to the env of the component calling them.
- */
-declare function useEnv<E extends Env>(): E;
-/**
- * This hook is a simple way to let components use a sub environment.  Note that
- * like for all hooks, it is important that this is only called in the
- * constructor method.
- */
-declare function useSubEnv(envExtension: Env): void;
-declare function useChildSubEnv(envExtension: Env): void;
-declare type EffectDeps<T extends unknown[]> = T | (T extends [...infer H, never] ? EffectDeps<H> : never);
-/**
- * @template T
- * @param {...T} dependencies the dependencies computed by computeDependencies
- * @returns {void|(()=>void)} a cleanup function that reverses the side
- *      effects of the effect callback.
- */
-declare type Effect<T extends unknown[]> = (...dependencies: EffectDeps<T>) => void | (() => void);
 /**
  * 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
@@ -547,10 +642,10 @@ declare type Effect<T extends unknown[]> = (...dependencies: EffectDeps<T>) => v
  *      again. The default value returns an array containing only NaN because
  *      NaN !== NaN, which will cause the effect to rerun on every patch.
  */
-declare function useEffect<T extends unknown[]>(effect: Effect<T>, computeDependencies?: () => [...T]): void;
+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 `useExternalListener` hook.
+ * part of his hierarchy, we can use the `useListener` hook.
  * It will correctly add and remove the event listener, whenever the
  * component is mounted and unmounted.
  *
@@ -559,9 +654,10 @@ declare function useEffect<T extends unknown[]>(effect: Effect<T>, computeDepend
  *
  * Usage:
  *  in the constructor of the OWL component that needs to be notified,
- *  `useExternalListener(window, 'click', this._doSomething);`
+ *  `useListener(window, 'click', this._doSomething);`
  * */
-declare function useExternalListener(target: EventTarget, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
+declare function useListener(target: EventTarget, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
+declare function usePlugins(Plugins: PluginConstructor[]): Plugin[];
 
 declare function onWillStart(fn: () => Promise<void> | void | any): void;
 declare function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any): void;
@@ -570,9 +666,7 @@ declare function onWillPatch(fn: () => any | void): void;
 declare function onPatched(fn: () => void | any): void;
 declare function onWillUnmount(fn: () => void | any): void;
 declare function onWillDestroy(fn: () => void | any): void;
-declare function onWillRender(fn: () => void | any): void;
-declare function onRendered(fn: () => void | any): void;
-declare type OnErrorCallback = (error: any) => void | any;
+type OnErrorCallback = (error: any) => void | any;
 declare function onError(callback: OnErrorCallback): void;
 
 declare class OwlError extends Error {
@@ -600,4 +694,4 @@ declare const __info__: {
     version: string;
 };
 
-export { App, Component, ComponentConstructor, EventBus, OwlError, __info__, batched, blockDom, htmlEscape, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, useRef, useState, useSubEnv, validate, validateType, whenReady, xml };
+export { App, Component, ComponentConstructor, EventBus, GetProps, OwlError, Plugin, PluginConstructor, PluginManager, PropsValidation, ReactiveValue, Registry, Resource, Signal, __info__, batched, blockDom, computed, effect, htmlEscape, markRaw, markup, mount, onError, onMounted, onPatched, onWillDestroy, onWillPatch, onWillStart, onWillUnmount, onWillUpdateProps, plugin, props, proxy, signal, status, toRaw, untrack, useComponent, useEffect, useListener, usePlugins, useResource, validate, validateType, whenReady, xml };