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

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

@@ -1,83 +1,57 @@
-import { Computation } from "../common/types";
-import type { App, Env } from "./app";
-import { BDom, VNode } from "./blockdom";
-import { Component, ComponentConstructor, Props } from "./component";
-import { Fiber, MountFiber, MountOptions } from "./fibers";
-import { PluginManager } from "./plugins";
-import { STATUS } from "./status";
-export declare function saveCurrent(): () => void;
-export declare function getCurrent(): ComponentNode;
-export 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
- */
-export declare function useState<T extends object>(state: T): T;
-declare type LifecycleHook = Function;
-export declare class ComponentNode<P extends Props = any, Plugins = any, E = any> implements VNode<ComponentNode<P, E>> {
-    el?: HTMLElement | Text | undefined;
-    app: App;
-    fiber: Fiber | null;
-    component: Component<P, Plugins, E>;
-    bdom: BDom | null;
-    status: STATUS;
-    forceNextRender: boolean;
-    parentKey: string | null;
-    props: P;
-    nextProps: P | null;
-    renderFn: Function;
-    parent: ComponentNode | null;
-    childEnv: Env;
-    children: {
-        [key: string]: ComponentNode;
-    };
-    refs: any;
-    willStart: LifecycleHook[];
-    willUpdateProps: LifecycleHook[];
-    willUnmount: LifecycleHook[];
-    mounted: LifecycleHook[];
-    willPatch: LifecycleHook[];
-    patched: LifecycleHook[];
-    willDestroy: LifecycleHook[];
-    signalComputation: Computation;
-    pluginManager: PluginManager;
-    constructor(C: ComponentConstructor<P, Plugins, E>, props: P, 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: P, 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;
-    patch(): void;
-    _patch(): void;
-    beforeRemove(): void;
-    remove(): void;
-    get name(): string;
-}
-export {};
+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>;
+    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;
+    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

@@ -0,0 +1,36 @@
+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 +1 @@
-export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => boolean;
+export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;

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

@@ -1,57 +1,32 @@
-import type { Env } from "./app";
-/**
- * The purpose of this hook is to allow components to get a reference to a sub
- * html node or component.
- */
-export 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.
- */
-export 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.
- */
-export declare function useSubEnv(envExtension: Env): void;
-export 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
- * 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<T extends unknown[]>(effect: Effect<T>, computeDependencies?: () => [...T]): 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.
- * It will correctly add and remove the event listener, whenever the
- * component is mounted and unmounted.
- *
- * 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,
- *  `useExternalListener(window, 'click', this._doSomething);`
- * */
-export declare function useExternalListener(target: EventTarget, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
-export {};
+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,35 +1,46 @@
-import { createBlock, html, list, mount as blockMount, multi, patch, remove, text, toggler, comment } from "./blockdom";
-export { Registry } from "./registry";
-export declare const blockDom: {
-    config: {
-        shouldNormalizeDom: boolean;
-        mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => 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 { useComponent, useState } from "./component_node";
-export { status } from "./status";
-export { reactive, markRaw, toRaw } from "./reactivity";
-export { effect, withoutReactivity, derived, signal } from "./signals";
-export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
-export { batched, EventBus, htmlEscape, whenReady, loadFile, markup } from "./utils";
-export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, onWillRender, onRendered, onWillDestroy, onError, } from "./lifecycle_hooks";
-export { validate, validateType } from "./validation";
-export { OwlError } from "../common/owl_error";
-export declare const __info__: {
-    version: string;
-};
-export { Plugin, PluginManager, usePlugins } from "./plugins";
+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,12 +1,10 @@
-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;
-export declare function onWillRender(fn: () => void | any): void;
-export declare function onRendered(fn: () => void | any): void;
-declare type OnErrorCallback = (error: any) => void | any;
-export declare function onError(callback: OnErrorCallback): void;
-export {};
+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/model.d.ts

@@ -0,0 +1,48 @@
+import { Signal } from "./reactivity/signal";
+type MClass<TFields extends Record<string, FieldDef>> = (new (...args: any[]) => Model<TFields>) & StaticModel<TFields>;
+type CharField = {
+    type: "char";
+};
+type NumberField = {
+    type: "number";
+};
+type Many2OneField<C extends MClass<any>> = {
+    type: "many2one";
+    comodel: () => C;
+};
+type FieldDef = CharField | NumberField | Many2OneField<MClass<any>>;
+type FieldValue<F extends FieldDef> = F extends CharField ? Signal<string> : F extends NumberField ? Signal<number> : F extends Many2OneField<infer C> ? Signal<InstanceType<C>> : never;
+type FieldsToData<F extends Record<string, FieldDef>> = {
+    [K in keyof F]: FieldValue<F[K]>;
+};
+type FieldDescription = {
+    type: "char";
+} | {
+    type: "number";
+} | {
+    type: "many2one";
+    comodel: () => MClass<any>;
+};
+export type Fields = Record<string, FieldDescription>;
+interface StaticModel<F extends Record<string, FieldDef>> {
+    fields: F;
+    id: string;
+}
+type R<F extends Record<string, FieldDef>, C extends MClass<F>> = InstanceType<C>;
+export declare class Model<F extends Record<string, FieldDef> = any> {
+    #private;
+    static fields: Fields;
+    readonly id: string;
+    data: FieldsToData<F>;
+    constructor(store: Store, id: string, data?: any);
+    toObject(): Object;
+}
+export declare class Store {
+    #private;
+    static fromObject(obj: any, models: MClass<any>[]): Store;
+    uuid(): string;
+    create<F extends Record<string, FieldDef>, C extends MClass<F>>(M: C, initialState?: any): R<F, C>;
+    toObject(): Object;
+    getAll<F extends Record<string, FieldDef>, C extends MClass<F>>(M: C): R<F, C>[];
+}
+export {};

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

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

@@ -0,0 +1,34 @@
+import { App } from "./app";
+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[];
+    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/plugins.d.ts

@@ -1,39 +1,36 @@
-export interface PluginCtor {
-    new (deps: any): Plugin<any>;
-    id: string;
-    dependencies: string[];
-}
-interface PluginMetaData {
-    isDestroyed: boolean;
-}
-export declare class Plugin<Deps = {
-    [name: string]: Plugin;
-}> {
-    static id: string;
-    static dependencies: string[];
-    readonly plugins: Deps;
-    static resources: {};
-    resources: {
-        [name: string]: any;
-    };
-    __meta__: PluginMetaData;
-    setup(): void;
-    destroy(): void;
-    get isDestroyed(): boolean;
-}
-export declare class PluginManager {
-    _parent: PluginManager | null;
-    _children: PluginManager[];
-    plugins: {
-        [id: string]: Plugin;
-    };
-    resources: {
-        [id: string]: any;
-    };
-    constructor(parent: PluginManager | null, Plugins: PluginCtor[] | (() => PluginCtor[]));
-    destroy(): void;
-    getPlugin(name: string): Plugin | null;
-    getResource(name: string): any[];
-}
-export declare function usePlugins(Plugins: PluginCtor[]): void;
-export {};
+import { Props, WithDefaults } from "./props";
+import { STATUS } from "./status";
+import { GetOptionalEntries } from "./types";
+export interface PluginConstructor {
+    new (): Plugin;
+    id: string;
+}
+export declare class Plugin {
+    private static _shadowId;
+    static get id(): string;
+    static set id(shadowId: string);
+    setup(): void;
+}
+interface PluginManagerOptions {
+    parent?: PluginManager | null;
+    plugins?: PluginConstructor[];
+    pluginProps?: any;
+}
+export declare class PluginManager {
+    static current: PluginManager | null;
+    private children;
+    private parent;
+    private plugins;
+    private onDestroyCb;
+    status: STATUS;
+    constructor(options?: PluginManagerOptions);
+    destroy(): void;
+    getPluginById<T extends Plugin>(id: string): T | null;
+    getPlugin<T extends PluginConstructor>(pluginType: T): InstanceType<T> | null;
+    startPlugins(pluginTypes: PluginConstructor[], pluginProps?: any): Plugin[];
+}
+export declare function plugin<T extends PluginConstructor>(pluginType: T): InstanceType<T>;
+export declare namespace plugin {
+    var props: <P extends Record<string, any> = any, D extends GetOptionalEntries<P> = any>(type?: P, defaults?: D) => Props<WithDefaults<P, D>>;
+}
+export {};

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

@@ -1,15 +1,12 @@
-import { Component } from "./component";
-/**
- * kind of similar to <t t-slot="default"/>, but it wraps it around a VPortal
- */
-export declare function portalTemplate(app: any, bdom: any, helpers: any): (ctx: any, node: any, key?: string) => any;
-export declare class Portal extends Component {
-    static template: string;
-    static props: {
-        readonly target: {
-            readonly type: StringConstructor;
-        };
-        readonly slots: true;
-    };
-    setup(): void;
-}
+import { Component } from "./component";
+/**
+ * kind of similar to <t t-slot="default"/>, but it wraps it around a VPortal
+ */
+export declare function portalTemplate(app: any, bdom: any, helpers: any): (ctx: any, node: any, key?: string) => any;
+export declare class Portal extends Component {
+    static template: string;
+    props: import("./props").Props<{
+        target: string;
+    }>;
+    setup(): void;
+}

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

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

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