@rentman/rm-core 1.7.3 → 1.7.5

package/dist/src/interfaces/LocalCacheManagerInterface.d.ts

@@ -1,5 +1,5 @@
-import { LocalCache } from '../classes';
-export interface LocalCacheManagerInterface {
-    getCurrentLocalCache(userId: string): LocalCache;
-    getAllLocalCaches(): LocalCache[];
-}
+import { LocalCache } from '../classes';
+export interface LocalCacheManagerInterface {
+    getCurrentLocalCache(userId: string): LocalCache;
+    getAllLocalCaches(): LocalCache[];
+}

package/dist/src/interfaces/PromiseLibraryInterface.d.ts

@@ -1,25 +1,25 @@
-import { PromiseInterface } from '../types';
-export interface Deferred<T> {
-    resolve(value?: T | PromiseInterface<T>): void;
-    reject(reason?: any): void;
-    promise: PromiseInterface<T>;
-}
-export interface PromiseLibraryInterface {
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>, T10 | PromiseInterface<T10>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
-    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8]>;
-    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7]>;
-    all<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>]): PromiseInterface<[T1, T2, T3, T4, T5, T6]>;
-    all<T1, T2, T3, T4, T5>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>]): PromiseInterface<[T1, T2, T3, T4, T5]>;
-    all<T1, T2, T3, T4>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>]): PromiseInterface<[T1, T2, T3, T4]>;
-    all<T1, T2, T3>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>]): PromiseInterface<[T1, T2, T3]>;
-    all<T1, T2>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>]): PromiseInterface<[T1, T2]>;
-    all<TAll>(promises: Array<TAll | PromiseInterface<TAll>>): PromiseInterface<TAll[]>;
-    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
-    all<T>(promises: {
-        [K in keyof T]: (PromiseInterface<T[K]> | T[K] | null);
-    }): PromiseInterface<T>;
-    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
-    reject(value?: any): PromiseInterface<any>;
-    defer<T>(): Deferred<T>;
-}
+import { PromiseInterface } from '../types';
+export interface Deferred<T> {
+    resolve(value?: T | PromiseInterface<T>): void;
+    reject(reason?: any): void;
+    promise: PromiseInterface<T>;
+}
+export interface PromiseLibraryInterface {
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>, T10 | PromiseInterface<T10>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7]>;
+    all<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>]): PromiseInterface<[T1, T2, T3, T4, T5, T6]>;
+    all<T1, T2, T3, T4, T5>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>]): PromiseInterface<[T1, T2, T3, T4, T5]>;
+    all<T1, T2, T3, T4>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>]): PromiseInterface<[T1, T2, T3, T4]>;
+    all<T1, T2, T3>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>]): PromiseInterface<[T1, T2, T3]>;
+    all<T1, T2>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>]): PromiseInterface<[T1, T2]>;
+    all<TAll>(promises: Array<TAll | PromiseInterface<TAll>>): PromiseInterface<TAll[]>;
+    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
+    all<T>(promises: {
+        [K in keyof T]: (PromiseInterface<T[K]> | T[K] | null);
+    }): PromiseInterface<T>;
+    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
+    reject(value?: any): PromiseInterface<any>;
+    defer<T>(): Deferred<T>;
+}

package/dist/src/interfaces/SocketMessageInterface.d.ts

@@ -1,3 +1,3 @@
-export interface SocketMessageInterface {
-    on(event: string, messageHandler: (message: any) => void): () => boolean;
-}
+export interface SocketMessageInterface {
+    on(event: string, messageHandler: (message: any) => void): () => boolean;
+}

package/dist/src/interfaces/index.d.ts

@@ -1,7 +1,7 @@
-export * from './PromiseLibraryInterface';
-export * from './LocalCacheManagerInterface';
-export * from './ErrorHandlerInterface';
-export * from './ExceptionHandlerInterface';
-export * from './AuthInterface';
-export * from './ApiRequestServiceInterface';
-export * from './SocketMessageInterface';
+export * from './PromiseLibraryInterface';
+export * from './LocalCacheManagerInterface';
+export * from './ErrorHandlerInterface';
+export * from './ExceptionHandlerInterface';
+export * from './AuthInterface';
+export * from './ApiRequestServiceInterface';
+export * from './SocketMessageInterface';

package/dist/src/models/CollectionEditResource.d.ts

@@ -1,14 +1,14 @@
-import { LocalCache } from '../classes';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-import { FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
-export declare class CollectionEditResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
-    save(): PromiseInterface<ItemIdConversionMap>;
-    moveItems(idArray: ItemId[], destination: CollectionResource<ItemTypeType>, enableCallbacks?: boolean): T[];
-    removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<T[]>;
-    removeItem(itemId: ItemId, callOnRemove?: boolean): PromiseInterface<T>;
-    addItems(valuesArray: FieldMap[], callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T[]>;
-    addItem(values: FieldMap, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T>;
-    clear(enableCallbacks: boolean): this["items"];
-}
+import { LocalCache } from '../classes';
+import { CollectionResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
+import { FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+export declare class CollectionEditResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
+    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
+    save(): PromiseInterface<ItemIdConversionMap>;
+    moveItems(idArray: ItemId[], destination: CollectionResource<ItemTypeType>, enableCallbacks?: boolean): T[];
+    removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<T[]>;
+    removeItem(itemId: ItemId, callOnRemove?: boolean): PromiseInterface<T>;
+    addItems(valuesArray: Array<FieldMap<ItemTypeType>>, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T[]>;
+    addItem(values: FieldMap<ItemTypeType>, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T>;
+    clear(enableCallbacks: boolean): this["items"];
+}

package/dist/src/models/CollectionEntry.d.ts

@@ -1,82 +1,82 @@
-import { ColumnExpansion, ColumnInfo, ColumnSet, ItemCache } from '../classes';
-import { CollectionEntryFactory } from '../factories';
-import { Deferred } from '../interfaces';
-import { CollectionEntryOptions, CollectionResource, ItemEntry } from '../models';
-import { ApiRequestColumns, CollectionQuery, ConversionMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, QueryCallback } from '../types';
-export declare class CollectionEntry<ItemTypeType extends ItemType = any> {
-    private factory;
-    itemType: ItemTypeType;
-    options: CollectionEntryOptions;
-    id: number;
-    parent: EntryParentNull;
-    query: CollectionQuery;
-    columns: ColumnSet<ItemTypeType>;
-    private templateColumns;
-    initial: Array<ItemEntry<ItemTypeType>>;
-    items: Array<ItemEntry<ItemTypeType>>;
-    deferred?: Deferred<this>;
-    promise: PromiseInterface<this>;
-    reloadQueued: boolean;
-    hasEditResources: boolean;
-    hasItemEditResources: boolean;
-    constructor(factory: CollectionEntryFactory, itemType: ItemTypeType, options: CollectionEntryOptions);
-    private getResources;
-    defer(): this;
-    isDeferred(): boolean;
-    _resolve(): this;
-    resolve(itemEntryCompound: {
-        columns: ColumnSet<ItemTypeType>;
-        initial: Array<ItemEntry<ItemTypeType>>;
-        modified?: Array<ItemEntry<ItemTypeType>>;
-    }): this;
-    isLocal(): boolean;
-    matchParent(itemType: ItemType, itemId: ItemId): boolean;
-    forEach(callback: (itemEntry: this['items'][0]) => void): void;
-    getItemById(itemId: ItemId): this['items'][0] | undefined;
-    getIdArray(accumulator?: ItemId[]): ItemId[];
-    createItems(valuesArray: FieldMap[]): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues(itemEntries: Array<ItemEntry<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource: U, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'];
-    addItems(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): null;
-    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: U | null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'] | null;
-    private handleAddedItemCallbacks;
-    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
-    removeItems(idArray: ItemId[], resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
-    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
-    clear<U extends CollectionResource<ItemTypeType>>(resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
-    clear(resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
-    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
-    handleRemovedItems(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
-    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
-    private handleRemovedItemCallbacks;
-    private createBatchStatus;
-    private expandLocal;
-    private expandRemote;
-    expand(newColumns: ApiRequestColumns, localItemCache: ItemCache): PromiseInterface<this>;
-    extendQuery(callback?: QueryCallback): CollectionQuery;
-    extend<U extends CollectionResource<ItemTypeType>>(queryCallback: QueryCallback, collectionResource?: U, callOnAdd?: boolean): PromiseInterface<U['items']>;
-    extend(queryCallback: QueryCallback, collectionResource?: null, callOnAdd?: boolean): PromiseInterface<null>;
-    queueReload(): void;
-    expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
-    expandRequestColumns(requestColumns: ApiRequestColumns): void;
-    getAddedItems(returnItemIds: true): ItemId[];
-    getAddedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
-    getRemovedItems(returnItemIds: true): ItemId[];
-    getRemovedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
-    getUpdatedItems(): Array<ItemEntry<ItemTypeType>>;
-    hasAddedItems(): boolean;
-    hasRemovedItems(): boolean;
-    hasUpdatedItems(): boolean;
-    /**
-     * @description
-     * this doesn't revert updates
-     */
-    revertChanges(): void;
-    onItemsCreated(conversionMap: ConversionMap): void;
-    private onAddInitial;
-    private onRemoveInitial;
-    getUpdatedItemColumns(conversionMap: ItemIdConversionMap): {
-        [columnId: string]: ColumnInfo<ItemTypeType>;
-    };
-    clone(parent: EntryParentNull, conversionMap?: ItemIdConversionMap): CollectionEntry<ItemTypeType>;
-}
+import { ColumnExpansion, ColumnInfo, ColumnSet, ItemCache } from '../classes';
+import { CollectionEntryFactory } from '../factories';
+import { Deferred } from '../interfaces';
+import { CollectionEntryOptions, CollectionResource, ItemEntry } from '../models';
+import { ApiRequestColumns, CollectionQuery, ConversionMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, QueryCallback } from '../types';
+export declare class CollectionEntry<ItemTypeType extends ItemType = any> {
+    private factory;
+    itemType: ItemTypeType;
+    options: CollectionEntryOptions;
+    id: number;
+    parent: EntryParentNull;
+    query: CollectionQuery;
+    columns: ColumnSet<ItemTypeType>;
+    private templateColumns;
+    initial: Array<ItemEntry<ItemTypeType>>;
+    items: Array<ItemEntry<ItemTypeType>>;
+    deferred?: Deferred<this>;
+    promise: PromiseInterface<this>;
+    reloadQueued: boolean;
+    hasEditResources: boolean;
+    hasItemEditResources: boolean;
+    constructor(factory: CollectionEntryFactory, itemType: ItemTypeType, options: CollectionEntryOptions);
+    private getResources;
+    defer(): this;
+    isDeferred(): boolean;
+    _resolve(): this;
+    resolve(itemEntryCompound: {
+        columns: ColumnSet<ItemTypeType>;
+        initial: Array<ItemEntry<ItemTypeType>>;
+        modified?: Array<ItemEntry<ItemTypeType>>;
+    }): this;
+    isLocal(): boolean;
+    matchParent(itemType: ItemType, itemId: ItemId): boolean;
+    forEach(callback: (itemEntry: this['items'][0]) => void): void;
+    getItemById(itemId: ItemId): this['items'][0] | undefined;
+    getIdArray(accumulator?: ItemId[]): ItemId[];
+    createItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    resolveDerivedValues(itemEntries: Array<ItemEntry<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource: U, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'];
+    addItems(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): null;
+    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: U | null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'] | null;
+    private handleAddedItemCallbacks;
+    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    removeItems(idArray: ItemId[], resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
+    clear<U extends CollectionResource<ItemTypeType>>(resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    clear(resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    handleRemovedItems(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
+    private handleRemovedItemCallbacks;
+    private createBatchStatus;
+    private expandLocal;
+    private expandRemote;
+    expand(newColumns: ApiRequestColumns, localItemCache: ItemCache): PromiseInterface<this>;
+    extendQuery(callback?: QueryCallback): CollectionQuery;
+    extend<U extends CollectionResource<ItemTypeType>>(queryCallback: QueryCallback, collectionResource?: U, callOnAdd?: boolean): PromiseInterface<U['items']>;
+    extend(queryCallback: QueryCallback, collectionResource?: null, callOnAdd?: boolean): PromiseInterface<null>;
+    queueReload(): void;
+    expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
+    expandRequestColumns(requestColumns: ApiRequestColumns): void;
+    getAddedItems(returnItemIds: true): ItemId[];
+    getAddedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
+    getRemovedItems(returnItemIds: true): ItemId[];
+    getRemovedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
+    getUpdatedItems(): Array<ItemEntry<ItemTypeType>>;
+    hasAddedItems(): boolean;
+    hasRemovedItems(): boolean;
+    hasUpdatedItems(): boolean;
+    /**
+     * @description
+     * this doesn't revert updates
+     */
+    revertChanges(): void;
+    onItemsCreated(conversionMap: ConversionMap): void;
+    private onAddInitial;
+    private onRemoveInitial;
+    getUpdatedItemColumns(conversionMap: ItemIdConversionMap): {
+        [columnId: string]: ColumnInfo<ItemTypeType>;
+    };
+    clone(parent: EntryParentNull, conversionMap?: ItemIdConversionMap): CollectionEntry<ItemTypeType>;
+}

package/dist/src/models/CollectionEntryOptions.d.ts

@@ -1,12 +1,12 @@
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull } from '../types';
-export declare type CollectionEntryOptionsInterface = Partial<CollectionEntryOptions>;
-export declare class CollectionEntryOptions {
-    columns: ApiRequestColumns;
-    query: ApiQuery | null;
-    queryParams: any;
-    parent: EntryParentNull;
-    deferRequest: boolean;
-    limit: ApiRequestLimit | null;
-    entryKey: string | null;
-    constructor(values: CollectionEntryOptionsInterface);
-}
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull } from '../types';
+export declare type CollectionEntryOptionsInterface = Partial<CollectionEntryOptions>;
+export declare class CollectionEntryOptions {
+    columns: ApiRequestColumns;
+    query: ApiQuery | null;
+    queryParams: any;
+    parent: EntryParentNull;
+    deferRequest: boolean;
+    limit: ApiRequestLimit | null;
+    entryKey: string | null;
+    constructor(values: CollectionEntryOptionsInterface);
+}

package/dist/src/models/CollectionResource.d.ts

@@ -1,41 +1,41 @@
-import { LocalCache } from '../classes';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
-import { ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
-export declare abstract class CollectionResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> {
-    protected factory: CollectionResourceFactory;
-    entry: CollectionEntry<ItemTypeType>;
-    options: CollectionResourceOptions<ItemTypeType>;
-    level: number;
-    localCache: LocalCache | null;
-    items: T[];
-    columns: ResponseColumnMap;
-    protected itemIdMap: ItemResourceItemIdMap<T>;
-    private readonly onChange;
-    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
-    getItemById(itemId: number): T;
-    rebuildMap(): void;
-    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
-    /**
-     * @param itemEntries
-     * @returns {ItemResource[]}
-     *
-     * Returns the Itemresources that where removed Collection.
-     * Filters on ItemResource.entry === ItemEntry
-     */
-    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
-    callOnAdd(itemResources: T[]): void;
-    callOnRemove(itemResources: T[]): void;
-    forEach(callback: (itemResource: T) => void): void;
-    filter(callback: (itemResource: T) => boolean): T[];
-    first(callback: (itemResource: T) => boolean): T | null;
-    some(callback: (itemResource: T) => boolean): boolean;
-    groupBy(argument: string | ((itemResource: T) => string | null)): {
-        [key: string]: T[];
-    };
-    map<U>(argument: string | ((itemResource: T) => U)): U[];
-    reduce<U>(callback: (itemResource: T, value: U) => U, value: U): U;
-    extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<T[]>;
-    clearResource(): void;
-    deactivate(): void;
-}
+import { LocalCache } from '../classes';
+import { CollectionResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
+import { ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
+export declare abstract class CollectionResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> {
+    protected factory: CollectionResourceFactory;
+    entry: CollectionEntry<ItemTypeType>;
+    options: CollectionResourceOptions<ItemTypeType>;
+    level: number;
+    localCache: LocalCache | null;
+    items: T[];
+    columns: ResponseColumnMap;
+    protected itemIdMap: ItemResourceItemIdMap<T>;
+    private readonly onChange;
+    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
+    getItemById(itemId: number): T;
+    rebuildMap(): void;
+    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
+    /**
+     * @param itemEntries
+     * @returns {ItemResource[]}
+     *
+     * Returns the Itemresources that where removed Collection.
+     * Filters on ItemResource.entry === ItemEntry
+     */
+    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
+    callOnAdd(itemResources: T[]): void;
+    callOnRemove(itemResources: T[]): void;
+    forEach(callback: (itemResource: T) => void): void;
+    filter(callback: (itemResource: T) => boolean): T[];
+    first(callback: (itemResource: T) => boolean): T | null;
+    some(callback: (itemResource: T) => boolean): boolean;
+    groupBy(argument: string | ((itemResource: T) => string | null)): {
+        [key: string]: T[];
+    };
+    map<U>(argument: string | ((itemResource: T) => U)): U[];
+    reduce<U>(callback: (itemResource: T, value: U) => U, value: U): U;
+    extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<T[]>;
+    clearResource(): void;
+    deactivate(): void;
+}

package/dist/src/models/CollectionResourceOptions.d.ts

@@ -1,22 +1,22 @@
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { ConversionMap, ItemType, OnChangeFunction } from '../types';
-export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
-export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
-export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
-export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
-export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
-    editItems: boolean;
-    remoteItems: boolean;
-    editCollection: boolean;
-    modInstant: boolean;
-    enableSave: boolean;
-    onItemsCreated: OnItemsCreatedCallback;
-    onChange: OnChangeFunction;
-    onAdd: CollectionResourceCallback<ItemTypeType>;
-    onRemove: CollectionResourceCallback<ItemTypeType>;
-    onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
-    onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
-    resourceKey: string | null;
-    custom: any;
-    constructor(values: CollectionResourceOptionsInterface<ItemTypeType>);
-}
+import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
+import { ConversionMap, ItemType, OnChangeFunction } from '../types';
+export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
+export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
+export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
+export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
+export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
+    editItems: boolean;
+    remoteItems: boolean;
+    editCollection: boolean;
+    modInstant: boolean;
+    enableSave: boolean;
+    onItemsCreated: OnItemsCreatedCallback;
+    onChange: OnChangeFunction;
+    onAdd: CollectionResourceCallback<ItemTypeType>;
+    onRemove: CollectionResourceCallback<ItemTypeType>;
+    onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
+    onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
+    resourceKey: string | null;
+    custom: any;
+    constructor(values: CollectionResourceOptionsInterface<ItemTypeType>);
+}

package/dist/src/models/CollectionViewResource.d.ts

@@ -1,7 +1,7 @@
-import { LocalCache } from '../classes';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
-}
+import { LocalCache } from '../classes';
+import { CollectionResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
+import { ItemType } from '../types';
+export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
+    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
+}

package/dist/src/models/EditResource.d.ts

@@ -1,18 +1,18 @@
-import { LocalCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, ItemType, PromiseInterface } from '../types';
-export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
-    protected localCopies: FieldMap[];
-    protected transactions: number;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
-    isNew(): boolean;
-    start(): this;
-    rollback(): this;
-    commit(callOnChange?: boolean): this;
-    getLocalCopy(): FieldMap | null;
-    copyFields(destination?: FieldMap): FieldMap;
-    setFields(values: FieldMap, callOnChange?: boolean): this;
-    callOnChange(previous?: FieldMap): this;
-    save(parameters?: any): PromiseInterface<this>;
-}
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
+import { FieldMap, ItemType, PromiseInterface } from '../types';
+export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
+    protected localCopies: Array<FieldMap<ItemTypeType>>;
+    protected transactions: number;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+    isNew(): boolean;
+    start(): this;
+    rollback(): this;
+    commit(callOnChange?: boolean): this;
+    getLocalCopy(): FieldMap<ItemTypeType> | null;
+    copyFields(destination?: FieldMap<ItemTypeType>): FieldMap<ItemTypeType>;
+    setFields(values: FieldMap<ItemTypeType>, callOnChange?: boolean): this;
+    callOnChange(previous?: FieldMap<ItemTypeType>): this;
+    save(parameters?: any): PromiseInterface<this>;
+}