@igo2/common 19.0.2 → 20.0.0-next.1

package/entity/index.d.ts

@@ -1,5 +1,1534 @@
+import { Observable, ReplaySubject, BehaviorSubject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, OnInit, OnDestroy, EventEmitter, OnChanges, ElementRef, SimpleChanges, TrackByFunction } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { NgControl, NgForm, FormControlName, UntypedFormGroup } from '@angular/forms';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import { MatTableDataSource } from '@angular/material/table';
+
+declare enum EntityOperationType {
+    Insert = "Insert",
+    Update = "Update",
+    Delete = "Delete"
+}
+declare enum EntityTableColumnRenderer {
+    Default = "Default",
+    HTML = "HTML",
+    UnsanitizedHTML = "UnsanitizedHTML",
+    Editable = "Editable",
+    Icon = "Icon",
+    ButtonGroup = "ButtonGroup"
+}
+declare enum EntityTableScrollBehavior {
+    Auto = "auto",
+    Instant = "instant",
+    Smooth = "smooth"
+}
+declare enum EntityTableSelectionState {
+    None = "None",
+    All = "All",
+    Some = "Some"
+}
+
+type EntityKey = string | number;
+type EntityState = Record<string, any>;
+interface EntityRecord<E extends object, S extends EntityState = EntityState> {
+    entity: E;
+    state: S;
+    revision: number;
+    ref: string;
+    edition?: boolean;
+}
+interface EntityStoreStrategyOptions {
+}
+interface EntityStoreStrategyFuncOptions extends EntityStoreStrategyOptions {
+    filterClauseFunc: EntityFilterClause;
+}
+interface EntityTransactionOptions {
+    getKey?: (entity: object) => EntityKey;
+}
+type EntityFilterClause<E = object> = (entity: E) => boolean;
+interface EntitySortClause<E = object> {
+    valueAccessor: (entity: E) => string | number;
+    direction: string;
+    nullsFirst?: boolean;
+}
+interface EntityJoinClause {
+    source: Observable<any | void>;
+    reduce: (param1: object, param2: any) => object;
+}
+interface EntityOperationState {
+    added: boolean;
+    canceled: boolean;
+}
+interface EntityTableTemplate {
+    columns: EntityTableColumn[];
+    selection?: boolean;
+    selectionCheckbox?: boolean;
+    selectMany?: boolean;
+    sort?: boolean;
+    fixedHeader?: boolean;
+    tableHeight?: string;
+    valueAccessor?: (entity: object, property: string, record: EntityRecord<object>) => any;
+    headerClassFunc?: () => Record<string, boolean>;
+    rowClassFunc?: (entity: object, record: EntityRecord<object>) => Record<string, boolean>;
+    cellClassFunc?: (entity: object, column: EntityTableColumn, record: EntityRecord<object>) => Record<string, boolean>;
+}
+interface EntityTableColumnValidation {
+    readonly?: boolean;
+    mandatory?: boolean;
+    maxlength?: number;
+    minlength?: number;
+    minValue?: number;
+    maxValue?: number;
+}
+interface TableRelation {
+    table: string;
+}
+interface EntityTableColumn {
+    validation?: EntityTableColumnValidation;
+    name: string;
+    title: string;
+    renderer?: EntityTableColumnRenderer;
+    valueAccessor?: (entity: object, record: EntityRecord<object>) => any;
+    visible?: boolean;
+    linkColumnForce?: string;
+    sort?: boolean;
+    type?: string;
+    multiple?: boolean;
+    domainValues?: SelectOption[];
+    relation?: TableRelation;
+    tooltip?: string;
+    cellClassFunc?: (entity: object, record: EntityRecord<object>) => Record<string, boolean>;
+    step?: number;
+    icon?: string;
+    onBlur?: (event: Event) => void;
+    onChange?: (event: Event) => void;
+    onClick?: (event: Event) => void;
+    onFocus?: (event: Event) => void;
+}
+interface SelectOption {
+    id: number;
+    value: string;
+    disabled?: boolean;
+}
+interface EntityTableButton {
+    icon: string;
+    click: (entity: object, record: EntityRecord<object>) => void;
+    color?: 'primary' | 'accent' | 'warn';
+    disabled?: boolean;
+    style?: 'mat-mini-fab' | 'mat-icon-button';
+    editMode?: boolean;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Get an entity's named property. Nested properties are supported
+ * with the dotted notation. (i.e 'author.name')
+ *
+ * Note: this method is a 'best attempt' at getting an entity's property.
+ * It fits the most common cases but you might need to explicitely define
+ * a property getter when using an EntityStore, for example.
+ * @param entity Entity
+ * @param property Property name
+ * @returns Property value
  */
-/// <amd-module name="@igo2/common/entity" />
-export * from './public_api';
+declare function getEntityProperty(entity: object, property: string): any;
+/**
+ * Get an entity's id. An entity's id can be one of:
+ * 'entity.meta.id', 'entity.meta.idProperty' or 'entity.id'.
+ *
+ * Note: See the note in the 'getEntityProperty' documentation.
+ * @param entity Entity
+ * @returns Entity id
+ */
+declare function getEntityId(entity: object): EntityKey;
+/**
+ * Get an entity's title. An entity's title can be one of:
+ * 'entity.meta.title', 'entity.meta.titleProperty' or 'entity.title'.
+ * @param entity Entity
+ * @returns Entity title
+ */
+declare function getEntityTitle(entity: object): string;
+/**
+ * Get an entity's HTML title. An entity's HTML title can be one of:
+ * 'entity.meta.titleHtml', 'entity.meta.titleHtmlProperty' or 'entity.titleHtml'.
+ * @param entity Entity
+ * @returns Entity HTML title
+ */
+declare function getEntityTitleHtml(entity: object): string;
+/**
+ * Get an entity's icon. An entity's icon can be one of:
+ * 'entity.meta.icon', 'entity.meta.iconProperty' or 'entity.icon'.
+ * @param entity Entity
+ * @returns Entity icon
+ */
+declare function getEntityIcon(entity: object): string;
+/**
+ * Get an entity's revision.
+ * @param entity Entity
+ * @returns Entity revision
+ */
+declare function getEntityRevision(entity: object): number;
+
+interface EntityStateManagerOptions<E extends object> {
+    getKey?: (entity: object) => EntityKey;
+    index?: Map<EntityKey, E>;
+}
+/**
+ * This class is used to track a store's entities state
+ */
+declare class EntityStateManager<E extends object, S extends EntityState = EntityState> {
+    private options;
+    /**
+     * State index
+     */
+    readonly index: Map<EntityKey, S>;
+    /**
+     * Change emitter
+     */
+    readonly change$: ReplaySubject<void>;
+    /**
+     * Method to get an entity's id
+     */
+    readonly getKey: (E: any) => EntityKey;
+    constructor(options?: EntityStateManagerOptions<E>);
+    /**
+     * Clear state
+     */
+    clear(): void;
+    /**
+     * Get an entity's state
+     * @param entity Entity
+     * @returns State
+     */
+    get(entity: E): S;
+    /**
+     * Set an entity's state
+     * @param entity Entity
+     * @param state State
+     */
+    set(entity: E, state: S): void;
+    /**
+     * Set many entitie's state
+     * @param entitie Entities
+     * @param state State
+     */
+    setMany(entities: E[], state: S): void;
+    /**
+     * Set state of all entities that already have a state. This is not
+     * the same as setting the state of all the store's entities.
+     * @param state State
+     */
+    setAll(state: S): void;
+    /**
+     * Update an entity's state
+     * @param entity Entity
+     * @param changes State changes
+     */
+    update(entity: E, changes: Partial<S>, exclusive?: boolean): void;
+    /**
+     * Update many entitie's state
+     * @param entitie Entities
+     * @param changes State changes
+     */
+    updateMany(entities: E[], changes: Partial<S>, exclusive?: boolean): void;
+    /**
+     * Reversee an entity's state
+     * @param entity Entity
+     * @param keys State keys to reverse
+     */
+    reverse(entity: E, keys: string[]): void;
+    /**
+     * Reverse many entitie's state
+     * @param entitie Entities
+     * @param keys State keys to reverse
+     */
+    reverseMany(entities: E[], keys: string[]): void;
+    /**
+     * Update state of all entities that already have a state. This is not
+     * the same as updating the state of all the store's entities.
+     * @param changes State
+     */
+    updateAll(changes: Partial<S>): void;
+    /**
+     * When some state changes are flagged as 'exclusive', reverse
+     * the state of all other entities. Changes are reversable when
+     * they are boolean.
+     * @param entitie Entities
+     * @param changes State changes
+     */
+    private updateManyExclusive;
+    /**
+     * Compute a 'reversed' version of some state changes.
+     * Changes are reversable when they are boolean.
+     * @param changes State changes
+     * @returns Reversed state changes
+     */
+    private reverseChanges;
+    /**
+     * Return all the keys in that state and in the store it's bound to, if any.
+     * @returns Set of keys
+     */
+    private getAllKeys;
+    /**
+     * Emit 'change' event
+     */
+    private next;
+}
+
+/**
+ * Entity store strategies. They can do pretty much anything during a store's
+ * lifetime. For example, they may act as triggers when something happens.
+ * Sharing a strategy is a good idea when multiple strategies would have
+ * on cancelling effect on each other.
+ *
+ * At creation, strategy is inactive and needs to be manually activated.
+ */
+declare class EntityStoreStrategy {
+    protected options: EntityStoreStrategyOptions;
+    /**
+     * Feature store
+     * @internal
+     */
+    protected stores: EntityStore[];
+    /**
+     * Whether this strategy is active
+     * @internal
+     */
+    get active(): boolean;
+    readonly active$: BehaviorSubject<boolean>;
+    constructor(options?: EntityStoreStrategyOptions);
+    /**
+     * Activate the strategy. If it's already active, it'll be deactivated
+     * and activated again.
+     */
+    activate(): void;
+    /**
+     * Activate the strategy. If it's already active, it'll be deactivated
+     * and activated again.
+     */
+    deactivate(): void;
+    /**
+     * Bind this strategy to a store
+     * @param store Feature store
+     */
+    bindStore(store: EntityStore): void;
+    /**
+     * Unbind this strategy from store
+     * @param store Feature store
+     */
+    unbindStore(store: EntityStore): void;
+    /**
+     * Do the stataegy activation
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Do the strategy deactivation
+     * @internal
+     */
+    protected doDeactivate(): void;
+}
+
+/**
+ * An entity view streams entities from an observable source. These entities
+ * can be filtered or sorted without affecting the source. A view can also
+ * combine data from multiple sources, joined together.
+ */
+declare class EntityView<E extends object, V extends object = E> {
+    private source$;
+    /**
+     * Observable stream of values
+     */
+    readonly values$: BehaviorSubject<V[]>;
+    /**
+     * Subscription to the source (and joined sources) values
+     */
+    private values$$;
+    /**
+     * Whether this view has been lifted
+     */
+    private lifted;
+    /**
+     * Join clauses
+     */
+    private joins;
+    /**
+     * Observable of a filter clause
+     */
+    private filter$;
+    /**
+     * Observable of filter clauses
+     */
+    private filters$;
+    /**
+     * Filters index
+     */
+    private filterIndex;
+    /**
+     * Observable of a sort clause
+     */
+    private sort$;
+    /**
+     * Method for indexing
+     */
+    get getKey(): (V: any) => EntityKey;
+    private getKey$;
+    /**
+     * Number of entities
+     */
+    readonly count$: BehaviorSubject<number>;
+    get count(): number;
+    /**
+     * Whether the store is empty
+     */
+    readonly empty$: BehaviorSubject<boolean>;
+    get empty(): boolean;
+    /**
+     * Store index
+     */
+    get index(): Map<EntityKey, V>;
+    private _index;
+    constructor(source$: BehaviorSubject<E[]>);
+    /**
+     * Get a value from the view by key
+     * @param key Key
+     * @returns Value
+     */
+    get(key: EntityKey): V;
+    /**
+     * Get all the values
+     * @returns Array of values
+     */
+    all(): V[];
+    /**
+     * Observe all the values
+     * @returns Observable of values
+     */
+    all$(): BehaviorSubject<V[]>;
+    /**
+     * Get the first value that respects a criteria
+     * @returns A value
+     */
+    firstBy(clause: EntityFilterClause<V>): V;
+    /**
+     * Observe the first value that respects a criteria
+     * @returns Observable of a value
+     */
+    firstBy$(clause: EntityFilterClause<V>): Observable<V>;
+    /**
+     * Get all the values that respect a criteria
+     * @returns Array of values
+     */
+    manyBy(clause: EntityFilterClause<V>): V[];
+    /**
+     * Observe all the values that respect a criteria
+     * @returns Observable of values
+     */
+    manyBy$(clause: EntityFilterClause<V>): Observable<V[]>;
+    /**
+     * Clear the filter and sort and unsubscribe from the source
+     */
+    clear(): void;
+    destroy(): void;
+    /**
+     * Create an index
+     * @param getKey Method to get a value's id
+     * @returns The view
+     */
+    createIndex(getKey: (E: any) => EntityKey): EntityView<E, V>;
+    /**
+     * Join another source to the stream (chainable)
+     * @param clause Join clause
+     * @returns The view
+     */
+    join(clause: EntityJoinClause): EntityView<E, V>;
+    /**
+     * Filter values (chainable)
+     * @param clause Filter clause
+     * @returns The view
+     */
+    filter(clause: EntityFilterClause<V>): EntityView<E, V>;
+    /**
+     * @param clause Filter clause
+     * @returns The filter id
+     */
+    addFilter(clause: EntityFilterClause<V>): string;
+    /**
+     * Remove a filter by id
+     * @param clause Filter clause
+     */
+    removeFilter(id: string): void;
+    /**
+     * Sort values (chainable)
+     * @param clauseSort clause
+     * @returns The view
+     */
+    sort(clause: EntitySortClause<V>): EntityView<E, V>;
+    /**
+     * Create the final observable
+     * @returns Observable
+     */
+    lift(): void;
+    /**
+     * Create the source observable when no joins are defined
+     * @returns Observable
+     */
+    private liftSource;
+    /**
+     * Create the source observable when joins are defined
+     * @returns Observable
+     */
+    private liftJoinedSource;
+    /**
+     * Apply joins to a source's entity and return the final value
+     * @returns Final value
+     */
+    private computeJoinedValue;
+    /**
+     * Filter and sort values before streaming them
+     * @param values Values
+     * @param filters Filter clauses
+     * @param filter Filter clause
+     * @param sort Sort clause
+     * @returns Filtered and sorted values
+     */
+    private processValues;
+    /**
+     * Filter values
+     * @param values Values
+     * @param filters Filter clauses
+     * @returns Filtered values
+     */
+    private filterValues;
+    /**
+     * Sort values
+     * @param values Values
+     * @param sort Sort clause
+     * @returns Sorted values
+     */
+    private sortValues;
+    /**
+     * Set value and optionally generate an index
+     * @param values Values
+     * @param generateIndex boolean
+     */
+    private setValues;
+    /**
+     * Generate a complete index of all the values
+     * @param entities Entities
+     * @returns Index
+     */
+    private generateIndex;
+}
+
+interface EntityStoreOptions {
+    getKey?: (entity: object) => EntityKey;
+    getProperty?: (entity: object, property: string) => any;
+}
+/**
+ * An entity store class holds any number of entities
+ * as well as their state. It can be observed, filtered and sorted and
+ * provides methods to insert, update or delete entities.
+ */
+declare class EntityStore<E extends object = object, S extends EntityState = EntityState> {
+    /**
+     * Observable of the raw entities
+     */
+    readonly entities$: BehaviorSubject<E[]>;
+    /**
+     * Number of entities
+     */
+    readonly count$: BehaviorSubject<number>;
+    get count(): number;
+    /**
+     * Whether the store is empty
+     */
+    readonly empty$: BehaviorSubject<boolean>;
+    get empty(): boolean;
+    /**
+     * Entity store state
+     */
+    readonly state: EntityStateManager<E, S>;
+    /**
+     * View of all the entities
+     */
+    readonly view: EntityView<E>;
+    /**
+     * View of all the entities and their state
+     */
+    readonly stateView: EntityView<E, EntityRecord<E, S>>;
+    /**
+     * Method to get an entity's id
+     */
+    readonly getKey: (E: any) => EntityKey;
+    /**
+     * Method to get an entity's named property
+     */
+    readonly getProperty: (E: any, prop: string) => any;
+    /**
+     * Store index
+     */
+    get index(): Map<EntityKey, E>;
+    private _index;
+    /**
+     * Store index
+     */
+    get pristine(): boolean;
+    private _pristine;
+    /**
+     * Strategies
+     */
+    private strategies;
+    constructor(entities: E[], options?: EntityStoreOptions);
+    /**
+     * Get an entity from the store by key
+     * @param key Key
+     * @returns Entity
+     */
+    get(key: EntityKey): E;
+    /**
+     * Get all entities in the store
+     * @returns Array of entities
+     */
+    all(): E[];
+    /**
+     * Set this store's entities
+     * @param entities Entities
+     */
+    load(entities: E[], pristine?: boolean): void;
+    /**
+     * Clear the store's entities but keep the state and views intact.
+     * Views won't return any data but future data will be subject to the
+     * current views filter and sort
+     */
+    softClear(): void;
+    /**
+     * Clear the store's entities, state and views
+     */
+    clear(): void;
+    destroy(): void;
+    /**
+     * Insert an entity into the store
+     * @param entity Entity
+     */
+    insert(entity: E): void;
+    /**
+     * Insert many entities into the store
+     * @param entities Entities
+     */
+    insertMany(entities: E[]): void;
+    /**
+     * Update or insert an entity into the store
+     * @param entity Entity
+     */
+    update(entity: E): void;
+    /**
+     * Update or insert many entities into the store
+     * @param entities Entities
+     */
+    updateMany(entities: E[]): void;
+    /**
+     * Add a strategy to this store
+     * @param strategy Entity store strategy
+     * @returns Entity store
+     */
+    addStrategy(strategy: EntityStoreStrategy, activate?: boolean): EntityStore;
+    /**
+     * Remove a strategy from this store
+     * @param strategy Entity store strategy
+     * @returns Entity store
+     */
+    removeStrategy(strategy: EntityStoreStrategy): EntityStore;
+    /**
+     * Return strategies of a given type
+     * @param type Entity store strategy class
+     * @returns Strategies
+     */
+    getStrategyOfType(type: typeof EntityStoreStrategy): EntityStoreStrategy;
+    /**
+     * Activate strategies of a given type
+     * @param type Entity store strategy class
+     */
+    activateStrategyOfType(type: typeof EntityStoreStrategy): void;
+    /**
+     * Deactivate strategies of a given type
+     * @param type Entity store strategy class
+     */
+    deactivateStrategyOfType(type: typeof EntityStoreStrategy): void;
+    /**
+     * Delete an entity from the store
+     * @param entity Entity
+     */
+    delete(entity: E): void;
+    /**
+     * Delete many entities from the store
+     * @param entities Entities
+     */
+    deleteMany(entities: E[]): void;
+    /**
+     * Generate a complete index of all the entities
+     * @param entities Entities
+     * @returns Index
+     */
+    private generateIndex;
+    /**
+     * Push the index's entities into the entities$ observable
+     */
+    private next;
+    /**
+     * Update the store's count and empty
+     */
+    private updateCount;
+    /**
+     * Create the entity state manager
+     * @returns EntityStateManager
+     */
+    private createStateManager;
+    /**
+     * Create the data view
+     * @returns EntityView<E>
+     */
+    private createDataView;
+    /**
+     * Create the state view
+     * @returns EntityView<EntityRecord<E>>
+     */
+    private createStateView;
+    private statesAreTheSame;
+}
+
+/**
+ * This class is used to synchronize a component's changes
+ * detection with an EntityStore changes. For example, it is frequent
+ * to have a component subscribe to a store's selected entity and, at the same time,
+ * this component provides a way to select an entity with, let's say, a click.
+ *
+ * This class automatically handles those case and triggers the compoent's
+ * change detection when needed.
+ *
+ * Note: If the component observes the store's stateView, a workspace is
+ * probably not required because the stateView catches any changes to the
+ * entities and their state.
+ */
+declare class EntityStoreWatcher<E extends object> {
+    /**
+     * Component change detector
+     */
+    private cdRef;
+    /**
+     * Entity store
+     */
+    private store;
+    /**
+     * Component inner state
+     */
+    private innerStateIndex;
+    /**
+     * Subscription to the store's entities
+     */
+    private entities$$;
+    /**
+     * Subscription to the store's state
+     */
+    private state$$;
+    constructor(store?: EntityStore<E>, cdRef?: ChangeDetectorRef);
+    destroy(): void;
+    /**
+     * Bind this workspace to a store and start watching for changes
+     * @param store Entity store
+     */
+    setStore(store?: EntityStore<E>): void;
+    /**
+     * Bind this workspace to a component's change detector
+     * @param cdRef Change detector
+     */
+    setChangeDetector(cdRef?: ChangeDetectorRef): void;
+    /**
+     * Set up observers on a store's entities and their state
+     * @param store Entity store
+     */
+    private setupObservers;
+    /**
+     * Teardown store observers
+     */
+    private teardownObservers;
+    /**
+     * When the entities change, always trigger the changes detection
+     */
+    private onEntitiesChange;
+    /**
+     * When the entities state change, trigger the change detection
+     * only if the component has not handled these changes yet. For example,
+     * the component might have initiated thoses changes itself.
+     */
+    private onStateChange;
+    /**
+     * Trigger the change detection of the workspace is bound to a change detector
+     */
+    private detectChanges;
+}
+
+interface EntityOperation<E extends object = object> {
+    key: EntityKey;
+    type: EntityOperationType;
+    previous: E | undefined;
+    current: E | undefined;
+    store?: EntityStore<E>;
+    meta?: Record<string, any>;
+}
+type EntityTransactionCommitHandler = (transaction: EntityTransaction, operations: EntityOperation[]) => Observable<any>;
+/**
+ * This class holds a reference to the insert, update and delete
+ * operations performed on a store. This is useful to commit
+ * these operations in a single pass or to cancel them.
+ */
+declare class EntityTransaction {
+    /**
+     * Store holding the operations on another store
+     */
+    readonly operations: EntityStore<EntityOperation, EntityOperationState>;
+    /**
+     * Method to get an entity's id
+     */
+    readonly getKey: (E: any) => EntityKey;
+    /**
+     * Whether there are pending operations
+     */
+    get empty$(): BehaviorSubject<boolean>;
+    /**
+     * Whether there are pending operations
+     */
+    get empty(): boolean;
+    /**
+     * Whether thise store is in commit phase
+     */
+    get inCommitPhase(): boolean;
+    readonly inCommitPhase$: BehaviorSubject<boolean>;
+    constructor(options?: EntityTransactionOptions);
+    destroy(): void;
+    /**
+     * Insert an entity into a store. If no store is specified, an insert
+     * operation is still created but the transaction won't add the new
+     * entity to the store.
+     * @param current The entity to insert
+     * @param store Optional: The store to insert the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    insert(current: object, store?: EntityStore<object>, meta?: Record<string, any>): void;
+    /**
+     * Update an entity in a store. If no store is specified, an update
+     * operation is still created but the transaction won't update the
+     * entity into the store.
+     * @param previous The entity before update
+     * @param current The entity after update
+     * @param store Optional: The store to update the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    update(previous: object, current: object, store?: EntityStore<object>, meta?: Record<string, any>): void;
+    /**
+     * Delete an entity from a store. If no store is specified, a delete
+     * operation is still created but the transaction won't remove the
+     * entity from the store.
+     * @param previous The entity before delete
+     * @param store Optional: The store to delete the entity from
+     * @param meta Optional: Any metadata on the operation
+     */
+    delete(previous: object, store?: EntityStore<object>, meta?: Record<string, any>): void;
+    /**
+     * Commit operations the transaction. This method doesn't do much
+     * in itself. The handler it receives does the hard work and it's
+     * implementation is left to the caller. This method simply wraps
+     * the handler into an error catching mechanism to update
+     * the transaction afterward. The caller needs to subscribe to this
+     * method's output (observable) for the commit to be performed.
+     * @param operations Operations to commit
+     * @param handler Function that handles the commit operation
+     * @returns The handler output (observable)
+     */
+    commit(operations: EntityOperation[], handler: EntityTransactionCommitHandler): Observable<any>;
+    /**
+     * Commit all the operations of the transaction.
+     * @param handler Function that handles the commit operation
+     * @returns The handler output (observable)
+     */
+    commitAll(handler: EntityTransactionCommitHandler): Observable<any>;
+    /**
+     * Rollback this transaction
+     */
+    rollback(): void;
+    /**
+     * Rollback specific operations
+     */
+    rollbackOperations(operations: EntityOperation[]): void;
+    /**
+     * Clear this transaction
+     * @todo Raise event and synchronize stores?
+     */
+    clear(): void;
+    /**
+     * Get any existing operation on an entity
+     * @param entity Entity
+     * @returns Either an insert, update or delete operation
+     */
+    getOperationByEntity(entity: object): EntityOperation;
+    /**
+     * Merge another transaction in this one
+     * @param transaction Another transaction
+     */
+    mergeTransaction(transaction: EntityTransaction): void;
+    /**
+     * Create an insert operation and add an entity to the store
+     * @param current The entity to insert
+     * @param store Optional: The store to insert the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    private doInsert;
+    /**
+     * Create an update operation and update an entity into the store
+     * @param previous The entity before update
+     * @param current The entity after update
+     * @param store Optional: The store to update the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    private doUpdate;
+    /**
+     * Create a delete operation and delete an entity from the store
+     * @param previous The entity before delete
+     * @param store Optional: The store to delete the entity from
+     * @param meta Optional: Any metadata on the operation
+     */
+    private doDelete;
+    /**
+     * Remove committed operations from store
+     * @param operations Commited operations
+     * @todo Raise event and synchronize stores?
+     */
+    private resolveOperations;
+    /**
+     * On commit success, resolve commited operations and exit commit phase
+     * @param operations Commited operations
+     */
+    private onCommitSuccess;
+    /**
+     * On commit error, abort transaction
+     * @param operations Commited operations
+     */
+    private onCommitError;
+    /**
+     * Add an operation to the operations store
+     * @param operation Operation to add
+     */
+    private addOperation;
+    /**
+     * Remove an operation from the operations store
+     * @param operation Operation to remove
+     */
+    private removeOperation;
+    /**
+     * Get all the operations to commit
+     * @returns Operations to commit
+     */
+    private getOperationsInCommit;
+    /**
+     * Check if the transaction is in the commit phase and throw an error if it is
+     */
+    private checkInCommitPhase;
+}
+
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+declare class EntityStoreFilterCustomFuncStrategy extends EntityStoreStrategy {
+    protected options: EntityStoreStrategyFuncOptions;
+    constructor(options: EntityStoreStrategyFuncOptions);
+    /**
+     * Store / filter ids map
+     */
+    private filters;
+    /**
+     * Bind this strategy to a store and start filtering it
+     * @param store Entity store
+     */
+    bindStore(store: EntityStore): void;
+    /**
+     * Unbind this strategy from a store and stop filtering it
+     * @param store Entity store
+     */
+    unbindStore(store: EntityStore): void;
+    /**
+     * Start filtering all stores
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Stop filtering all stores
+     * @internal
+     */
+    protected doDeactivate(): void;
+    /**
+     * Filter all stores
+     */
+    private filterAll;
+    /**
+     * Unfilter all stores
+     */
+    private unfilterAll;
+    /**
+     * Filter a store and add it to the filters map
+     */
+    private filterStore;
+    /**
+     * Unfilter a store and delete it from the filters map
+     */
+    private unfilterStore;
+}
+
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+declare class EntityStoreFilterSelectionStrategy extends EntityStoreStrategy {
+    /**
+     * Store / filter ids map
+     */
+    private filters;
+    /**
+     * Bind this strategy to a store and start filtering it
+     * @param store Entity store
+     */
+    bindStore(store: EntityStore): void;
+    /**
+     * Unbind this strategy from a store and stop filtering it
+     * @param store Entity store
+     */
+    unbindStore(store: EntityStore): void;
+    /**
+     * Start filtering all stores
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Stop filtering all stores
+     * @internal
+     */
+    protected doDeactivate(): void;
+    /**
+     * Filter all stores
+     */
+    private filterAll;
+    /**
+     * Unfilter all stores
+     */
+    private unfilterAll;
+    /**
+     * Filter a store and add it to the filters map
+     */
+    private filterStore;
+    /**
+     * Unfilter a store and delete it from the filters map
+     */
+    private unfilterStore;
+}
+
+interface EntitySelectorChange<T = any> {
+    selected: boolean;
+    value: T;
+}
+declare class EntitySelectorComponent implements OnInit, OnDestroy {
+    private cdRef;
+    /**
+     * The selected entity
+     * @internal
+     */
+    readonly selected$: BehaviorSubject<object>;
+    /**
+     * The current multi select option text
+     * @internal
+     */
+    readonly multiText$: BehaviorSubject<string>;
+    readonly multiSelectValue: {
+        id: string;
+    };
+    readonly emptyValue: {
+        id: string;
+    };
+    /**
+     * Subscription to the selected entity
+     */
+    private selected$$;
+    /**
+     * Store watcher
+     */
+    private watcher;
+    /**
+     * Entity store
+     */
+    store: EntityStore<object>;
+    /**
+     * Title accessor
+     */
+    titleAccessor: (object: any) => string;
+    /**
+     * Text to display when nothing is selected
+     */
+    emptyText: string;
+    /**
+     * Wheter selecting many entities is allowed
+     */
+    multi: boolean;
+    /**
+     * Text to display for the select all option
+     */
+    multiAllText: string;
+    /**
+     * Text to display for the select none option
+     */
+    multiNoneText: string;
+    /**
+     * Field placeholder
+     */
+    placeholder: string;
+    /**
+     * Wheter the selector is disabled or not
+     */
+    disabled: boolean;
+    /**
+     * Event emitted when the selection changes
+     */
+    selectedChange: EventEmitter<EntitySelectorChange<any>>;
+    /**
+     * Create a store watcher and subscribe to the selected entity
+     * @internal
+     */
+    ngOnInit(): void;
+    /**
+     * Unsubscribe to the selected entity and destroy the store watcher
+     * @internal
+     */
+    ngOnDestroy(): void;
+    /**
+     * On selection change, update the store's state and emit an event
+     * @internal
+     */
+    onSelectionChange(event: {
+        value: object | undefined;
+    }): void;
+    private onSelectFromStore;
+    private updateMultiToggleWithEntities;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntitySelectorComponent, "igo-entity-selector", never, { "store": { "alias": "store"; "required": false; }; "titleAccessor": { "alias": "titleAccessor"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "multi": { "alias": "multi"; "required": false; }; "multiAllText": { "alias": "multiAllText"; "required": false; }; "multiNoneText": { "alias": "multiNoneText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the EntitySelectorComponent directly
+ */
+declare class IgoEntitySelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntitySelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntitySelectorModule, never, [typeof EntitySelectorComponent], [typeof EntitySelectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntitySelectorModule>;
+}
+
+interface EntityTablePaginatorOptions {
+    disabled?: boolean;
+    hidePageSize?: boolean;
+    pageIndex?: number;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showFirstLastButtons?: boolean;
+}
+
+type CellData = Record<string, {
+    value: any;
+    class: Record<string, boolean>;
+    isUrl: boolean;
+    isImg: boolean;
+}>;
+interface RowData {
+    record: EntityRecord<object, EntityState>;
+    cellData: CellData;
+}
+declare class EntityTableComponent implements OnInit, OnChanges, OnDestroy {
+    private cdRef;
+    private formBuilder;
+    protected _focusMonitor: FocusMonitor;
+    protected _elementRef: ElementRef<HTMLElement>;
+    ngControl: NgControl;
+    protected _parentForm: NgForm;
+    protected _controlName: FormControlName;
+    protected _defaultErrorStateMatcher: ErrorStateMatcher;
+    private dateAdapter;
+    entitySortChange$: BehaviorSubject<boolean>;
+    formGroup: UntypedFormGroup;
+    filteredOptions: {};
+    /**
+     * Reference to the column renderer types
+     * @internal
+     */
+    entityTableColumnRenderer: typeof EntityTableColumnRenderer;
+    /**
+     * Reference to the selection's state
+     * @internal
+     */
+    entityTableSelectionState: typeof EntityTableSelectionState;
+    /**
+     * Observable of the selection,s state
+     * @internal
+     */
+    readonly selectionState$: BehaviorSubject<EntityTableSelectionState>;
+    /**
+     * Subscription to the store's selection
+     */
+    private selection$$;
+    /**
+     * Subscription to the dataSource
+     */
+    private dataSource$$;
+    /**
+     * The last record checked. Useful for selecting
+     * multiple records by holding the shift key and checking
+     * checkboxes.
+     */
+    private lastRecordCheckedKey;
+    /**
+     * Entity store
+     */
+    store: EntityStore<object>;
+    /**
+     * Table paginator
+     */
+    set paginator(value: MatPaginator);
+    get paginator(): MatPaginator;
+    private _paginator;
+    /**
+     * Table template
+     */
+    template: EntityTableTemplate;
+    /**
+     * Scroll behavior on selection
+     */
+    scrollBehavior: EntityTableScrollBehavior;
+    /**
+     * Whether nulls should be first when sorting
+     */
+    sortNullsFirst: boolean;
+    /**
+     * Show the table paginator or not. False by default.
+     */
+    withPaginator: boolean;
+    /**
+     * Paginator options
+     */
+    paginatorOptions: EntityTablePaginatorOptions;
+    /**
+     * Event emitted when an entity (row) is clicked
+     */
+    entityClick: EventEmitter<object>;
+    /**
+     * Event emitted when an entity (row) is selected
+     */
+    entitySelectChange: EventEmitter<{
+        added: object[];
+    }>;
+    /**
+     * Event emitted when the table sort is changed.
+     */
+    entitySortChange: EventEmitter<{
+        column: EntityTableColumn;
+        direction: string;
+    }>;
+    /**
+     * Table headers
+     * @internal
+     */
+    get headers(): string[];
+    /**
+     * Data source consumable by the underlying material table
+     * @internal
+     */
+    dataSource: MatTableDataSource<RowData, MatPaginator>;
+    /**
+     * Whether selection is supported
+     * @internal
+     */
+    get selection(): boolean;
+    /**
+     * Whether a selection checkbox should be displayed
+     * @internal
+     */
+    get selectionCheckbox(): boolean;
+    /**
+     * Whether selection many entities should eb supported
+     * @internal
+     */
+    get selectMany(): boolean;
+    /**
+     * Whether selection many entities should eb supported
+     * @internal
+     */
+    get fixedHeader(): boolean;
+    get tableHeight(): string;
+    constructor();
+    /**
+     * Track the selection state to properly display the selection checkboxes
+     * @internal
+     */
+    ngOnInit(): void;
+    /**
+     * @internal
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Process text or number value change (edition)
+     */
+    onValueChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process boolean value change (edition)
+     */
+    onBooleanValueChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process select value change (edition)
+     */
+    onSelectValueChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process autocomplete value change (edition)
+     */
+    onAutocompleteValueChange(column: EntityTableColumn, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process date value change (edition)
+     */
+    onDateChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Enable edition mode for one row
+     * More than one row can be edited at the same time
+     */
+    private enableEdit;
+    private handleDatasource;
+    /**
+     * Unbind the store watcher
+     * @internal
+     */
+    ngOnDestroy(): void;
+    private unsubscribeStore;
+    /**
+     * Trackby function
+     * @param record Record
+     * @param index Record index
+     * @internal
+     */
+    getTrackByFunction(): TrackByFunction<RowData>;
+    /**
+     * Trigger a refresh of the table. This can be useful when
+     * the data source doesn't emit a new value but for some reason
+     * the records need an update.
+     * @internal
+     */
+    refresh(): void;
+    paginatorChange(event: MatPaginator): void;
+    /**
+     * On sort, sort the store
+     * @param event Sort event
+     * @internal
+     */
+    onSort(event: {
+        active: string;
+        direction: string;
+    }): void;
+    /**
+     * When an entity is clicked, emit an event
+     * @param record Record
+     * @internal
+     */
+    onRowClick(record: EntityRecord<object>): void;
+    /**
+     * When an entity is selected, select it in the store and emit an event. Even if
+     * "many" is set to true, this method always select a single, exclusive row. Selecting
+     * multiple rows should be achieved by using the checkboxes.
+     * @param record Record
+     * @internal
+     */
+    onRowSelect(record: EntityRecord<object>): void;
+    /**
+     * Select or unselect all rows at once. On select, emit an event.
+     * @param toggle Select or unselect
+     * @internal
+     */
+    onToggleRows(toggle: boolean): void;
+    /**
+     * When an entity is toggled, select or unselect it in the store. On select,
+     * emit an event.
+     * @param toggle Select or unselect
+     * @param record Record
+     * @internal
+     */
+    onToggleRow(toggle: boolean, record: EntityRecord<object>): void;
+    /**
+     * When an entity is toggled, select or unselect it in the store. On select,
+     * emit an event.
+     * @param toggle Select or unselect
+     * @param record Record
+     * @internal
+     */
+    onShiftToggleRow(toggle: boolean, record: EntityRecord<object>, event: MouseEvent): void;
+    /**
+     * Compute the selection state
+     * @returns Whether all, some or no rows are selected
+     * @internal
+     */
+    private computeSelectionState;
+    /**
+     * Whether a column is sortable
+     * @param column Column
+     * @returns True if a column is sortable
+     * @internal
+     */
+    columnIsSortable(column: EntityTableColumn): boolean;
+    /**
+     * Whether a row is should be selected based on the underlying entity state
+     * @param record Record
+     * @returns True if a row should be selected
+     * @internal
+     */
+    rowIsSelected(record: EntityRecord<object>): boolean;
+    isImg(value: any): boolean;
+    isUrl(value: any): boolean;
+    /**
+     * Method to access an entity's values
+     * @param record Record
+     * @param column Column
+     * @returns Any value
+     * @internal
+     */
+    getValue(record: EntityRecord<object>, column: EntityTableColumn): any;
+    /**
+     * Method to access an entity's validation values
+     * @param column Column
+     * @param validationType string
+     * @returns Any value (false if no validation or not the one concerned)
+     * @internal
+     */
+    getValidationAttributeValue(column: EntityTableColumn, validationType: string): any;
+    isEdition(record: any): boolean;
+    /**
+     * Return the type of renderer of a column
+     * @param column Column
+     * @returns Renderer type
+     * @internal
+     */
+    getColumnRenderer(column: EntityTableColumn): EntityTableColumnRenderer;
+    /**
+     * Return the table ngClass
+     * @returns ngClass
+     * @internal
+     */
+    getTableClass(): Record<string, boolean>;
+    /**
+     * Return a header ngClass
+     * @returns ngClass
+     * @internal
+     */
+    getHeaderClass(): Record<string, boolean>;
+    /**
+     * Return a row ngClass
+     * @param record Record
+     * @returns ngClass
+     * @internal
+     */
+    getRowClass(record: EntityRecord<object>): Record<string, boolean>;
+    /**
+     * Return a row ngClass
+     * @param record Record
+     * @param column Column
+     * @returns ngClass
+     * @internal
+     */
+    getCellClass(record: EntityRecord<object>, column: EntityTableColumn): Record<string, boolean>;
+    /**
+     * When a button is clicked
+     * @param func Function
+     * @param record Record
+     * @internal
+     */
+    onButtonClick(clickFunc: (entity: object, record?: EntityRecord<object>) => void, record: EntityRecord<object>): void;
+    /**
+     * Retrieve column name without his "properties" tag (useful for edition workspace properties)
+     */
+    getColumnKeyWithoutPropertiesTag(column: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityTableComponent, "igo-entity-table", never, { "store": { "alias": "store"; "required": false; }; "paginator": { "alias": "paginator"; "required": false; }; "template": { "alias": "template"; "required": false; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; }; "sortNullsFirst": { "alias": "sortNullsFirst"; "required": false; }; "withPaginator": { "alias": "withPaginator"; "required": false; }; "paginatorOptions": { "alias": "paginatorOptions"; "required": false; }; }, { "entityClick": "entityClick"; "entitySelectChange": "entitySelectChange"; "entitySortChange": "entitySortChange"; }, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the EntityTableComponent directly
+ */
+declare class IgoEntityTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntityTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntityTableModule, never, [typeof EntityTableComponent], [typeof EntityTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntityTableModule>;
+}
+
+declare class EntityTablePaginatorComponent implements OnChanges, OnDestroy {
+    private languageService;
+    private mediaService;
+    disabled: boolean;
+    hidePageSize: boolean;
+    pageIndex: number;
+    pageSize: number;
+    pageSizeOptions: number[];
+    showFirstLastButtons: boolean;
+    private count$$;
+    private entitySortChange$$;
+    private paginationLabelTranslation$$;
+    entitySortChange$: BehaviorSubject<boolean>;
+    /**
+     * Entity store
+     */
+    store: EntityStore<object>;
+    /**
+     * Paginator options
+     */
+    paginatorOptions: EntityTablePaginatorOptions;
+    /**
+     * Event emitted when the paginator changes the page size or page index.
+     */
+    page: EventEmitter<PageEvent>;
+    length: number;
+    /**
+     * Paginator emitted.
+     */
+    paginatorChange: EventEmitter<MatPaginator>;
+    paginator: MatPaginator;
+    ngOnChanges(): void;
+    initPaginatorOptions(): void;
+    translateLabels(): void;
+    rangeLabel: (page: number, pageSize: number, length: number) => string;
+    private unsubscribeAll;
+    ngOnDestroy(): void;
+    emitPaginator(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTablePaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityTablePaginatorComponent, "igo-entity-table-paginator", never, { "entitySortChange$": { "alias": "entitySortChange$"; "required": false; }; "store": { "alias": "store"; "required": false; }; "paginatorOptions": { "alias": "paginatorOptions"; "required": false; }; }, { "page": "page"; "paginatorChange": "paginatorChange"; }, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the EntityTablePaginatorComponent directly
+ */
+declare class IgoEntityTablePaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntityTablePaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntityTablePaginatorModule, never, [typeof EntityTablePaginatorComponent], [typeof EntityTablePaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntityTablePaginatorModule>;
+}
+
+declare const ENTITY_DIRECTIVES: readonly [typeof EntitySelectorComponent, typeof EntityTableComponent, typeof EntityTablePaginatorComponent];
+/**
+ * @deprecated import the components directly or ENTITY_DIRECTIVES for every components/directives
+ */
+declare class IgoEntityModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntityModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntityModule, never, [typeof EntitySelectorComponent, typeof EntityTableComponent, typeof EntityTablePaginatorComponent], [typeof EntitySelectorComponent, typeof EntityTableComponent, typeof EntityTablePaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntityModule>;
+}
+
+export { ENTITY_DIRECTIVES, EntityOperationType, EntitySelectorComponent, EntityStateManager, EntityStore, EntityStoreFilterCustomFuncStrategy, EntityStoreFilterSelectionStrategy, EntityStoreStrategy, EntityStoreWatcher, EntityTableColumnRenderer, EntityTableComponent, EntityTablePaginatorComponent, EntityTableScrollBehavior, EntityTableSelectionState, EntityTransaction, EntityView, IgoEntityModule, IgoEntitySelectorModule, IgoEntityTableModule, IgoEntityTablePaginatorModule, getEntityIcon, getEntityId, getEntityProperty, getEntityRevision, getEntityTitle, getEntityTitleHtml };
+export type { EntityFilterClause, EntityJoinClause, EntityKey, EntityOperation, EntityOperationState, EntityRecord, EntitySelectorChange, EntitySortClause, EntityState, EntityStoreOptions, EntityStoreStrategyFuncOptions, EntityStoreStrategyOptions, EntityTableButton, EntityTableColumn, EntityTableColumnValidation, EntityTablePaginatorOptions, EntityTableTemplate, EntityTransactionCommitHandler, EntityTransactionOptions, SelectOption, TableRelation };