@odoo/owl 3.0.0-alpha.3 → 3.0.0-alpha.30

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

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

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

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

package/dist/types/runtime/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/component.d.ts

@@ -1,28 +0,0 @@
-import { Schema } from "./validation";
-import type { ComponentNode } from "./component_node";
-import type { PluginManager } from "./plugins";
-export declare type Props = {
-    [key: string]: any;
-};
-interface StaticComponentProperties {
-    template: string;
-    defaultProps?: any;
-    props?: Schema;
-    components?: {
-        [componentName: string]: ComponentConstructor;
-    };
-}
-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, plugins: Plugins, node: ComponentNode);
-    setup(): void;
-    render(deep?: boolean): void;
-}
-export {};

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

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

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

@@ -1,13 +0,0 @@
-import type { ComponentNode } from "./component_node";
-import type { Fiber } from "./fibers";
-export declare const fibersInError: WeakMap<Fiber, any>;
-export declare const nodeErrorHandlers: WeakMap<ComponentNode, ((error: any) => void)[]>;
-declare type ErrorParams = {
-    error: any;
-} & ({
-    node: ComponentNode;
-} | {
-    fiber: Fiber;
-});
-export declare function handleError(params: ErrorParams): void;
-export {};

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

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

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

@@ -1,37 +0,0 @@
-import { BDom } from "./blockdom";
-import type { ComponentNode } from "./component_node";
-export declare function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber;
-export declare function makeRootFiber(node: ComponentNode): Fiber;
-export declare class Fiber {
-    node: ComponentNode;
-    bdom: BDom | null;
-    root: RootFiber | null;
-    parent: Fiber | null;
-    children: Fiber[];
-    appliedToDom: boolean;
-    deep: boolean;
-    childrenMap: ComponentNode["children"];
-    constructor(node: ComponentNode, parent: Fiber | null);
-    render(): void;
-    _render(): void;
-}
-export declare class RootFiber extends Fiber {
-    counter: number;
-    willPatch: Fiber[];
-    patched: Fiber[];
-    mounted: Fiber[];
-    locked: boolean;
-    complete(): void;
-    setCounter(newValue: number): void;
-}
-declare type Position = "first-child" | "last-child";
-export interface MountOptions {
-    position?: Position;
-}
-export declare class MountFiber extends RootFiber {
-    target: HTMLElement;
-    position: Position;
-    constructor(node: ComponentNode, target: HTMLElement, options?: MountOptions);
-    complete(): void;
-}
-export {};

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

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

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

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

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

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

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/plugins.d.ts

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

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

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

@@ -1,46 +0,0 @@
-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;
-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): T;
-export {};

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

@@ -1,15 +0,0 @@
-import { TypeDescription } from "./validation";
-declare type Fn<T> = () => T;
-export declare class Registry<T> {
-    _map: {
-        [key: string]: [number, T];
-    };
-    _name: string;
-    _type?: TypeDescription;
-    items: Fn<T[]>;
-    entries: Fn<[string, T][]>;
-    constructor(name?: string, type?: TypeDescription);
-    set(key: string, value: T, sequence?: number): void;
-    get(key: string, defaultValue?: 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;

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

@@ -1,59 +0,0 @@
-import { MakeGetSet } from "../../common/types";
-import { ModelId, InstanceId, FieldDefinition, RecordItem, RelationChanges, DraftContext } from "./types";
-export declare class Model {
-    static id: ModelId;
-    static fields: Record<string, FieldDefinition>;
-    static relatedFields: Record<string, string>;
-    static recordsItems: Record<InstanceId, RecordItem>;
-    static create<T extends typeof Model>(this: T, data: Partial<InstanceType<T>>): InstanceType<T>;
-    static get<T extends typeof Model>(this: T, id: InstanceId, context?: DraftContext): InstanceType<T>;
-    static getAll<T extends typeof Model>(this: T): InstanceType<T>[];
-    static register<T extends typeof Model>(this: T): T;
-    static getRecordItem(id: InstanceId, defaultData?: Record<string, any>): RecordItem;
-    static getGlobalInstance<T extends typeof Model>(this: T, id: InstanceId): InstanceType<T>;
-    static getContextInstance<T extends typeof Model>(this: T, id: InstanceId, draftContext?: DraftContext): InstanceType<T>;
-    id?: InstanceId;
-    data: RecordItem["data"];
-    reactiveData: RecordItem["reactiveData"];
-    changes: RelationChanges;
-    reactiveChanges: RelationChanges;
-    parentRecord?: Model;
-    childRecords: Model[];
-    draftContext?: DraftContext;
-    constructor(idOrParentRecord?: InstanceId | Model, params?: {
-        createData?: Record<string, any>;
-        draftContext?: DraftContext;
-    });
-    delete(): void;
-    isNew(): boolean;
-    hasChanges(): boolean;
-    makeDraft(): this;
-    saveDraft(): void;
-    _saveDraft(parentDraftContext: DraftContext): void;
-    withContext(fn: () => void): void;
-    _setDraftItem(id: InstanceId): void;
-}
-/**
- * Define a lazy property on an object that computes its getter and setter on first access.
- * Allowing to delay some computation until the property is actually used.
- *
- * @param object The object on which to define the property.
- * @param property The name of the property to define.
- * @param makeGetSet A function that returns a tuple containing the getter and optional setter.
- * @example
- * defineLazyProperty(MyClass.prototype, "myProperty", function() {
- *   // Some computing that will only run once, on first access.
- *   return [
- *     () => this._myProperty,
- *     (value) => { this._myProperty = value; }
- *   ];
- * });
- */
-export declare function defineLazyProperty<T, V>(object: object, property: string, makeGetSet: MakeGetSet<T, V>): void;
-export declare function combineLists(listA: InstanceId[], deleteList: InstanceId[], addList: InstanceId[]): InstanceId[];
-export declare function ensureContext(context: DraftContext, record: Model): Model | undefined;
-export declare function withDraftContext<T>(context: DraftContext, fn: () => T): T;
-export declare function saveDraftContext(context: DraftContext): void;
-export declare function makeDraftContext(parent?: DraftContext): DraftContext;
-export declare function formatId(number: number): string;
-export declare function resetIdCounter(): void;

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

@@ -1,18 +0,0 @@
-import { Model } from "./model";
-import { InstanceId, ModelId, RelationChanges } from "./types";
-export declare type DataToSave = Record<ModelId, Record<InstanceId, RelationChanges>>;
-export declare const saveHooks: {
-    onSave: (data: DataToSave) => void;
-};
-export declare const x2ManyCommands: {
-    CREATE: number;
-    UPDATE: number;
-    DELETE: number;
-    UNLINK: number;
-    LINK: number;
-    CLEAR: number;
-    SET: number;
-};
-export declare function getRecordChanges(record: Model, dataToSave?: DataToSave, processedRecords?: Set<Model>): Record<string, any>;
-export declare function saveModels(): void;
-export declare function commitRecordChanges(record: Model): void;

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

@@ -1,3 +0,0 @@
-import { Model } from "./model";
-export declare const Models: Record<string, typeof Model>;
-export declare function clearModelRegistry(): void;

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

@@ -1,4 +0,0 @@
-export declare function isRelatedField(fieldType: string): boolean;
-export declare function isX2ManyField(fieldType: string): boolean;
-export declare function isOne2ManyField(fieldType: string): boolean;
-export declare function isMany2OneField(fieldType: string): boolean;

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

@@ -1,16 +0,0 @@
-import { Model } from "./model";
-import { ModelId, InstanceId, RecordItem, NormalizedDomain, SearchEntry, DraftContextStore } from "./types";
-export declare type StoreData = Record<ModelId, Record<InstanceId, RecordItem>>;
-declare class Store {
-    searches: Record<ModelId, Record<NormalizedDomain, SearchEntry>>;
-    data: Record<ModelId, Record<InstanceId, RecordItem>>;
-    getModelData(modelId: ModelId): Record<InstanceId, RecordItem>;
-}
-export declare const globalStore: Store;
-export declare function setStore(store: any): void;
-export declare function destroyStore(): void;
-export declare function loadRecord(modelId: ModelId, instanceId: InstanceId, data: Record<string, any>): void;
-export declare function loadRecordWithRelated(Mod: typeof Model, instanceData: Record<string, any>): Model;
-export declare function flushDataToLoad(): void;
-export declare function getStoreChanges(store: DraftContextStore): any;
-export {};