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

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

@@ -1,57 +1,57 @@
-import type { Callback } from "./utils";
-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
- */
-export 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
- */
-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
- * 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
- */
-export declare function reactive<T extends Target>(target: T, callback?: Callback): T;
-export {};
+import type { Callback } from "./utils";
+type Target = object;
+type Reactive<T extends Target> = T;
+/**
+ * Mark an object or array so that it is ignored by the reactivity system
+ *
+ * @param value the value to mark
+ * @returns the object itself
+ */
+export declare function markRaw<T extends Target>(value: T): T;
+/**
+ * Given a reactive objet, return the raw (non reactive) underlying object
+ *
+ * @param value a reactive value
+ * @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
+ * 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
+ */
+export declare function reactive<T extends Target>(target: T, callback?: Callback): T;
+export {};

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

@@ -1,7 +1,7 @@
 import type { ComponentNode } from "../component_node";
 import { Fiber, RootFiber } from "./fibers";
 export declare class Scheduler {
-    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+    static requestAnimationFrame: (callback: FrameRequestCallback) => number;
     tasks: Set<RootFiber>;
     requestAnimationFrame: Window["requestAnimationFrame"];
     frame: number;

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

@@ -2,7 +2,6 @@ import { OwlError } from "../../common/owl_error";
 import { App } from "../app";
 import { BDom, createCatcher, toggler } from "../blockdom";
 import { ComponentNode } from "../component_node";
-import { Portal } from "../portal";
 import { markRaw } from "../reactivity/proxy";
 /**
  * This file contains utility functions that will be injected in each template,
@@ -26,6 +25,7 @@ declare class LazyValue {
 }
 export declare function safeOutput(value: any, defaultValue?: any): ReturnType<typeof toggler>;
 declare function createRef(ref: any): (el: HTMLElement | null, previousEl: HTMLElement | null) => void;
+declare function callHandler(fn: any, ctx: any, ev: Event): void;
 declare function modelExpr(value: any): any;
 declare function createComponent<P extends Record<string, any>>(app: App, name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
 declare function callTemplate(subTemplate: string, owner: any, app: App, ctx: any, parent: any, key: any): any;
@@ -45,7 +45,7 @@ export declare const helpers: {
     createRef: typeof createRef;
     modelExpr: typeof modelExpr;
     createComponent: typeof createComponent;
-    Portal: typeof Portal;
     callTemplate: typeof callTemplate;
+    callHandler: typeof callHandler;
 };
 export {};

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

@@ -1,21 +1,21 @@
-import type { ComponentNode } from "./component_node";
-import { Fiber, RootFiber } from "./fibers";
-export declare class Scheduler {
-    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
-    tasks: Set<RootFiber>;
-    requestAnimationFrame: Window["requestAnimationFrame"];
-    frame: number;
-    delayedRenders: Fiber[];
-    cancelledNodes: Set<ComponentNode>;
-    processing: boolean;
-    constructor();
-    addFiber(fiber: Fiber): void;
-    scheduleDestroy(node: ComponentNode): void;
-    /**
-     * Process all current tasks. This only applies to the fibers that are ready.
-     * Other tasks are left unchanged.
-     */
-    flush(): void;
-    processTasks(): void;
-    processFiber(fiber: RootFiber): void;
-}
+import type { ComponentNode } from "./component_node";
+import { Fiber, RootFiber } from "./fibers";
+export declare class Scheduler {
+    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+    tasks: Set<RootFiber>;
+    requestAnimationFrame: Window["requestAnimationFrame"];
+    frame: number;
+    delayedRenders: Fiber[];
+    cancelledNodes: Set<ComponentNode>;
+    processing: boolean;
+    constructor();
+    addFiber(fiber: Fiber): void;
+    scheduleDestroy(node: ComponentNode): void;
+    /**
+     * Process all current tasks. This only applies to the fibers that are ready.
+     * Other tasks are left unchanged.
+     */
+    flush(): void;
+    processTasks(): void;
+    processFiber(fiber: RootFiber): void;
+}

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

@@ -33,6 +33,8 @@ declare function literalSelection<const T extends LiteralTypes>(literals: T[]):
 declare function objectType(): Record<string, any>;
 declare function objectType<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
 declare function objectType<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
+declare function strictObjectType<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
+declare function strictObjectType<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
 declare function promiseType(): Promise<void>;
 declare function promiseType<T>(type: T): Promise<T>;
 declare function recordType(): Record<PropertyKey, any>;
@@ -61,6 +63,7 @@ export declare const types: {
     ref: typeof ref;
     selection: typeof literalSelection;
     signal: typeof reactiveValueType;
+    strictObject: typeof strictObjectType;
     string: string;
     tuple: typeof tuple;
 };

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.0.0-alpha";
+export declare const version = "3.0.0-alpha.21";

package/package.json

@@ -1,10 +1,20 @@
 {
   "name": "@odoo/owl",
-  "version": "3.0.0-alpha.20",
+  "version": "3.0.0-alpha.21",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "module": "dist/owl.es.js",
   "types": "dist/types/owl.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/owl.d.ts",
+      "import": "./dist/owl.es.js",
+      "require": "./dist/owl.cjs.js",
+      "default": "./dist/owl.es.js"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
   "type": "module",
   "files": [
     "dist"
@@ -49,6 +59,18 @@
   },
   "homepage": "https://github.com/odoo/owl#readme",
   "devDependencies": {
+    "@codemirror/autocomplete": "^6.20.1",
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-javascript": "^6.2.5",
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/lang-xml": "^6.1.0",
+    "@codemirror/language": "^6.12.2",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.40.0",
+    "@emmetio/codemirror6-plugin": "^0.4.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
     "@types/jest": "^30.0.0",
     "@types/jsdom": "^21.1.7",
@@ -56,6 +78,7 @@
     "@typescript-eslint/eslint-plugin": "^8.54.0",
     "@typescript-eslint/parser": "^8.54.0",
     "chalk": "^3.0.0",
+    "codemirror": "^6.0.2",
     "current-git-branch": "^1.1.0",
     "eslint": "^9.39.2",
     "git-rev-sync": "^3.0.2",

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

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

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

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

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

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

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

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

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

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

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

@@ -1,46 +0,0 @@
-type Target = object;
-type Reactive<T extends Target> = T;
-/**
- * Mark an object or array so that it is ignored by the reactivity system
- *
- * @param value the value to mark
- * @returns the object itself
- */
-export declare function markRaw<T extends Target>(value: T): T;
-/**
- * Given a proxy objet, return the raw (non proxy) underlying object
- *
- * @param value a proxy value
- * @returns the underlying value
- */
-export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
-export declare const targets: WeakMap<object, object>;
-/**
- * Creates a reactive proxy for an object. Reading data on the proxy object
- * subscribes to changes to the data. Writing data on the object will cause the
- * notify callback to be called if there are suscriptions to that data. Nested
- * objects and arrays are automatically made reactive as well.
- *
- * Whenever you are notified of a change, all subscriptions are cleared, and if
- * you would like to be notified of any further changes, you should go read
- * the underlying data again. We assume that if you don't go read it again after
- * being notified, it means that you are no longer interested in that data.
- *
- * Subscriptions:
- * + Reading a property on an object will subscribe you to changes in the value
- *    of that property.
- * + Accessing an object's keys (eg with Object.keys or with `for..in`) will
- *    subscribe you to the creation/deletion of keys. Checking the presence of a
- *    key on the object with 'in' has the same effect.
- * - getOwnPropertyDescriptor does not currently subscribe you to the property.
- *    This is a choice that was made because changing a key's value will trigger
- *    this trap and we do not want to subscribe by writes. This also means that
- *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
- *
- * @param target the object for which to create a proxy proxy
- * @param callback the function to call when an observed property of the
- *  proxy has changed
- * @returns a proxy that tracks changes to it
- */
-export declare function proxy<T extends Target>(target: T): T;
-export {};

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

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

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

@@ -1,48 +0,0 @@
-import { Atom } from "./computations";
-type Target = object;
-type Reactive<T extends Target> = T;
-/**
- * Mark an object or array so that it is ignored by the reactivity system
- *
- * @param value the value to mark
- * @returns the object itself
- */
-export declare function markRaw<T extends Target>(value: T): T;
-/**
- * Given a proxy objet, return the raw (non proxy) underlying object
- *
- * @param value a proxy value
- * @returns the underlying value
- */
-export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
-export declare const targets: WeakMap<object, object>;
-export declare function proxifyTarget<T extends Target>(target: T, atom: Atom | null): T;
-/**
- * Creates a reactive proxy for an object. Reading data on the proxy object
- * subscribes to changes to the data. Writing data on the object will cause the
- * notify callback to be called if there are suscriptions to that data. Nested
- * objects and arrays are automatically made reactive as well.
- *
- * Whenever you are notified of a change, all subscriptions are cleared, and if
- * you would like to be notified of any further changes, you should go read
- * the underlying data again. We assume that if you don't go read it again after
- * being notified, it means that you are no longer interested in that data.
- *
- * Subscriptions:
- * + Reading a property on an object will subscribe you to changes in the value
- *    of that property.
- * + Accessing an object's keys (eg with Object.keys or with `for..in`) will
- *    subscribe you to the creation/deletion of keys. Checking the presence of a
- *    key on the object with 'in' has the same effect.
- * - getOwnPropertyDescriptor does not currently subscribe you to the property.
- *    This is a choice that was made because changing a key's value will trigger
- *    this trap and we do not want to subscribe by writes. This also means that
- *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
- *
- * @param target the object for which to create a proxy proxy
- * @param callback the function to call when an observed property of the
- *  proxy has changed
- * @returns a proxy that tracks changes to it
- */
-export declare function state<T extends Target>(target: T): T;
-export {};

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

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

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

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