@odoo/owl 2.8.1 → 3.0.0-alpha.2

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

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

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

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

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

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

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

@@ -0,0 +1,83 @@
+import { Model } from "./model";
+export declare type FieldTypes = FieldDefinition["type"];
+export declare type ModelId = string;
+export declare type NormalizedDomain = string;
+export declare type InstanceId = number | string;
+export declare type FieldName = string;
+export declare type ItemData = Record<string, any>;
+export declare type RecordItem = {
+    data: ItemData;
+    reactiveData: ItemData;
+    instance: Model;
+    dataToLoad?: ItemData;
+};
+export declare type RelationChanges = Record<FieldName, null | InstanceId | [InstanceId[], InstanceId[]]>;
+export declare type FieldDefinitionBase = {
+    fieldName: string;
+};
+export declare type FieldDefinitionAny = FieldDefinitionBase & {
+    type: "any";
+};
+export declare type FieldDefinitionString = FieldDefinitionBase & {
+    type: "string";
+};
+export declare type FieldDefinitionChar = FieldDefinitionBase & {
+    type: "char";
+};
+export declare type FieldDefinitionText = FieldDefinitionBase & {
+    type: "text";
+};
+export declare type FieldDefinitionHtml = FieldDefinitionBase & {
+    type: "html";
+};
+export declare type FieldDefinitionDate = FieldDefinitionBase & {
+    type: "date";
+};
+export declare type FieldDefinitionDatetime = FieldDefinitionBase & {
+    type: "datetime";
+};
+export declare type FieldDefinitionSelection = FieldDefinitionBase & {
+    type: "selection";
+    selection: any;
+};
+export declare type FieldDefinitionReference = FieldDefinitionBase & {
+    type: "reference";
+};
+export declare type FieldDefinitionMany2OneReference = FieldDefinitionBase & {
+    type: "many2one_reference";
+};
+export declare type FieldDefinitionProperties = FieldDefinitionBase & {
+    type: "properties";
+};
+export declare type FieldDefinitionNumber = FieldDefinitionBase & {
+    type: "number";
+};
+export declare type FieldDefinitionX2Many = FieldDefinitionBase & {
+    modelId: ModelId;
+};
+export declare type FieldDefinitionOne2Many = FieldDefinitionX2Many & {
+    type: "one2many";
+    relatedField?: string;
+};
+export declare type FieldDefinitionMany2One = FieldDefinitionX2Many & {
+    type: "many2one";
+};
+export declare type FieldDefinitionMany2Many = FieldDefinitionX2Many & {
+    type: "many2many";
+    relationTableName?: string;
+};
+export declare type X2ManyFieldDefinition = FieldDefinitionOne2Many | FieldDefinitionMany2One | FieldDefinitionMany2Many;
+export declare type FieldDefinition = FieldDefinitionAny | FieldDefinitionString | FieldDefinitionChar | FieldDefinitionText | FieldDefinitionHtml | FieldDefinitionDate | FieldDefinitionDatetime | FieldDefinitionSelection | FieldDefinitionReference | FieldDefinitionMany2OneReference | FieldDefinitionProperties | FieldDefinitionNumber | X2ManyFieldDefinition;
+export declare type ManyFn<T extends Model> = (() => T[]) & {
+    add: (m: T) => void;
+    delete: (m: T) => void;
+    ids: () => InstanceId[];
+};
+export declare type SearchEntry = {
+    ids: InstanceId[];
+};
+export declare type DraftContextStore = Record<ModelId, Record<InstanceId, Model>>;
+export declare type DraftContext = {
+    parent?: DraftContext;
+    store: DraftContextStore;
+} | undefined;

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

@@ -0,0 +1 @@
+export declare function mapEntries<T, U>(obj: Record<string, T>, fn: (entry: [string, T]) => [string, U]): Record<string, U>;

package/dist/types/runtime/relationalModel/web/WebDataPoint.d.ts

@@ -0,0 +1,25 @@
+export declare class DataPoint {
+    /**
+     * @param {RelationalModel} model
+     * @param {RelationalModelConfig} config
+     * @param {Record<string, unknown>} data
+     * @param {unknown} [options]
+     */
+    model: any;
+    _config: any;
+    _constructor(model: any, config: any, data: any, options: any): void;
+    /**
+     * @abstract
+     * @template [O={}]
+     * @param {RelationalModelConfig} _config
+     * @param {Record<string, unknown>} _data
+     * @param {O | undefined} _options
+     */
+    setup(_config: any, _data: any, _options: any): void;
+    get activeFields(): any;
+    get fields(): any;
+    get fieldNames(): string[];
+    get resModel(): any;
+    get config(): any;
+    get context(): any;
+}

package/dist/types/runtime/relationalModel/web/WebRecord.d.ts

@@ -0,0 +1,131 @@
+import { Model } from "../model";
+import { DataPoint } from "./WebDataPoint";
+export declare type MakeWebRecord = (model: any, config: any, data: any, options: any) => WebRecord;
+export declare class WebRecord extends DataPoint {
+    static type: string;
+    orecord: Model;
+    data: Record<string, any>;
+    evalContext: Record<string, any>;
+    evalContextWithVirtualIds: Record<string, any>;
+    _isEvalContextReady: boolean;
+    canSaveOnUpdate: boolean;
+    selected: boolean | undefined;
+    constructor(...args: Parameters<MakeWebRecord>);
+    setup(_config: any, data: any, options?: any): void;
+    get id(): import("../types").InstanceId | undefined;
+    get resId(): false | import("../types").InstanceId | undefined;
+    get isNew(): boolean;
+    get dirty(): boolean;
+    get isValid(): boolean;
+    _isRequired(fieldName: string): any;
+    get isActive(): any;
+    _isInvisible(fieldName: string): any;
+    _isReadonly(fieldName: string): any;
+    update(changes: any, { save }?: any): any;
+    _updateORecord(orecord: any, changes: any): Promise<void>;
+    _update(changes: any, { withoutOnchange, withoutParentUpdate }?: any): Promise<void>;
+    _setEvalContext(): void;
+    _computeDataContext(): {
+        withVirtualIds: any;
+        withoutVirtualIds: any;
+    };
+    /**
+     * @param {Parameters<Record["_save"]>[0]} options
+     */
+    save(options: any): Promise<any>;
+    _save({ reload, onError, nextId }?: any): Promise<any>;
+    _getChanges(): Record<string, any>;
+    urgentSave(): Promise<any>;
+    load(): any;
+    _load(nextConfig?: {}): Promise<void>;
+    get resIds(): any;
+    get hasData(): boolean;
+    get isInEdition(): boolean;
+    /**
+     * @param {Mode} mode
+     */
+    switchMode(mode: any): any;
+    /**
+     * @param {Mode} mode
+     */
+    _switchMode(mode: any): void;
+    get canBeAbandoned(): boolean;
+    isDirty(): Promise<boolean>;
+    toggleSelection(selected: any): any;
+    _toggleSelection(selected: any): void;
+    getChanges({ withReadonly }?: any): Promise<any>;
+    _getOnchangeValues(changes: any): Promise<void>;
+    /**
+     * @param {RecordType<string, unknown>} serverValues
+     * @param {FieldSpecifications} [params]
+     */
+    _parseServerValues(serverValues: any, { currentValues, orderBys }?: any): void;
+    _formatServerValue(fieldType: string, value: any): void;
+    checkValidity({ displayNotification }?: any): Promise<boolean>;
+    _checkValidity({ silent, displayNotification, removeInvalidOnly }?: any): void;
+    /**
+     * @param {string} fieldName
+     */
+    isFieldInvalid(fieldName: string): boolean;
+    /**
+     * @param {string} fieldName
+     */
+    setInvalidField(fieldName: string): Promise<void>;
+    _setInvalidField(fieldName: string): Promise<void>;
+    /**
+     * @param {string} fieldName
+     */
+    resetFieldValidity(fieldName: string): Promise<void>;
+    _resetFieldValidity(fieldName: string): void;
+    _removeInvalidFields(...fieldNames: string[]): void;
+    _displayInvalidFieldNotification(): void;
+    _setData(data: Record<string, any>, { orderBys, keepChanges }?: any): void;
+    _applyValues(values: Record<string, any>): void;
+    _applyChanges(changes: Record<string, any>, serverChanges?: {}): void;
+    _applyDefaultValues(): void;
+    _getDefaultValues(fieldNames?: string[]): void;
+    /**
+     * This function extracts all properties and adds them to fields and activeFields.
+     *
+     * @param {Object[]} properties the list of properties to be extracted
+     * @param {string} fieldName name of the field containing the properties
+     * @param {Array} parent Array with ['id, 'display_name'], representing the record to which the definition of properties is linked
+     * @param {Object} currentValues current values of the record
+     * @returns An object containing as key `${fieldName}.${property.name}` and as value the value of the property
+     */
+    _processProperties(properties: Array<any>, fieldName: string, parent: Array<any>, currentValues?: Object): void;
+    _preprocessMany2oneChanges(changes: any): Promise<void>;
+    _preprocessMany2OneReferenceChanges(changes: any): Promise<void>;
+    _preprocessReferenceChanges(changes: any): Promise<void>;
+    _preprocessX2manyChanges(changes: any): Promise<void>;
+    _preprocessPropertiesChanges(changes: any): void;
+    _preprocessHtmlChanges(changes: any): void;
+    /**
+     * Given a possibily incomplete value for a many2one field (i.e. a object { id, display_name } but
+     * with id and/or display_name being undefined), return the complete value as follows:
+     *  - if a display_name is given but no id, perform a name_create to get an id
+     *  - if an id is given but display_name is undefined, call web_read to get the display_name
+     *  - if both id and display_name are given, return the value as is
+     *  - in any other cases, return false
+     *
+     * @param {{ id?: number; display_name?: string }} value
+     * @param {string} fieldName
+     * @param {string} resModel
+     * @returns {Promise<false | { id: number; display_name: string; }>} the completed record { id, display_name } or false
+     */
+    _completeMany2OneValue(value: {
+        id?: number;
+        display_name?: string;
+    }, fieldName: string, resModel: string): Promise<void>;
+    discard(): Promise<void>;
+    _discard(): void;
+    duplicate(): void;
+    delete(): void;
+    archive(): void;
+    unarchive(): void;
+    _toggleArchive(state: boolean): Promise<void>;
+    _getTextValues(values: any): void;
+    _addSavePoint(): void;
+    _createStaticListDatapoint(data: any, fieldName: string, { orderBys }?: any): void;
+}
+export declare function makeFieldObject(record: any, orecord: Model): any;

package/dist/types/runtime/relationalModel/web/WebStaticList.d.ts

@@ -0,0 +1,63 @@
+import { Model } from "../model";
+import { DraftContext, InstanceId, ManyFn } from "../types";
+import { DataPoint } from "./WebDataPoint";
+import { MakeWebRecord, WebRecord } from "./WebRecord";
+export declare type StaticListConfig = {
+    parentRecord: any;
+    orecord: Model;
+    fieldName: string;
+    makeWebRecord: MakeWebRecord;
+};
+export declare type MakeNewRecordParams = {
+    activeFields: Object;
+    fields: Object;
+    context?: Object;
+    withoutParent?: boolean;
+    mode?: string;
+};
+export declare class StaticList extends DataPoint {
+    sconfig: StaticListConfig;
+    _records: () => WebRecord[];
+    orecordList: ManyFn<Model>;
+    _webRecords: Record<InstanceId, WebRecord>;
+    _draftRecord: Map<InstanceId, WebRecord>;
+    draftContext: DraftContext;
+    draftORecord: Model;
+    constructor(sconfig: StaticListConfig);
+    _constructor(sconfig: StaticListConfig): void;
+    _defineRecords(): void;
+    _getRecord(record: Model): WebRecord;
+    get count(): number;
+    get records(): WebRecord[];
+    get resIds(): InstanceId[];
+    get currentIds(): string;
+    get limit(): number;
+    get offset(): number;
+    get orderBy(): never[];
+    get evalContext(): any;
+    extendRecord(params: MakeNewRecordParams, record: WebRecord): Promise<any>;
+    _getDraftRecord(params: MakeNewRecordParams, webrecord: WebRecord, activeFields: Record<string, any>): Promise<WebRecord>;
+    validateExtendedRecord(record: WebRecord): void;
+    _getActiveFields(params: MakeNewRecordParams): Record<string, any>;
+    _makeNewRecord(params: any): Promise<WebRecord>;
+    _createRecordDatapoint(data: any, params?: any): WebRecord;
+    get editedRecord(): null;
+    enterEditMode(): void;
+    leaveEditMode(): void;
+    get selection(): never[];
+    canResequence(): void;
+    resequence(): void;
+    load(): void;
+    sortBy(): void;
+    addNewRecord(): void;
+    addNewRecordAtIndex(): void;
+    applyCommands(): void;
+    linkTo(): void;
+    unlinkFrom(): void;
+    forget(): void;
+    moveRecord(): void;
+    addAndRemove(): void;
+    duplicateRecords(): void;
+    delete(): void;
+}
+export declare function completeActiveFields(activeFields: Record<string, any>, extraActiveFields: Record<string, any>): void;

package/dist/types/runtime/relationalModel/web/webModel.d.ts

@@ -0,0 +1,5 @@
+import { Model } from "../model";
+import { ModelId } from "../types";
+import { WebModelConfig } from "./webModelTypes";
+export declare function getOrMakeModel(modelId: ModelId): typeof Model;
+export declare function makeModelFromWeb(config: WebModelConfig, processedModel?: Set<string>): typeof Model;

package/dist/types/runtime/relationalModel/web/webModelTypes.d.ts

@@ -0,0 +1,139 @@
+export interface WebModelConfig {
+    isMonoRecord: boolean;
+    context: Record<string, any>;
+    fieldsToAggregate: string[];
+    activeFields?: {
+        [key: string]: ActiveFieldInfo;
+    };
+    fields: {
+        [key: string]: FieldInfo;
+    };
+    isRoot: boolean;
+    resModel: string;
+    groupBy: string[];
+    resId?: number | false;
+    resIds?: number[];
+    mode?: "edit" | "readonly";
+    domain: any[];
+    orderBy: OrderBy[];
+    groups?: Record<string, any>;
+    offset: number;
+    limit: number;
+    countLimit: number;
+    currentGroups?: {
+        params: string;
+        groups: any[];
+    };
+    loadId?: string;
+    openGroupsByDefault?: boolean;
+    [key: string]: any;
+}
+export interface FieldInfo {
+    change_default?: boolean;
+    groupable?: boolean;
+    name?: string;
+    readonly?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    sortable?: boolean;
+    store?: boolean;
+    string?: string;
+    type?: string;
+    help?: string;
+    translate?: boolean;
+    trim?: boolean;
+    context?: {};
+    domain?: any[];
+    relation?: string;
+    related?: string;
+    selection?: Array<[string, string]>;
+    groups?: string;
+    relation_field?: string;
+    aggregator?: string;
+    digits?: [number, number];
+    size?: number;
+    currency_field?: string;
+    sanitize?: boolean;
+    sanitize_tags?: boolean;
+    definition_record?: string;
+    definition_record_field?: string;
+}
+export interface ActiveFieldInfo {
+    context: {};
+    invisible: string | boolean;
+    readonly: string | boolean;
+    required: string | boolean;
+    onChange: boolean;
+    forceSave: boolean;
+    isHandle: boolean;
+    related?: {
+        activeFields: {
+            [key: string]: ActiveFieldInfo;
+        };
+        fields: {
+            [key: string]: FieldInfo;
+        };
+    };
+}
+export interface WebModelConfigContext {
+    default_is_company: boolean;
+    lang: string;
+    tz: string;
+    uid: number;
+    allowed_company_ids: number[];
+}
+export interface RelationalModelParams {
+    config: {
+        activeFields: {
+            [key: string]: ActiveFieldInfo;
+        };
+        [key: string]: any;
+    };
+    limit?: number;
+    groupsLimit?: number;
+    countLimit?: number;
+    defaultOrderBy?: OrderBy[];
+    maxGroupByDepth?: number;
+    groupByInfo?: Record<string, any>;
+    multiEdit?: boolean;
+    activeIdsLimit?: number;
+    state?: {
+        specialDataCaches?: Record<string, any>;
+    };
+    useSendBeaconToSaveUrgently?: boolean;
+    hooks?: Partial<RelationalModelHooks>;
+    [key: string]: any;
+}
+export interface OrderBy {
+    name: string;
+    asc?: boolean;
+}
+export interface SearchParams {
+    context?: Record<string, any>;
+    resId?: number | false;
+    resIds?: number[];
+    domain?: any[];
+    groupBy?: string[];
+    orderBy?: OrderBy[];
+    limit?: number;
+    offset?: number;
+    countLimit?: number;
+}
+export interface Services {
+    action: any;
+    dialog: any;
+    notification: any;
+    orm: any;
+}
+export interface OnChangeParams {
+    changes?: Record<string, any>;
+    fieldNames?: string[];
+    evalContext?: Record<string, any>;
+    onError?: (error: any) => void;
+    cache?: any;
+}
+export interface RelationalModelHooks {
+    onWillLoadRoot: (config: WebModelConfig) => Promise<void>;
+    onRootLoaded: (root: any) => Promise<void>;
+    onWillDisplayOnchangeWarning: (warning: any) => Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import { Atom, Computation, Derived, Opts } from "../common/types";
+export declare function signal<T>(value: T, opts?: Opts): {
+    readonly get: () => T;
+    readonly set: (newValue: T | ((prevValue: T) => T)) => void;
+};
+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;

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

@@ -0,0 +1,12 @@
+import { TaskContext } from "./cancellableContext";
+export declare class Task<T = any> {
+    _onCancelled?: Function | undefined;
+    _promise: Promise<T>;
+    _ctx?: TaskContext;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: any) => void) => void, _onCancelled?: Function | undefined);
+    then(onFulfilled: (value: any) => any, onRejected: (error: any) => any): Promise<any>;
+    catch(onRejected: (error: any) => any): Promise<any>;
+    finally(onFinally: () => any): Promise<T>;
+    cancel(): void;
+    get [Symbol.toStringTag](): string;
+}

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

@@ -0,0 +1,15 @@
+import { Schema } from "../runtime/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.8.1",
+  "version": "3.0.0-alpha.2",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "module": "dist/owl.es.js",