@rentman/rm-core 1.5.5 → 1.5.7-1

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

@@ -1,9 +1,9 @@
-import { ChangesCompilation } from '../classes';
+import { ChangesCompilation, KeyService } from '../classes';
 import { CollectionEntry, ItemEntry } from '../models';
 import { CollectionCacheFactory } from './';
 export declare class ChangesCompilationFactory {
     private collectionCacheFactory;
     private keyService;
-    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: any);
+    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService);
     construct(singleItems: ItemEntry[], collections: CollectionEntry[]): ChangesCompilation;
 }

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

@@ -1,7 +1,7 @@
 import { KeyService, LocalCache } from '../classes';
 import { ChangesProcessorFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface } from '../models';
+import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ViewResource } from '../models';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     itemResourceFactory: ItemResourceFactory;
@@ -9,5 +9,15 @@ export declare class CollectionResourceFactory {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     constructor(errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, localCache: LocalCache): CollectionResource;
+    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }, localCache: LocalCache): CollectionEditResource<EditResource>;
+    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }, localCache: LocalCache): CollectionEditResource<ViewResource>;
+    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }, localCache: LocalCache): CollectionViewResource<EditResource>;
+    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, localCache: LocalCache): CollectionViewResource<ViewResource>;
 }

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

@@ -2,5 +2,5 @@ import { ColumnInfo } from '../classes';
 import { ResponseColumn } from '../types';
 export declare class ColumnInfoFactory {
     constructor();
-    construct(apiColumn: ResponseColumn, parent: ColumnInfo): ColumnInfo;
+    construct(apiColumn: ResponseColumn, parent: ColumnInfo | null): ColumnInfo;
 }

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

@@ -7,5 +7,5 @@ export declare class ColumnSetFactory {
     private columnInfoFactory;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory);
     constructStub(itemType: ItemType, requestColumns: ApiRequestColumns): ColumnSet;
-    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: any, includeIdColumn?: any): ColumnSet;
+    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet;
 }

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

@@ -13,7 +13,7 @@ export declare class ItemEntryFactory {
     constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface);
     constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: ColumnSet): ItemEntry;
     constructLocalLinked(itemType: ItemType, itemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
-    constructLocal(itemId: ItemId, template: Template, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet, conversionMap?: any): ItemEntry;
+    constructLocal(itemId: ItemId, template: Template, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet, conversionMap?: ItemIdConversionMap): ItemEntry;
     constructDeferred(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry;
     construct(itemId: ItemId, initial: FieldMap, derived: FieldMap, columnInfo: ColumnSet): ItemEntry;
 }

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

@@ -1,6 +1,6 @@
 import { ApiFormatter, ChangesProcessor, LockService } from '../classes';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry, ItemResource } from '../models';
+import { EditResource, ItemEntry, ViewResource } from '../models';
 import { ItemOptionsInterface } from '../types';
 export declare class ItemResourceFactory {
     apiFormatter: ApiFormatter;
@@ -9,6 +9,12 @@ export declare class ItemResourceFactory {
     errorHandler: ErrorHandlerInterface;
     promiseService: PromiseLibraryInterface;
     constructor(apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
-    getConstructor(options: ItemOptionsInterface): (itemEntry: ItemEntry) => ItemResource;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface, isNew?: boolean): ItemResource;
+    getConstructor(options: ItemOptionsInterface & {
+        edit: true;
+    }): (itemEntry: ItemEntry) => EditResource;
+    getConstructor(options: ItemOptionsInterface): (itemEntry: ItemEntry) => ViewResource;
+    construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+        edit: true;
+    }, isNew?: boolean): EditResource;
+    construct(itemEntry: ItemEntry, options: ItemOptionsInterface, isNew?: boolean): ViewResource;
 }

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

@@ -1,5 +1,6 @@
 import { QueryParser } from '../classes';
+import { ApiQuery } from '../types';
 export declare class QueryParserFactory {
     constructor();
-    construct(query: any, parameters?: any): QueryParser;
+    construct(query: ApiQuery, parameters?: any): QueryParser;
 }

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

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

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

@@ -1,15 +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(iterable: {
-        [key: string]: PromiseInterface<any> | any;
-    }): PromiseInterface<{
-        [key: string]: any;
-    }>;
+    all<T>(promises: {
+        [K in keyof T]: (PromiseInterface<T[K]> | T[K]);
+    }): PromiseInterface<T>;
     when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
     reject(value?: any): PromiseInterface<any>;
-    defer(): {
-        (value?): any;
-        (value?): any;
-    };
+    defer<T>(): Deferred<T>;
 }

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

@@ -1,15 +1,15 @@
 import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource } from '../models';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, ViewResource } from '../models';
 import { FieldMap, ItemId, ItemIdConversionMap, PromiseInterface } from '../types';
-export declare class CollectionEditResource extends CollectionResource {
+export declare class CollectionEditResource<T extends ItemResource = ViewResource> extends CollectionResource<T> {
     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;
+    moveItems(idArray: ItemId[], destination: CollectionResource, enableCallbacks?: boolean): this['items'];
+    removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<this['items']>;
+    removeItem(itemId: ItemId, callOnRemove?: boolean): PromiseInterface<T>;
+    addItems(valuesArray: FieldMap[], callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<this['items']>;
+    addItem(values: FieldMap, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T>;
+    clear(enableCallbacks: boolean): this["items"];
 }

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

@@ -1,21 +1,21 @@
 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';
+import { CollectionEditResource, CollectionEntryOptions, CollectionResource, CollectionViewResource, ItemEntry, ViewResource } from '../models';
+import { ApiRequestColumns, CollectionQuery, ConversionMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, QueryCallback } from '../types';
 export declare class CollectionEntry {
     private factory;
     itemType: ItemType;
     options: CollectionEntryOptions;
     id: number;
-    query: ApiQuery;
+    query: CollectionQuery;
     columns: ColumnSet;
     templateColumns: ColumnSet | null;
     parent: EntryParentNull;
     initial: ItemEntry[];
     items: ItemEntry[];
-    resources: CollectionResource[];
+    resources: Array<CollectionViewResource | CollectionEditResource>;
     deferred: any;
-    promise: PromiseInterface<CollectionEntry>;
+    promise: PromiseInterface<this>;
     reloadQueued: boolean;
     hasEditResources: boolean;
     hasItemEditResources: boolean;
@@ -31,37 +31,51 @@ export declare class CollectionEntry {
     isLocal(): boolean;
     matchParent(itemType: ItemType, itemId: ItemId): boolean;
     forEach(callback: (itemEntry: ItemEntry) => void): void;
-    getItemById(itemId: any): ItemEntry | undefined;
+    getItemById(itemId: ItemId): 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);
+    addItems<U extends CollectionResource>(itemEntries: ItemEntry[], resultResource: U, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'];
+    addItems(itemEntries: ItemEntry[], resultResource?: null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): null;
+    addItems<U extends CollectionResource>(itemEntries: ItemEntry[], resultResource?: U | null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'] | null;
+    private handleAddedItemCallbacks;
+    removeItems<U extends CollectionResource>(idArray: ItemId[], resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    removeItems(idArray: ItemId[], resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    removeItems<U extends CollectionResource>(idArray: ItemId[], resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
+    clear<U extends CollectionResource>(resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    clear(resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    handleRemovedItems<U extends CollectionResource>(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    handleRemovedItems(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    handleRemovedItems<U extends CollectionResource>(filterFunction: (itemEntry: ItemEntry) => 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): any;
-    extend(queryCallback: QueryCallback, collectionResource?: CollectionResource | null, callOnAdd?: boolean, updateInitial?: boolean): PromiseInterface<ItemResource[] | null>;
+    extendQuery(callback?: QueryCallback): CollectionQuery;
+    extend<U extends CollectionResource>(queryCallback: QueryCallback, collectionResource?: U, callOnAdd?: boolean, updateInitial?: boolean): PromiseInterface<U['items']>;
+    extend(queryCallback: QueryCallback, collectionResource?: null, callOnAdd?: boolean, updateInitial?: boolean): PromiseInterface<null>;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion): void;
     expandRequestColumns(requestColumns: ApiRequestColumns): void;
-    getAddedItems(returnItemIds?: boolean): (number | ItemEntry)[];
-    getRemovedItems(returnItemIds?: boolean): (number | ItemEntry)[];
+    getAddedItems(returnItemIds: true): ItemId[];
+    getAddedItems(returnItemIds?: boolean): ItemEntry[];
+    getRemovedItems(returnItemIds: true): ItemId[];
+    getRemovedItems(returnItemIds?: boolean): ItemEntry[];
     getUpdatedItems(): ItemEntry[];
     hasAddedItems(): boolean;
     hasRemovedItems(): boolean;
     hasUpdatedItems(): boolean;
-    getCurrentResource(): CollectionResource;
+    getCurrentResource<T extends CollectionViewResource = CollectionViewResource<ViewResource>>(): T;
     clearResources(isSubtabChange?: boolean): void;
+    /**
+     * @description
+     * this doesn't revert updates
+     */
     revertChanges(): void;
-    onItemsCreated(conversionMap: any): void;
-    getUpdatedItemColumns(conversionMap: any): {
+    onItemsCreated(conversionMap: ConversionMap): void;
+    getUpdatedItemColumns(conversionMap: ItemIdConversionMap): {
         [columnId: string]: ColumnInfo;
     };
-    clone(parent: any, conversionMap?: ItemIdConversionMap): CollectionEntry;
+    clone(parent: EntryParentNull, conversionMap?: ItemIdConversionMap): CollectionEntry;
 }

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

@@ -1,20 +1,12 @@
-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;
+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: any;
-    deferRequest: any;
-    limit: any;
-    entryKey: any;
+    parent: EntryParentNull;
+    deferRequest: boolean;
+    limit: ApiRequestLimit | null;
+    entryKey: string | null;
     constructor(values: CollectionEntryOptionsInterface);
 }

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

@@ -1,20 +1,20 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
-import { CollectionResourceOptions, ItemEntry, ItemResource } from '../models';
-import { ItemResourceItemIdMap, PromiseInterface } from '../types';
+import { CollectionResourceOptions, ItemEntry, ItemResource, ViewResource } from '../models';
+import { ItemResourceItemIdMap, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
 import { CollectionEntry } from './CollectionEntry';
-export declare class CollectionResource {
+export declare abstract class CollectionResource<T extends ItemResource = ViewResource> {
     private itemResourceFactory;
     entry: CollectionEntry;
     options: CollectionResourceOptions;
     localCache: LocalCache;
-    items: ItemResource[];
-    itemIdMap: ItemResourceItemIdMap;
-    columns: any;
+    items: T[];
+    itemIdMap: ItemResourceItemIdMap<T>;
+    columns: ResponseColumnMap;
     constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
-    getItemById(itemId: number): ItemResource;
+    getItemById(itemId: number): T;
     rebuildMap(): void;
-    addItemResources(itemEntries: ItemEntry[]): ItemResource[];
+    addItemResources(itemEntries: ItemEntry[]): T[];
     /**
      * @param itemEntries
      * @returns {ItemResource[]}
@@ -22,19 +22,19 @@ export declare class CollectionResource {
      * 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[];
+    removeItemResources(itemEntries: ItemEntry[]): T[];
+    callOnAdd(itemResources: this['items']): void;
+    callOnRemove(itemResources: this['items']): 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<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>;
+    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<this['items']>;
     deactivate(): void;
     clearResource(): void;
 }

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

@@ -1,38 +1,23 @@
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { ItemIdConversionMap, OnChangeFunction, OptionsInterface } from '../types';
+import { ConversionMap, OnChangeFunction } 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;
+export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
+export declare type CollectionResourceOptionsInterface = Partial<CollectionResourceOptions>;
+export declare class CollectionResourceOptions {
+    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;
     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, CollectionResourceOptions } from '../models';
-export declare class CollectionViewResource extends CollectionResource {
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, EditResource, ViewResource } from '../models';
+export declare class CollectionViewResource<T extends EditResource | ViewResource = ViewResource> extends CollectionResource<T> {
     constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
 }

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

@@ -13,6 +13,6 @@ export declare class EditResource extends ItemResource {
     getLocalCopy(): FieldMap | null;
     copyFields(destination?: FieldMap): FieldMap;
     setFields(values: FieldMap, callOnChange?: boolean): this;
-    callOnChange(previous: FieldMap): this;
+    callOnChange(previous?: FieldMap): this;
     save(parameters?: any): PromiseInterface<this>;
 }

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

@@ -1,7 +1,8 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
 import { ItemResource } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+import { Deferred } from '../interfaces';
 export declare class ItemEntry {
     private factory;
     itemType: string;
@@ -10,7 +11,7 @@ export declare class ItemEntry {
     id: number;
     reloadQueued: boolean;
     deferRequest: boolean;
-    deferred: any;
+    deferred?: Deferred<this>;
     parent: EntryParentNull;
     initial: FieldMap;
     modified: FieldMap;
@@ -19,26 +20,27 @@ export declare class ItemEntry {
     constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
     queueReload(): this;
     defer(deferRequest?: boolean): this;
+    getPromise(): PromiseInterface<this>;
     resolve(): this;
-    resolveDeferred(initial: any, derived: any, columns: any): this;
+    resolveDeferred(initial: FieldMap, derived: FieldMap, columns: ColumnSet): this;
     isDeferred(): boolean;
     reject(error?: ItemError): this;
     setFields(initial: FieldMap, derived: FieldMap): this;
     setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
     clone(conversionMap?: ItemIdConversionMap): ItemEntry;
-    resetDerived(columnIds: any): this;
+    resetDerived(columnIds: string[]): this;
     clearResources(): this;
     deactivateResources(): this;
     getFields(): FieldMap;
     expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
     expandLocal(columnExpansionResult: ColumnExpansionResult): this;
-    private setLocalValues(fields, columns);
+    private setLocalValues;
     /**
      * This function assumes the initial, modified, derived properties are already set. It will update the values
      * themselves to preserve references in existing item resources.
      */
     updateFields(fields: FieldMap, derived?: FieldMap | null, overwrite?: boolean): this;
-    private updateItemValues(fields, itemColumns, conversionMap);
+    private updateItemValues;
     updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
     formatRequest(): FieldMap;
     setDisplayName(): this;
@@ -59,7 +61,7 @@ export declare class ItemEntry {
     setModified(values?: FieldMap): this;
     setDerived(values: FieldMap): this;
     setParent(parentType: ItemType, parentId: ItemId): this;
-    callOnChange(previous: FieldMap): this;
+    callOnChange(previous?: FieldMap): this;
     toJSON(): {
         id: number;
         parent: EntryParentNull;

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

@@ -1,18 +1,11 @@
-import { ApiRequestColumnMap, ApiRequestColumns, EntryParentNull, OptionsInterface } from '../types';
-export declare abstract class ItemEntryOptionsInterface implements OptionsInterface {
-    columns?: ApiRequestColumns;
-    parent?: EntryParentNull;
-    templateOptions?: any;
-    templateColumns?: ApiRequestColumnMap;
-    deferRequest?: boolean;
-    isDuplicate?: boolean;
-}
-export declare class ItemEntryOptions extends ItemEntryOptionsInterface {
-    columns: any;
-    parent: any;
+import { ApiRequestColumnMap, ApiRequestColumns, EntryParentNull } from '../types';
+export declare type ItemEntryOptionsInterface = Partial<ItemEntryOptions>;
+export declare class ItemEntryOptions {
+    columns: ApiRequestColumns;
+    parent: EntryParentNull;
     templateOptions: any;
-    templateColumns: any;
-    deferRequest: any;
-    isDuplicate: any;
+    templateColumns: ApiRequestColumnMap;
+    deferRequest: boolean;
+    isDuplicate: boolean;
     constructor(values: ItemEntryOptionsInterface);
 }

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

@@ -1,6 +1,6 @@
 import { ItemEntry, ItemResourceOptions } from '../models';
 import { FieldMap, ResponseColumn } from '../types';
-export declare class ItemResource {
+export declare abstract class ItemResource {
     entry: ItemEntry;
     options: ItemResourceOptions;
     protected readonly _isNew: boolean;

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

@@ -1,13 +1,9 @@
 import { ItemEntry } from '../models';
-import { ItemOptionsInterface, OnChangeFunction } from '../types';
-export declare abstract class ItemResourceOptionsInterface implements ItemOptionsInterface {
-    edit?: boolean;
-    onChange?: OnChangeFunction;
-    onDeactivate?: (itemEntry: ItemEntry) => void;
-}
-export declare class ItemResourceOptions extends ItemResourceOptionsInterface {
-    edit: any;
-    onChange: any;
-    onDeactivate: any;
+import { OnChangeFunction } from '../types';
+export declare type ItemResourceOptionsInterface = Partial<ItemResourceOptions>;
+export declare class ItemResourceOptions {
+    edit: boolean;
+    onChange: OnChangeFunction;
+    onDeactivate: (itemEntry: ItemEntry) => void;
     constructor(values: ItemResourceOptionsInterface);
 }