@rentman/rm-core 1.4.0 → 1.5.0

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

@@ -1,21 +1,22 @@
-export * from './ApiResponseProcessorFactory';
-export * from './BatchStatusFactory';
-export * from './ChangesCompilationFactory';
-export * from './ChangesProcessorFactory';
-export * from './CollectionCacheFactory';
-export * from './CollectionEntryFactory';
-export * from './CollectionMatcherFactory';
-export * from './CollectionResourceFactory';
-export * from './ColumnExpansionFactory';
-export * from './ColumnInfoFactory';
-export * from './ColumnSetFactory';
-export * from './CreateRequestFactory';
-export * from './ItemCacheFactory';
-export * from './ItemEntryFactory';
-export * from './ItemResourceFactory';
-export * from './LocalCacheFactory';
-export * from './ModuleChangesCompilationFactory';
-export * from './QueryMatcherFactory';
-export * from './QueryParserFactory';
-export * from './RequestColumnExpansionFactory';
-export * from './TemplateFactory';
+export * from './ApiResponseProcessorFactory';
+export * from './BatchStatusFactory';
+export * from './ChangesCompilationFactory';
+export * from './ChangesProcessorFactory';
+export * from './CollectionCacheFactory';
+export * from './CollectionEntryFactory';
+export * from './CollectionMatcherFactory';
+export * from './CollectionResourceFactory';
+export * from './ColumnExpansionFactory';
+export * from './ColumnInfoFactory';
+export * from './ColumnSetFactory';
+export * from './ColumnSubsetCacheFactory';
+export * from './CreateRequestFactory';
+export * from './ItemCacheFactory';
+export * from './ItemEntryFactory';
+export * from './ItemResourceFactory';
+export * from './LocalCacheFactory';
+export * from './ModuleChangesCompilationFactory';
+export * from './QueryMatcherFactory';
+export * from './QueryParserFactory';
+export * from './RequestColumnExpansionFactory';
+export * from './TemplateFactory';

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
-export * from './core';
-export * from './constants';
-export * from './models';
-export * from './interfaces';
-export * from './classes';
-export * from './factories';
-export * from './types';
+export * from './core';
+export * from './constants';
+export * from './models';
+export * from './interfaces';
+export * from './classes';
+export * from './factories';
+export * from './types';

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

@@ -1,11 +1,11 @@
-import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestMoveItems, ItemId, ItemType, PromiseInterface } from '../types';
-export interface ApiRequestServiceInterface {
-    template(itemType: ItemType, params: any): PromiseInterface<any>;
-    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<any>;
-    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<any>;
-    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: ApiRequestColumnMap): PromiseInterface<any>;
-    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<any>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: ApiRequestMoveItems): PromiseInterface<any>;
-    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<any>;
-    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<any>;
-}
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestMoveItems, ItemId, ItemType, PromiseInterface } from '../types';
+export interface ApiRequestServiceInterface {
+    template(itemType: ItemType, params: any): PromiseInterface<any>;
+    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<any>;
+    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<any>;
+    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: ApiRequestColumnMap): PromiseInterface<any>;
+    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<any>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: ApiRequestMoveItems): PromiseInterface<any>;
+    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<any>;
+    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<any>;
+}

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

@@ -1,9 +1,9 @@
-export interface AuthInterface {
-    /**
-     * @returns {string} A uniquely identifying string for each user of the api
-     */
-    getUniqueUserId(): string;
-    getUserId(): number;
-    getUserAccountname(): string;
-    getUserDisplayname(): string;
-}
+export interface AuthInterface {
+    /**
+     * @returns {string} A uniquely identifying string for each user of the api
+     */
+    getUniqueUserId(): string;
+    getUserId(): number;
+    getUserAccountname(): string;
+    getUserDisplayname(): string;
+}

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

@@ -1,5 +1,5 @@
-import { PromiseInterface } from '../types';
-export interface ErrorHandlerInterface {
-    reject(error?: object): PromiseInterface<any>;
-    notifyError(error?: any): PromiseInterface<any>;
-}
+import { PromiseInterface } from '../types';
+export interface ErrorHandlerInterface {
+    reject(error?: object): PromiseInterface<any>;
+    notifyError(error?: any): PromiseInterface<any>;
+}

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

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

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

@@ -1,15 +1,15 @@
-import { PromiseInterface } from '../types';
-export interface PromiseLibraryInterface {
-    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
-    all(iterable: {
-        [key: string]: PromiseInterface<any> | any;
-    }): PromiseInterface<{
-        [key: string]: any;
-    }>;
-    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
-    reject(value?: any): PromiseInterface<any>;
-    defer(): {
-        (value?): any;
-        (value?): any;
-    };
-}
+import { PromiseInterface } from '../types';
+export interface PromiseLibraryInterface {
+    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
+    all(iterable: {
+        [key: string]: PromiseInterface<any> | any;
+    }): PromiseInterface<{
+        [key: string]: any;
+    }>;
+    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
+    reject(value?: any): PromiseInterface<any>;
+    defer(): {
+        (value?): any;
+        (value?): any;
+    };
+}

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,6 +1,6 @@
-export * from './PromiseLibraryInterface';
-export * from './LocalCacheManagerInterface';
-export * from './ErrorHandlerInterface';
-export * from './AuthInterface';
-export * from './ApiRequestServiceInterface';
-export * from './SocketMessageInterface';
+export * from './PromiseLibraryInterface';
+export * from './LocalCacheManagerInterface';
+export * from './ErrorHandlerInterface';
+export * from './AuthInterface';
+export * from './ApiRequestServiceInterface';
+export * from './SocketMessageInterface';

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull, OptionsInterface } from '../types';
+export declare abstract class CollectionEntryOptionsInterface implements OptionsInterface {
+    columns?: ApiRequestColumns;
+    query?: ApiQuery | null;
+    queryParams?: object;
+    parent?: EntryParentNull;
+    deferRequest?: boolean;
+    limit?: ApiRequestLimit | null;
+    entryKey?: string | null;
+}
+export declare class CollectionEntryOptions extends CollectionEntryOptionsInterface {
+    columns: any;
+    query: any;
+    queryParams: any;
+    parent: any;
+    deferRequest: any;
+    limit: any;
+    entryKey: any;
+    constructor(values: CollectionEntryOptionsInterface);
+}

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

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

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

@@ -0,0 +1,38 @@
+import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
+import { ItemIdConversionMap, OnChangeFunction, OptionsInterface } from '../types';
+export declare type CollectionResourceCallback = (itemResources: ItemResource[], collectionResource: CollectionResource) => void;
+export declare type CollectionResourceInitialCallback = (itemEntries: ItemEntry[], collectionEntry: CollectionEntry) => void;
+export declare type OnItemsCreatedCallback = (conversionMap: ItemIdConversionMap) => void;
+export declare abstract class CollectionResourceOptionsInterface implements OptionsInterface {
+    editItems?: boolean;
+    editCollection?: boolean;
+    modInstant?: boolean;
+    enableSave?: boolean;
+    onItemsCreated?: OnItemsCreatedCallback;
+    onChange?: OnChangeFunction;
+    onAdd?: CollectionResourceCallback;
+    onRemove?: CollectionResourceCallback;
+    onAddInitial?: CollectionResourceInitialCallback;
+    onRemoveInitial?: CollectionResourceInitialCallback;
+    resourceKey?: string | null;
+    clearOnTabChange?: boolean;
+    clearOnSubTabChange?: boolean;
+    custom?: any;
+}
+export declare class CollectionResourceOptions extends CollectionResourceOptionsInterface {
+    editItems: any;
+    editCollection: any;
+    modInstant: any;
+    enableSave: any;
+    onItemsCreated: any;
+    onChange: any;
+    onAdd: any;
+    onRemove: any;
+    onAddInitial: any;
+    onRemoveInitial: any;
+    resourceKey: any;
+    clearOnTabChange: any;
+    clearOnSubTabChange: any;
+    custom: any;
+    constructor(values: CollectionResourceOptionsInterface);
+}

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

@@ -1,6 +1,6 @@
-import { LocalCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource } from '../models';
-export declare class CollectionViewResource extends CollectionResource {
-    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: any, localCache: LocalCache);
-}
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions } from '../models';
+export declare class CollectionViewResource extends CollectionResource {
+    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+}

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

@@ -1,18 +1,18 @@
-import { ItemResourceFactory } from '../factories';
-import { FieldMap, PromiseInterface } from '../types';
-import { ItemEntry, ItemResource } from './';
-export declare class EditResource extends ItemResource {
-    private factory;
-    localCopies: FieldMap[];
-    transactions: number;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: any, isNew?: boolean);
-    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 { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
+import { FieldMap, PromiseInterface } from '../types';
+export declare class EditResource extends ItemResource {
+    private factory;
+    localCopies: FieldMap[];
+    transactions: number;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
+    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>;
+}