vasille 1.2.7 → 2.0.1

package/types/binding/class.d.ts

@@ -0,0 +1,23 @@
+import { Binding } from "./binding";
+import type { INode } from "../node/node";
+import type { IValue } from "../core/ivalue";
+/**
+ * Represents a HTML class binding description
+ * @class ClassBinding
+ * @extends Binding
+ */
+export declare class ClassBinding extends Binding<string | boolean> {
+    /**
+     * Constructs an HTML class binding description
+     * @param node {INode} the vasille node
+     * @param name {String} the name of class
+     * @param value {IValue} the value to bind
+     */
+    constructor(node: INode, name: string, value: IValue<string | boolean>);
+    /**
+     * Generates a function which updates the html class value
+     * @param name {String} The name of attribute
+     * @returns {Function} a function which will update attribute value
+     */
+    protected bound(name: string): (node: INode, value: string | boolean) => void;
+}

package/types/binding/style.d.ts

@@ -0,0 +1,23 @@
+import { Binding } from "./binding";
+import type { INode } from "../node/node";
+import type { IValue } from "../core/ivalue";
+/**
+ * Describes a style attribute binding
+ * @class StyleBinding
+ * @extends Binding
+ */
+export declare class StyleBinding extends Binding<string> {
+    /**
+     * Constructs a style binding attribute
+     * @param node {INode} the vasille node
+     * @param name {string} the name of style property
+     * @param value {IValue} the value to bind
+     */
+    constructor(node: INode, name: string, value: IValue<string>);
+    /**
+     * Generates a function to update style property value
+     * @param name {string}
+     * @returns {Function} a function to update style property
+     */
+    protected bound(name: string): (node: INode, value: string) => void;
+}

package/types/core/core.d.ts

@@ -0,0 +1,140 @@
+import { Destroyable } from "./destroyable.js";
+import { IValue } from "./ivalue.js";
+import { Expression } from "../value/expression";
+import { Pointer } from "../value/pointer";
+import { Mirror } from "../value/mirror";
+import { IModel } from "../models/model";
+/**
+ * Private stuff of a reactive object
+ * @class ReactivePrivate
+ * @extends Destroyable
+ */
+export declare class ReactivePrivate extends Destroyable {
+    /**
+     * A list of user-defined values
+     * @type {Set}
+     */
+    watch: Set<IValue<unknown>>;
+    /**
+     * A list of user-defined bindings
+     * @type {Set}
+     */
+    bindings: Set<Destroyable>;
+    /**
+     * A list of user defined models
+     */
+    models: Set<IModel<any, any>>;
+    /**
+     * Reactivity switch state
+     * @type {boolean}
+     */
+    enabled: boolean;
+    /**
+     * The frozen state of object
+     * @type {boolean}
+     */
+    frozen: boolean;
+    /**
+     * An expression which will freeze/unfreeze the object
+     * @type {IValue<void>}
+     */
+    freezeExpr: Expression<void, boolean>;
+    constructor();
+    $destroy(): void;
+}
+/**
+ * A reactive object
+ * @class Reactive
+ * @extends Destroyable
+ */
+export declare class Reactive extends Destroyable {
+    /**
+     * Private stuff
+     * @protected
+     */
+    protected $: ReactivePrivate;
+    constructor($?: ReactivePrivate);
+    /**
+     * Create a reference
+     * @param value {*} value to reference
+     */
+    $ref<T>(value: T): IValue<T>;
+    /**
+     * Create a mirror
+     * @param value {IValue} value to mirror
+     * @param forwardOnly {boolean} forward only sync
+     */
+    $mirror<T>(value: IValue<T>, forwardOnly?: boolean): Mirror<T>;
+    /**
+     * Creates a pointer
+     * @param value {*} default value to point
+     * @param forwardOnly {boolean} forward only sync
+     */
+    $point<T>(value: T | IValue<T>, forwardOnly?: boolean): Pointer<T>;
+    /**
+     * Register a model
+     * @param model
+     */
+    $register<T extends IModel<any, any>>(model: T): T;
+    /**
+     * Creates a watcher
+     * @param func {function} function to run on any argument change
+     * @param v1 {IValue} argument
+     * @param v2 {IValue} argument
+     * @param v3 {IValue} argument
+     * @param v4 {IValue} argument
+     * @param v5 {IValue} argument
+     * @param v6 {IValue} argument
+     * @param v7 {IValue} argument
+     * @param v8 {IValue} argument
+     * @param v9 {IValue} argument
+     */
+    $watch<T1>(func: (a1: T1) => void, v1: IValue<T1>): any;
+    $watch<T1, T2>(func: (a1: T1, a2: T2) => void, v1: IValue<T1>, v2: IValue<T2>): any;
+    $watch<T1, T2, T3>(func: (a1: T1, a2: T2, a3: T3) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>): any;
+    $watch<T1, T2, T3, T4>(func: (a1: T1, a2: T2, a3: T3, a4: T4) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>): any;
+    $watch<T1, T2, T3, T4, T5>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>): any;
+    $watch<T1, T2, T3, T4, T5, T6>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>): any;
+    $watch<T1, T2, T3, T4, T5, T6, T7>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>): any;
+    $watch<T1, T2, T3, T4, T5, T6, T7, T8>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8: IValue<T8>): any;
+    $watch<T1, T2, T3, T4, T5, T6, T7, T8, T9>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => void, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8: IValue<T8>, v9: IValue<T9>): any;
+    /**
+     * Creates a computed value
+     * @param func {function} function to run on any argument change
+     * @param v1 {IValue} argument
+     * @param v2 {IValue} argument
+     * @param v3 {IValue} argument
+     * @param v4 {IValue} argument
+     * @param v5 {IValue} argument
+     * @param v6 {IValue} argument
+     * @param v7 {IValue} argument
+     * @param v8 {IValue} argument
+     * @param v9 {IValue} argument
+     * @return {IValue} the created ivalue
+     */
+    $bind<T, T1>(func: (a1: T1) => T, v1: IValue<T1>): any;
+    $bind<T, T1, T2>(func: (a1: T1, a2: T2) => T, v1: IValue<T1>, v2: IValue<T2>): any;
+    $bind<T, T1, T2, T3>(func: (a1: T1, a2: T2, a3: T3) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>): any;
+    $bind<T, T1, T2, T3, T4>(func: (a1: T1, a2: T2, a3: T3, a4: T4) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>): any;
+    $bind<T, T1, T2, T3, T4, T5>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>): any;
+    $bind<T, T1, T2, T3, T4, T5, T6>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>): any;
+    $bind<T, T1, T2, T3, T4, T5, T6, T7>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>): any;
+    $bind<T, T1, T2, T3, T4, T5, T6, T7, T8>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8: IValue<T8>): any;
+    $bind<T, T1, T2, T3, T4, T5, T6, T7, T8, T9>(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => T, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8: IValue<T8>, v9: IValue<T9>): any;
+    /**
+     * Enable reactivity of fields
+     */
+    $enable(): void;
+    /**
+     * Disable reactivity of fields
+     */
+    $disable(): void;
+    /**
+     * Disable/Enable reactivity of object fields with feedback
+     * @param cond {IValue} show condition
+     * @param onOff {function} on show feedback
+     * @param onOn {function} on hide feedback
+     */
+    $bindAlive(cond: IValue<boolean>, onOff?: () => void, onOn?: () => void): this;
+    $destroy(): void;
+}

package/types/core/destroyable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Mark an object which can be destroyed
+ * @class Destroyable
+ */
+export declare class Destroyable {
+    /**
+     * Make object fields non configurable
+     * @protected
+     */
+    protected $seal(): void;
+    /**
+     * Garbage collector method
+     */
+    $destroy(): void;
+}

package/types/core/errors.d.ts

@@ -0,0 +1,4 @@
+export declare function notOverwritten(): string;
+export declare function internalError(msg: string): string;
+export declare function userError(msg: string, err: string): string;
+export declare function wrongBinding(msg: string): string;

package/types/core/executor.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Represents an executor unit interface
+ * @class Executor
+ */
+export declare class Executor {
+    /**
+     * Adds a CSS class
+     * @param el {Element} element to manipulate
+     * @param cl {string} class to be added
+     */
+    addClass(el: Element, cl: string): void;
+    /**
+     * Removes a CSS class
+     * @param el {Element} element to manipulate
+     * @param cl {string} class to be removed
+     */
+    removeClass(el: Element, cl: string): void;
+    /**
+     * Sets a tag attribute
+     * @param el {Element} element to manipulate
+     * @param name {string} name of attribute
+     * @param value {string} value of attribute
+     */
+    setAttribute(el: Element, name: string, value: string): void;
+    /**
+     * Removes a tag attribute
+     * @param el {Element} element to manipulate
+     * @param name {string} name of attribute
+     */
+    removeAttribute(el: Element, name: string): void;
+    /**
+     * Sets a style attribute
+     * @param el {HTMLElement} element to manipulate
+     * @param prop {string} property name
+     * @param value {string} property value
+     */
+    setStyle(el: HTMLElement, prop: string, value: string): void;
+    /**
+     * Inserts a child before target
+     * @param target {Element} target element
+     * @param child {Node} element to insert before
+     */
+    insertBefore(target: Node, child: Node): void;
+    /**
+     * Appends a child to element
+     * @param el {Element} element
+     * @param child {Node} child to be inserted
+     */
+    appendChild(el: Element, child: Node): void;
+    /**
+     * Calls a call-back function
+     * @param cb {function} call-back function
+     */
+    callCallback(cb: () => void): void;
+}
+/**
+ * Executor which execute any commands immediately
+ * @class InstantExecutor
+ * @extends Executor
+ */
+export declare class InstantExecutor extends Executor {
+    addClass(el: Element, cl: string): void;
+    removeClass(el: Element, cl: string): void;
+    setAttribute(el: Element, name: string, value: string): void;
+    removeAttribute(el: Element, name: string): void;
+    setStyle(el: HTMLElement, prop: string, value: string): void;
+    insertBefore(target: Node, child: Node): void;
+    appendChild(el: Node, child: Node): void;
+    callCallback(cb: () => void): void;
+}
+/**
+ * Executor which execute any commands over timeout
+ * @class TimeoutExecutor
+ * @extends InstantExecutor
+ */
+export declare class TimeoutExecutor extends InstantExecutor {
+    addClass(el: Element, cl: string): void;
+    removeClass(el: Element, cl: string): void;
+    setAttribute(el: Element, name: string, value: string): void;
+    removeAttribute(el: Element, name: string): void;
+    setStyle(el: HTMLElement, prop: string, value: string): void;
+    insertBefore(target: Node, child: Node): void;
+    appendChild(el: Node, child: Node): void;
+    callCallback(cb: () => void): void;
+}
+export declare const instantExecutor: InstantExecutor;
+export declare const timeoutExecutor: TimeoutExecutor;

package/types/core/ivalue.d.ts

@@ -0,0 +1,45 @@
+import { Destroyable } from "./destroyable.js";
+/**
+ * Interface which describes a value
+ * @class IValue
+ * @extends Destroyable
+ */
+export declare class IValue<T> extends Destroyable {
+    /**
+     * Is enabled state flag
+     * @protected
+     */
+    protected isEnabled: boolean;
+    /**
+     * @param isEnabled {boolean} initial is enabled state
+     */
+    constructor(isEnabled: boolean);
+    /**
+     * Get the encapsulated value
+     * @return {*} the encapsulated value
+     */
+    get $(): T;
+    /**
+     * Sets the encapsulated value
+     * @param value {*} value to encapsulate
+     */
+    set $(value: T);
+    /**
+     * Add a new handler to value change
+     * @param handler {function(value : *)} the handler to add
+     */
+    on(handler: (value: T) => void): this;
+    /**
+     * Removes a handler of value change
+     * @param handler {function(value : *)} the handler to remove
+     */
+    off(handler: (value: T) => void): this;
+    /**
+     * Enable update handlers triggering
+     */
+    enable(): this;
+    /**
+     * disable update handlers triggering
+     */
+    disable(): this;
+}

package/types/core/signal.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Signal is an event generator
+ * @class Signal
+ */
+export declare class Signal<T1 = void, T2 = void, T3 = void, T4 = void, T5 = void, T6 = void, T7 = void, T8 = void, T9 = void> {
+    /**
+     * Handler of event
+     * @type {Set}
+     * @private
+     */
+    private handlers;
+    /**
+     * Emit event
+     * @param a1 {*} argument
+     * @param a2 {*} argument
+     * @param a3 {*} argument
+     * @param a4 {*} argument
+     * @param a5 {*} argument
+     * @param a6 {*} argument
+     * @param a7 {*} argument
+     * @param a8 {*} argument
+     * @param a9 {*} argument
+     */
+    emit(a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9): void;
+    /**
+     * Subscribe to event
+     * @param func {function} handler
+     */
+    subscribe(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => void): void;
+    /**
+     * Unsubscribe from event
+     * @param func {function} handler
+     */
+    unsubscribe(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => void): void;
+}

package/types/core/slot.d.ts

@@ -0,0 +1,45 @@
+import { Fragment } from "../node/node";
+/**
+ * Component slot
+ * @class Slot
+ */
+export declare class Slot<t1 = void, t2 = void, t3 = void, t4 = void, t5 = void, t6 = void, t7 = void, t8 = void, t9 = void> {
+    /**
+     * Function to run
+     * @type {function(node : Fragment)}
+     */
+    private runner?;
+    /**
+     * Sets the runner
+     * @param func {function} the function to run
+     */
+    insert(func: (a0: Fragment, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void): void;
+    /**
+     * @param a0 {Fragment} node to paste content
+     * @param a1 {*} 1st argument
+     * @param a2 {*} 2nd argument
+     * @param a3 {*} 3rd argument
+     * @param a4 {*} 4th argument
+     * @param a5 {*} 5th argument
+     * @param a6 {*} 6th argument
+     * @param a7 {*} 7th argument
+     * @param a8 {*} 8th argument
+     * @param a9 {*} 9th argument
+     */
+    release(a0: Fragment, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9): void;
+    /**
+     * Predefine a handler for a slot
+     * @param func {function(node : Fragment)} Function to run if no handler specified
+     * @param a0 {Fragment} node to paste content
+     * @param a1 {*} 1st argument
+     * @param a2 {*} 2nd argument
+     * @param a3 {*} 3rd argument
+     * @param a4 {*} 4th argument
+     * @param a5 {*} 5th argument
+     * @param a6 {*} 6th argument
+     * @param a7 {*} 7th argument
+     * @param a8 {*} 8th argument
+     * @param a9 {*} 9th argument
+     */
+    predefine(func: (a0: Fragment, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void, a0: Fragment, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9): void;
+}

package/types/index.d.ts

@@ -1,21 +1,27 @@
-import { Expression } from "./bind.js";
-import { Destroyable } from "./interfaces/destroyable.js";
-import { IBind } from "./interfaces/ibind.js";
-import { IValue } from "./interfaces/ivalue.js";
-import { ArrayModel } from "./models.js";
-import { MapModel } from "./models.js";
-import { ObjectModel } from "./models.js";
-import { SetModel } from "./models.js";
-import { App } from "./node.js";
-import { INode } from "./node.js";
-import { Tag } from "./node.js";
-import { Extension } from "./node.js";
-import { TextNode } from "./node.js";
-import { Component } from "./node.js";
-import { Pointer } from "./value.js";
-import { Reference } from "./value.js";
-import { ArrayView } from "./views.js";
-import { MapView } from "./views.js";
-import { ObjectView } from "./views.js";
-import { SetView } from "./views.js";
-export { Expression, Destroyable, IBind, IValue, ArrayModel, MapModel, ObjectModel, SetModel, App, INode, Tag, Extension, TextNode, Component, Pointer, Reference, ArrayView, MapView, ObjectView, SetView };
+import { Destroyable } from "./core/destroyable";
+import { Executor, InstantExecutor, TimeoutExecutor } from "./core/executor";
+import { Reactive } from "./core/core";
+import { IValue } from "./core/ivalue";
+import { Signal } from "./core/signal";
+import { Slot } from "./core/slot";
+import { ArrayModel } from "./models/array-model";
+import { Listener } from "./models/listener";
+import { MapModel } from "./models/map-model";
+import { ObjectModel } from "./models/object-model";
+import { SetModel } from "./models/set-model";
+import { App, AppNode } from "./node/app";
+import { Interceptor, InterceptorNode } from "./node/interceptor";
+import { Component, Extension, Fragment, INode, Tag } from "./node/node";
+import { Expression } from "./value/expression";
+import { Mirror } from "./value/mirror";
+import { Pointer } from "./value/pointer";
+import { Reference } from "./value/reference";
+import { ArrayView } from "./views/array-view";
+import { BaseView } from "./views/base-view";
+import { MapView } from "./views/map-view";
+import { ObjectView } from "./views/object-view";
+import { RepeatNode } from "./views/repeat-node";
+import { Repeater } from "./views/repeater";
+import { SetView } from "./views/set-view";
+import { Binding } from "./binding/binding";
+export { Destroyable, IValue, Reference, Mirror, Pointer, ArrayModel, MapModel, ObjectModel, SetModel, RepeatNode, Repeater, BaseView, Listener, ArrayView, MapView, ObjectView, SetView, Fragment, INode, Tag, Component, Extension, AppNode, App, Executor, InstantExecutor, TimeoutExecutor, Signal, Slot, Interceptor, InterceptorNode, Expression, Binding, Reactive, };

package/types/models/array-model.d.ts

@@ -0,0 +1,103 @@
+import { Listener } from "./listener";
+import type { IModel } from "./model";
+/**
+ * Model based on Array class
+ * @extends Array
+ * @implements IModel
+ */
+export declare class ArrayModel<T> extends Array<T> implements IModel<T, T> {
+    listener: Listener<T, T>;
+    /**
+     * @param data {Array} input data
+     */
+    constructor(data?: Array<T>);
+    /**
+     * Gets the last item of array
+     * @return {*} the last item of array
+     */
+    get last(): T;
+    /**
+     * Calls Array.fill and notify about changes
+     * @param value {*} value to fill with
+     * @param start {?number} begin index
+     * @param end {?number} end index
+     */
+    fill(value: T, start?: number, end?: number): this;
+    /**
+     * Calls Array.pop and notify about changes
+     * @return {*} removed value
+     */
+    pop(): T;
+    /**
+     * Calls Array.push and notify about changes
+     * @param items {...*} values to push
+     * @return {number} new length of array
+     */
+    push(...items: Array<T>): number;
+    /**
+     * Calls Array.shift and notify about changed
+     * @return {*} the shifted value
+     */
+    shift(): T;
+    /**
+     * Calls Array.splice and notify about changed
+     * @param start {number} start index
+     * @param deleteCount {?number} delete count
+     * @param items {...*}
+     * @return {ArrayModel} a pointer to this
+     */
+    splice(start: number, deleteCount?: number, ...items: Array<T>): ArrayModel<T>;
+    /**
+     * Calls Array.unshift and notify about changed
+     * @param items {...*} values to insert
+     * @return {number} the length after prepend
+     */
+    unshift(...items: Array<T>): number;
+    /**
+     * Inserts a value to the end of array
+     * @param v {*} value to insert
+     */
+    append(v: T): this;
+    /**
+     * Clears array
+     * @return {this} a pointer to this
+     */
+    clear(): this;
+    /**
+     * Inserts a value to position `index`
+     * @param index {number} index to insert value
+     * @param v {*} value to insert
+     * @return {this} a pointer to this
+     */
+    insert(index: number, v: T): this;
+    /**
+     * Inserts a value to the beginning of array
+     * @param v {*} value to insert
+     * @return {this} a pointer to this
+     */
+    prepend(v: T): this;
+    /**
+     * Removes a value from an index
+     * @param index {number} index of value to remove
+     * @return {this} a pointer to this
+     */
+    removeAt(index: number): this;
+    /**
+     * Removes the first value of array
+     * @return {this} a pointer to this
+     */
+    removeFirst(): this;
+    /**
+     * Removes the ast value of array
+     * @return {this} a pointer to this
+     */
+    removeLast(): this;
+    /**
+     * Remove the first occurrence of value
+     * @param v {*} value to remove
+     * @return {this}
+     */
+    removeOne(v: T): this;
+    enableReactivity(): void;
+    disableReactivity(): void;
+}

package/types/models/listener.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Represent a listener for a model
+ * @class Listener
+ */
+export declare class Listener<ValueT, IndexT = string | number> {
+    /**
+     * Functions to run on adding new items
+     * @type Set
+     */
+    private readonly onAdded;
+    /**
+     * Functions to run on item removing
+     * @type Set
+     */
+    private readonly onRemoved;
+    /**
+     * Describe the frozen state of model
+     * @type boolean
+     * @private
+     */
+    private frozen;
+    /**
+     * The queue of operations in frozen state
+     * @type Object[]
+     * @private
+     */
+    private readonly queue;
+    constructor();
+    /**
+     * Exclude the repeated operation in queue
+     * @private
+     */
+    private excludeRepeat;
+    /**
+     * Emits added event to listeners
+     * @param index {*} index of value
+     * @param value {*} value of added item
+     */
+    emitAdded(index: IndexT, value: ValueT): void;
+    /**
+     * Emits removed event to listeners
+     * @param index {*} index of removed value
+     * @param value {*} value of removed item
+     */
+    emitRemoved(index: IndexT, value: ValueT): void;
+    /**
+     * Adds a handler to added event
+     * @param handler {function} function to run on event emitting
+     */
+    onAdd(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Adds a handler to removed event
+     * @param handler {function} function to run on event emitting
+     */
+    onRemove(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Removes an handler from added event
+     * @param handler {function} handler to remove
+     */
+    offAdd(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Removes an handler form removed event
+     * @param handler {function} handler to remove
+     */
+    offRemove(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Run all queued operation and enable reactivity
+     */
+    enableReactivity(): void;
+    /**
+     * Disable the reactivity and enable the queue
+     */
+    disableReactivity(): void;
+}