@odoo/owl 2.8.1 → 3.0.0-alpha.2

package/dist/types/owl.d.ts

@@ -152,6 +152,45 @@ declare function validate(obj: {
 }, spec: Schema): void;
 declare function validateType(key: string, value: any, descr: TypeDescription): string | null;
 
+declare type Fn<T> = () => T;
+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;
+}
+
+declare type customDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
+declare enum ComputationState {
+    EXECUTED = 0,
+    STALE = 1,
+    PENDING = 2
+}
+declare type Computation<T = any> = {
+    compute?: () => T;
+    state: ComputationState;
+    sources: Set<Atom | Derived<any, any>>;
+    isEager?: boolean;
+    isDerived?: boolean;
+    value: T;
+    childrenEffect?: Computation[];
+} & Opts;
+declare type Opts = {
+    name?: string;
+};
+declare type Atom<T = any> = {
+    value: T;
+    observers: Set<Computation>;
+} & Opts;
+interface Derived<Prev, Next = Prev> extends Atom<Next>, Computation<Next> {
+}
+
 declare class Fiber {
     node: ComponentNode;
     bdom: BDom | null;
@@ -185,75 +224,44 @@ 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;
+interface PluginCtor {
+    new (deps: any): Plugin<any>;
+    id: string;
+    dependencies: string[];
 }
-declare function whenReady(fn?: any): Promise<void>;
-declare function loadFile(url: string): Promise<string>;
-declare class Markup extends String {
+interface PluginMetaData {
+    isDestroyed: boolean;
 }
-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 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;
+}
+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[];
+}
+declare function usePlugins(Plugins: PluginCtor[]): void;
 
 declare const enum STATUS {
     NEW = 0,
@@ -277,11 +285,11 @@ declare function useComponent(): Component;
  */
 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>> {
+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, E>;
+    component: Component<P, Plugins, E>;
     bdom: BDom | null;
     status: STATUS;
     forceNextRender: boolean;
@@ -302,7 +310,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<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>;
@@ -334,7 +344,6 @@ declare class ComponentNode<P extends Props = any, E = any> implements VNode<Com
     beforeRemove(): void;
     remove(): void;
     get name(): string;
-    get subscriptions(): ReturnType<typeof getSubscriptions>;
 }
 
 declare type Props = {
@@ -348,15 +357,16 @@ interface StaticComponentProperties {
         [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> {
+declare type ComponentConstructor<P extends Props = any, Plugins = any, E = any> = (new (props: P, env: E, plugins: Plugins, node: ComponentNode) => Component<P, Plugins, E>) & StaticComponentProperties;
+declare class Component<Props = any, Plugins = PluginManager["plugins"], Env = any> {
     static template: string;
     static props?: Schema;
     static defaultProps?: any;
     props: Props;
     env: Env;
+    plugins: Plugins;
     __owl__: ComponentNode;
-    constructor(props: Props, env: Env, node: ComponentNode);
+    constructor(props: Props, env: Env, plugins: Plugins, node: ComponentNode);
     setup(): void;
     render(deep?: boolean): void;
 }
@@ -390,8 +400,6 @@ 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[];
@@ -456,12 +464,79 @@ declare namespace xml {
     var nextId: number;
 }
 
+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;
+/**
+ * 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): T;
+
 interface Env {
     [key: string]: any;
 }
 interface RootConfig<P, E> {
     props?: P;
     env?: E;
+    Plugins?: PluginCtor[];
 }
 interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
     name?: string;
@@ -496,6 +571,7 @@ declare class App<T extends abstract new (...args: any) => any = any, P extends
     subRoots: Set<ComponentNode>;
     root: ComponentNode<P, E> | null;
     warnIfNoStaticProps: boolean;
+    pluginManager: PluginManager;
     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>;
@@ -507,6 +583,14 @@ declare class App<T extends abstract new (...args: any) => any = any, P extends
 }
 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 signal<T>(value: T, opts?: Opts): {
+    readonly get: () => T;
+    readonly set: (newValue: T | ((prevValue: T) => T)) => void;
+};
+declare function effect<T>(fn: () => T, opts?: Opts): () => void;
+declare function derived<T>(fn: () => T, opts?: Opts): () => T;
+declare function withoutReactivity<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;
+
 /**
  * The purpose of this hook is to allow components to get a reference to a sub
  * html node or component.
@@ -600,4 +684,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, OwlError, Plugin, PluginManager, Registry, __info__, batched, blockDom, derived, effect, htmlEscape, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, signal, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, usePlugins, useRef, useState, useSubEnv, validate, validateType, whenReady, withoutReactivity, xml };

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

@@ -6,12 +6,14 @@ import { Scheduler } from "./scheduler";
 import { TemplateSet, TemplateSetConfig } from "./template_set";
 import { validateTarget } from "./utils";
 import { toRaw, reactive } from "./reactivity";
+import { PluginCtor, PluginManager } from "./plugins";
 export interface Env {
     [key: string]: any;
 }
 export interface RootConfig<P, E> {
     props?: P;
     env?: E;
+    Plugins?: PluginCtor[];
 }
 export interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
     name?: string;
@@ -46,6 +48,7 @@ export declare class App<T extends abstract new (...args: any) => any = any, P e
     subRoots: Set<ComponentNode>;
     root: ComponentNode<P, E> | null;
     warnIfNoStaticProps: boolean;
+    pluginManager: PluginManager;
     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>;

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

@@ -0,0 +1,15 @@
+export declare type TaskContext = {
+    isCancelled: boolean;
+    cancel: () => void;
+    meta: Record<string, any>;
+};
+export declare const taskContextStack: TaskContext[];
+export declare function getTaskContext(): TaskContext;
+export declare function makeTaskContext(): TaskContext;
+export declare function useTaskContext(ctx?: TaskContext): {
+    ctx: TaskContext;
+    cleanup: () => void;
+};
+export declare function pushTaskContext(context: TaskContext): void;
+export declare function popTaskContext(): void;
+export declare function taskEffect(fn: Function): TaskContext;

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

@@ -0,0 +1,15 @@
+export declare type PromiseExecContext = {
+    cancelled: boolean;
+};
+export declare type CancellablePromise<T = any> = Promise<T> & {
+    execContext?: PromiseExecContext;
+};
+export declare const setCancellableContext: (ctx: PromiseExecContext | undefined) => PromiseExecContext | undefined;
+export declare const resetCancellableContext: (ctx: PromiseExecContext | undefined) => void;
+export declare const _exec: (execContext: PromiseExecContext | undefined, cb: Function, args: any[]) => any;
+export declare function patchPromise(): void;
+export declare function restorePromise(): void;
+export declare function getCancellableTask(cb: Function): {
+    cancel: () => boolean;
+    readonly isCancel: boolean;
+};

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

@@ -1,5 +1,6 @@
 import { Schema } from "./validation";
 import type { ComponentNode } from "./component_node";
+import type { PluginManager } from "./plugins";
 export declare type Props = {
     [key: string]: any;
 };
@@ -11,15 +12,16 @@ interface StaticComponentProperties {
         [componentName: string]: ComponentConstructor;
     };
 }
-export declare type ComponentConstructor<P extends Props = any, E = any> = (new (props: P, env: E, node: ComponentNode) => Component<P, E>) & StaticComponentProperties;
-export declare class Component<Props = any, Env = any> {
+export declare type ComponentConstructor<P extends Props = any, Plugins = any, E = any> = (new (props: P, env: E, plugins: Plugins, node: ComponentNode) => Component<P, Plugins, E>) & StaticComponentProperties;
+export declare class Component<Props = any, Plugins = PluginManager["plugins"], Env = any> {
     static template: string;
     static props?: Schema;
     static defaultProps?: any;
     props: Props;
     env: Env;
+    plugins: Plugins;
     __owl__: ComponentNode;
-    constructor(props: Props, env: Env, node: ComponentNode);
+    constructor(props: Props, env: Env, plugins: Plugins, node: ComponentNode);
     setup(): void;
     render(deep?: boolean): void;
 }

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

@@ -1,8 +1,9 @@
+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 { getSubscriptions } from "./reactivity";
+import { PluginManager } from "./plugins";
 import { STATUS } from "./status";
 export declare function saveCurrent(): () => void;
 export declare function getCurrent(): ComponentNode;
@@ -19,11 +20,11 @@ export declare function useComponent(): Component;
  */
 export declare function useState<T extends object>(state: T): T;
 declare type LifecycleHook = Function;
-export declare class ComponentNode<P extends Props = any, E = any> implements VNode<ComponentNode<P, E>> {
+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, E>;
+    component: Component<P, Plugins, E>;
     bdom: BDom | null;
     status: STATUS;
     forceNextRender: boolean;
@@ -44,7 +45,9 @@ export declare class ComponentNode<P extends Props = any, E = any> implements VN
     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<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>;
@@ -76,6 +79,5 @@ export declare class ComponentNode<P extends Props = any, E = any> implements VN
     beforeRemove(): void;
     remove(): void;
     get name(): string;
-    get subscriptions(): ReturnType<typeof getSubscriptions>;
 }
 export {};

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

@@ -1,4 +1,5 @@
 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;
@@ -22,6 +23,7 @@ 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";
@@ -30,3 +32,4 @@ export { OwlError } from "../common/owl_error";
 export declare const __info__: {
     version: string;
 };
+export { Plugin, PluginManager, usePlugins } from "./plugins";

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

@@ -0,0 +1 @@
+export declare function reactiveMap<A, B>(arr: A[], fn: (a: A, index: number) => B): any;

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

@@ -0,0 +1,39 @@
+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 {};

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

@@ -1,4 +1,3 @@
-import type { Callback } from "./utils";
 declare type Target = object;
 declare type Reactive<T extends Target> = T;
 /**
@@ -15,16 +14,6 @@ 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
@@ -53,5 +42,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, callback?: Callback): T;
+export declare function reactive<T extends Target>(target: T): T;
 export {};

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

@@ -0,0 +1,15 @@
+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 {};

package/dist/types/runtime/relationalModel/discussModel.d.ts

@@ -0,0 +1,19 @@
+import { AttrParams, DateParams, DatetimeParams, HtmlParams, ManyParams, RelationParams } from "./discussModelTypes";
+import { Model } from "./model";
+import { FieldDefinition } from "./types";
+export declare class DiscussRecord {
+    static Model: typeof Model;
+    static fields: Record<string, FieldDefinition>;
+    static register(): void;
+    static insert(data: Partial<any>): any;
+    record: Model;
+    constructor();
+}
+export declare const fields: {
+    One: (modelName: string, params?: RelationParams) => import("./types").FieldDefinitionMany2One;
+    Many: (modelName: string, params?: ManyParams) => FieldDefinition;
+    Attr: (defaultValue: string, params?: AttrParams) => import("./types").FieldDefinitionAny;
+    Html: (defaultValue: string, params?: HtmlParams) => import("./types").FieldDefinitionAny;
+    Date: (params?: DateParams) => import("./types").FieldDefinitionAny;
+    Datetime: (params?: DatetimeParams) => import("./types").FieldDefinitionAny;
+};

package/dist/types/runtime/relationalModel/discussModelTypes.d.ts

@@ -0,0 +1,22 @@
+import { DiscussRecord } from "./discussModel";
+export declare type FieldCommonParams = {
+    compute?: (record: DiscussRecord) => any;
+    eager?: boolean;
+    onUpdate?: (record: DiscussRecord) => void;
+};
+export declare type RelationParams = FieldCommonParams & {
+    inverse?: string;
+    onAdd?: (record: DiscussRecord) => void;
+    onDelete?: (record: DiscussRecord) => void;
+};
+export declare type ManyParams = RelationParams & {
+    sort?: (a: DiscussRecord, b: DiscussRecord) => number;
+};
+export declare type AttrParams = FieldCommonParams & {
+    sort?: (a: DiscussRecord, b: DiscussRecord) => number;
+    type?: string;
+};
+export declare type HtmlParams = FieldCommonParams;
+export declare type DateParams = FieldCommonParams;
+export declare type DatetimeParams = FieldCommonParams;
+export declare type DManyFn<T extends DiscussRecord> = () => T[];

package/dist/types/runtime/relationalModel/field.d.ts

@@ -0,0 +1,20 @@
+import { FieldDefinition, FieldDefinitionAny, FieldDefinitionChar, FieldDefinitionDate, FieldDefinitionDatetime, FieldDefinitionHtml, FieldDefinitionMany2One, FieldDefinitionMany2OneReference, FieldDefinitionNumber, FieldDefinitionOne2Many, FieldDefinitionProperties, FieldDefinitionReference, FieldDefinitionSelection, FieldDefinitionText, FieldTypes, ModelId } from "./types";
+export declare const fieldAny: () => FieldDefinitionAny;
+export declare const fieldNumber: () => FieldDefinitionNumber;
+export declare const fieldChar: () => FieldDefinitionChar;
+export declare const fieldText: () => FieldDefinitionText;
+export declare const fieldHtml: () => FieldDefinitionHtml;
+export declare const fieldDate: () => FieldDefinitionDate;
+export declare const fieldDatetime: () => FieldDefinitionDatetime;
+export declare const fieldSelection: (selection: any) => FieldDefinitionSelection;
+export declare const fieldReference: () => FieldDefinitionReference;
+export declare const fieldProperties: () => FieldDefinitionProperties;
+export declare const fieldOne2Many: (modelId: ModelId, { relatedField }?: {
+    relatedField?: string | undefined;
+}) => FieldDefinitionOne2Many;
+export declare const fieldMany2One: (modelId: ModelId) => FieldDefinitionMany2One;
+export declare const fieldMany2Many: (modelId: ModelId, opts?: {
+    relationTableName?: string;
+}) => FieldDefinition;
+export declare const fieldMany2OneReference: () => FieldDefinitionMany2OneReference;
+export declare const field: (type: FieldTypes, opts?: any) => FieldDefinition;