@rentman/rm-core 1.4.0 → 1.5.1-1

package/dist/src/classes/QueryMatcher.d.ts

@@ -6,9 +6,9 @@ export declare class QueryMatcher {
     fields: FieldMap;
     parent: EntryParentNull;
     constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
-    private compareValues(value, queryValue);
+    private compareValues;
     matchQuery(query: any): boolean | string;
-    private matchLinkedToQuery(query);
-    private matchComplexQuery(query);
-    private matchSimpleQuery(value, query);
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
 }

package/dist/src/classes/QueryParser.d.ts

@@ -2,15 +2,15 @@ export declare class QueryParser {
     query: any;
     parameters: any;
     constructor(query: any, parameters?: any);
-    private processValue(value);
-    private compareParsedQueries(a, b);
+    private processValue;
+    private compareParsedQueries;
     parse(query?: any): any;
-    private parseSearchQuery(value);
-    private parseCustomQuery(custom, parameters);
-    private parseCustomParameters(parameters);
-    private parseSimpleQuery(key, value, comparator?);
-    private parseLinkedToQuery(linkedTo, query, reverse, not);
-    private parseComplexQuery(conditions, operator);
-    private parseConditions(conditions);
-    private formatValue(value);
+    private parseSearchQuery;
+    private parseCustomQuery;
+    private parseCustomParameters;
+    private parseSimpleQuery;
+    private parseLinkedToQuery;
+    private parseComplexQuery;
+    private parseConditions;
+    private formatValue;
 }

package/dist/src/classes/SocketMessageHandler.d.ts

@@ -1,7 +1,11 @@
 import { ApiFormatter, CollectionHandler, ItemHandler } from '../classes';
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionMatchResult, FieldMap, GroupedExtendedCollectionMatchResult, PromiseInterface } from '../types';
+import { ItemEntry, ItemResource } from '../models';
+import { ApiRequestColumns, ApiResponse, CollectionMatchResult, FieldMap, FunctionChangesResolveSocketMessage, GroupedExtendedCollectionMatchResult, ItemId, ItemType, PromiseInterface, ResponseColumn, SocketMessage } from '../types';
+export declare type SocketCollectionMap = {
+    [itemId: number]: CollectionMatchResult;
+};
 export declare class SocketMessageHandler {
     private promiseService;
     private apiRequestService;
@@ -14,23 +18,23 @@ export declare class SocketMessageHandler {
     private apiFormatter;
     private errorHandler;
     constructor(promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, itemEntryFactory: ItemEntryFactory, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface);
-    onMessageReceived(message: any): any;
-    formatMessageValues(values: any, columns: any): FieldMap;
-    createCollectionMap(itemType: any, items: any, columns: any): {
-        [itemId: number]: CollectionMatchResult;
+    onMessageReceived(message: SocketMessage): any;
+    formatMessageValues(values: any, columns: ResponseColumn[]): FieldMap;
+    createCollectionMap(itemType: ItemType, items: {
+        [itemId: number]: any;
+    }, columns: ResponseColumn[]): SocketCollectionMap;
+    groupByCollectionId(itemType: ItemType, collectionMap: SocketCollectionMap): GroupedExtendedCollectionMatchResult;
+    getRequestColumns(itemType: ItemType, collectionMap: SocketCollectionMap): {
+        [itemType: string]: ApiRequestColumns;
     };
-    groupByCollectionId(itemType: any, collectionMap: any): GroupedExtendedCollectionMatchResult;
-    getRequestColumns(itemType: any, collectionMap: any): {
-        [itemType: string]: true | (string | {
-            [columnId: string]: (string | any)[];
-        })[];
-    };
-    deferEntry(itemEntry: any): any;
+    deferEntry(itemEntry: ItemEntry): ItemEntry | PromiseInterface<ItemEntry>;
     processMessage(body: any): PromiseInterface<GroupedExtendedCollectionMatchResult>;
-    processFunctionChangesResolve(body: any): Promise<any> | undefined;
-    handleResponse(itemType: any, requestIds: any, requestColumns: any, response: any, collectionMap: any): GroupedExtendedCollectionMatchResult;
-    handleCreate(message: any): Promise<any> | undefined;
-    handleUpdate(message: any): Promise<any>;
-    handleDelete(message: any): PromiseInterface<{}>;
-    handleLinkMove(): void;
+    processFunctionChangesResolve(body: any): PromiseInterface<void>;
+    handleResponse(itemType: ItemType, requestIds: ItemId[], requestColumns: ApiRequestColumns, response: ApiResponse, collectionMap: SocketCollectionMap): GroupedExtendedCollectionMatchResult;
+    private isFunctionChangesResolveMessage;
+    handleCreate(message: FunctionChangesResolveSocketMessage): PromiseInterface<void>;
+    handleCreate(message: SocketMessage): PromiseInterface<ItemResource[]>;
+    handleUpdate(message: SocketMessage): PromiseInterface<void>;
+    handleDelete(message: SocketMessage): PromiseInterface<void>;
+    handleLinkMove(): PromiseInterface<void>;
 }

package/dist/src/classes/Util.d.ts

@@ -1,8 +1,10 @@
+import { OptionsInterface } from '../types';
+export declare function instantiateOptions(options: OptionsInterface, values: object): void;
 export declare function shallowMerge(object: any, defaults: any): any;
 export declare function hasProperties(object: any): boolean;
 export declare function getFirstProperty(object: any): string | null;
 export declare function inArray(needle: any, haystack: any): boolean;
-export declare function filterArray<T>(source: T[], callback: (T) => boolean): boolean;
+export declare function filterArray<T>(source: T[], callback: (T: any) => boolean): boolean;
 export declare function emptyArray(array: any): void;
 export declare function pathExists(source: any, path: any): boolean;
 export declare function createPath(object: {}, path: Array<number | string>, defaults: any[]): any;

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

@@ -14,6 +14,7 @@ export * from './ColumnExpansion';
 export * from './ColumnHandler';
 export * from './ColumnInfo';
 export * from './ColumnSet';
+export * from './ColumnSubsetCache';
 export * from './ColumnUtil';
 export * from './CreateRequest';
 export * from './ItemAdministrator';
@@ -21,7 +22,6 @@ export * from './ItemCache';
 export * from './ItemEntryService';
 export * from './ItemHandler';
 export * from './ItemRequestService';
-export * from './ItemResourceService';
 export * from './KeyService';
 export * from './LocalCache';
 export * from './LockService';

package/dist/src/constants.d.ts

@@ -1,11 +1,13 @@
 export declare enum ENTRY_STATUS {
     CACHED = "cached",
+    LOCAL = "local",
     PROMISED = "promised",
     EXPAND = "expand",
     PROMISED_EXPAND = "promised-expand",
+    EXPAND_LOCAL = "expand-local",
+    PROMISED_EXPAND_LOCAL = "promised-expand-local",
     RESOLVE = "resolve",
-    RESOLVE_VALUES = "resolve-values",
-    LOCAL = "local",
+    RESOLVE_VALUES = "resolve-values"
 }
 export declare const ALL_PERMISSIONS = "7";
 export declare const COLUMN_SEPERATOR = ">";

package/dist/src/core.d.ts

@@ -1,5 +1,5 @@
-import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionHandler, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemAdministrator, ItemEntryService, ItemHandler, ItemRequestService, ItemResourceService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
-import { ApiResponseProcessorFactory, BatchStatusFactory, ChangesCompilationFactory, ChangesProcessorFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, LocalCacheFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory } from './factories';
+import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionHandler, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemAdministrator, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { ApiResponseProcessorFactory, BatchStatusFactory, ChangesCompilationFactory, ChangesProcessorFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, LocalCacheFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory } from './factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from './interfaces';
 export declare class RmCore {
     version: string;
@@ -22,6 +22,7 @@ export declare class RmCore {
     columnHandler: ColumnHandler;
     columnInfoFactory: ColumnInfoFactory;
     columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
     columnUtil: ColumnUtil;
     createRequestFactory: CreateRequestFactory;
     itemAdministrator: ItemAdministrator;
@@ -31,7 +32,6 @@ export declare class RmCore {
     itemHandler: ItemHandler;
     itemRequestService: ItemRequestService;
     itemResourceFactory: ItemResourceFactory;
-    itemResourceService: ItemResourceService;
     keyService: KeyService;
     localCacheFactory: LocalCacheFactory;
     lockService: LockService;

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

@@ -1,8 +1,8 @@
 import { BatchStatus } from '../classes';
 import { PromiseLibraryInterface } from '../interfaces';
-import { ItemId, PromiseInterface } from '../types';
+import { ItemId, ItemType, PromiseInterface } from '../types';
 export declare class BatchStatusFactory {
     private promiseService;
     constructor(promiseService: PromiseLibraryInterface);
-    construct<T>(getItemId: (entry: T) => ItemId, getPromise: (entry: T) => PromiseInterface<T>): BatchStatus<T>;
+    construct<T>(itemType: ItemType, getItemId: (entry: T) => ItemId, getPromise: (entry: T) => PromiseInterface<T>): BatchStatus<T>;
 }

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

@@ -1,9 +1,12 @@
-import { CollectionEntryService, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
-import { ColumnSetFactory, ItemEntryFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry } from '../models/';
+import { CollectionEntryService, ColumnHandler, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes/';
+import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories/';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces/';
+import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
+import { ItemType } from '../types/';
 export declare class CollectionEntryFactory {
     collectionEntryService: CollectionEntryService;
+    columnHandler: ColumnHandler;
+    columnExpansionFactory: ColumnExpansionFactory;
     columnSetFactory: ColumnSetFactory;
     errorHandler: ErrorHandlerInterface;
     itemEntryFactory: ItemEntryFactory;
@@ -13,6 +16,6 @@ export declare class CollectionEntryFactory {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     queryService: QueryService;
-    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
-    construct(itemType: string, options: any): CollectionEntry;
+    constructor(collectionEntryService: CollectionEntryService, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
+    construct(itemType: ItemType, options: CollectionEntryOptionsInterface): CollectionEntry;
 }

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

@@ -1,14 +1,13 @@
-import { CollectionResourceService, KeyService, LocalCache } from '../classes';
+import { KeyService, LocalCache } from '../classes';
 import { ChangesProcessorFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource } from '../models';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface } from '../models';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     itemResourceFactory: ItemResourceFactory;
     changesProcessorFactory: ChangesProcessorFactory;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    collectionResourceService: CollectionResourceService;
-    constructor(errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, collectionResourceService: CollectionResourceService);
-    construct(collectionEntry: CollectionEntry, options: any, localCache: LocalCache): CollectionResource;
+    constructor(errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, localCache: LocalCache): CollectionResource;
 }

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

@@ -0,0 +1,7 @@
+import { ColumnSubsetCache, ColumnUtil } from '../classes';
+import { ApiRequestColumns } from '../types';
+export declare class ColumnSubsetCacheFactory {
+    private columnUtil;
+    constructor(columnUtil: ColumnUtil);
+    construct(requestColumns: ApiRequestColumns): ColumnSubsetCache;
+}

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

@@ -1,15 +1,14 @@
-import { ApiFormatter, ChangesProcessor, ItemResourceService, LockService } from '../classes';
+import { ApiFormatter, ChangesProcessor, LockService } from '../classes';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, ItemResource } from '../models';
-import { ItemOptions } from '../types';
+import { ItemOptionsInterface } from '../types';
 export declare class ItemResourceFactory {
-    itemResourceService: ItemResourceService;
     apiFormatter: ApiFormatter;
     lockService: LockService;
     changesProcessor: ChangesProcessor;
     errorHandler: ErrorHandlerInterface;
     promiseService: PromiseLibraryInterface;
-    constructor(itemResourceService: ItemResourceService, apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
-    getConstructor(options: ItemOptions): (itemEntry: ItemEntry) => ItemResource;
-    construct(itemEntry: ItemEntry, options: ItemOptions, isNew?: boolean): ItemResource;
+    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;
 }

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

@@ -1,4 +1,4 @@
-import { ItemResourceService, LocalCache, LockService } from '../classes';
+import { LocalCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class LocalCacheFactory {
@@ -9,8 +9,7 @@ export declare class LocalCacheFactory {
     private changesProcessorFactory;
     private itemCacheFactory;
     private collectionResourceFactory;
-    private itemResourceService;
     private promiseService;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseLibraryInterface);
+    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, promiseService: PromiseLibraryInterface);
     construct(id?: string): LocalCache;
 }

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

@@ -9,6 +9,7 @@ export * from './CollectionResourceFactory';
 export * from './ColumnExpansionFactory';
 export * from './ColumnInfoFactory';
 export * from './ColumnSetFactory';
+export * from './ColumnSubsetCacheFactory';
 export * from './CreateRequestFactory';
 export * from './ItemCacheFactory';
 export * from './ItemEntryFactory';

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

@@ -9,7 +9,7 @@ export interface PromiseLibraryInterface {
     when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
     reject(value?: any): PromiseInterface<any>;
     defer(): {
-        (value?): any;
-        (value?): any;
+        (value?: any): any;
+        (value?: any): any;
     };
 }

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

@@ -1,10 +1,10 @@
 import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, ItemResource } from '../models';
+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: any, localCache: LocalCache);
+    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[]>;

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

@@ -1,13 +1,13 @@
 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';
+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: any;
+    options: CollectionEntryOptions;
     id: number;
-    query: any;
+    query: ApiQuery;
     columns: ColumnSet;
     templateColumns: ColumnSet | null;
     parent: EntryParentNull;
@@ -19,7 +19,7 @@ export declare class CollectionEntry {
     reloadQueued: boolean;
     hasEditResources: boolean;
     hasItemEditResources: boolean;
-    constructor(factory: CollectionEntryFactory, itemType: ItemType, options: any);
+    constructor(factory: CollectionEntryFactory, itemType: ItemType, options: CollectionEntryOptions);
     defer(): this;
     isDeferred(): boolean;
     _resolve(): this;
@@ -36,14 +36,17 @@ export declare class CollectionEntry {
     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?);
+    private handleAddedItemCallbacks;
     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>;
+    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>;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion): void;
     expandRequestColumns(requestColumns: ApiRequestColumns): void;

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,17 +1,17 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource } from '../models';
+import { CollectionResourceOptions, ItemEntry, ItemResource } from '../models';
 import { ItemResourceItemIdMap, PromiseInterface } from '../types';
 import { CollectionEntry } from './CollectionEntry';
 export declare class CollectionResource {
     private itemResourceFactory;
     entry: CollectionEntry;
-    options: any;
+    options: CollectionResourceOptions;
     localCache: LocalCache;
     items: ItemResource[];
     itemIdMap: ItemResourceItemIdMap;
     columns: any;
-    constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: any, localCache: LocalCache);
+    constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
     getItemById(itemId: number): ItemResource;
     rebuildMap(): void;
     addItemResources(itemEntries: ItemEntry[]): ItemResource[];

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';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions } from '../models';
 export declare class CollectionViewResource extends CollectionResource {
-    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: any, localCache: LocalCache);
+    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
 }

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

@@ -1,11 +1,11 @@
 import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
 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);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
     isNew(): boolean;
     start(): this;
     rollback(): this;

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

@@ -1,7 +1,7 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
 import { ItemResource } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType } from '../types';
 export declare class ItemEntry {
     private factory;
     itemType: string;
@@ -22,7 +22,7 @@ export declare class ItemEntry {
     resolve(): this;
     resolveDeferred(initial: any, derived: any, columns: any): this;
     isDeferred(): boolean;
-    reject(error?: any): this;
+    reject(error?: ItemError): this;
     setFields(initial: FieldMap, derived: FieldMap): this;
     setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
     clone(conversionMap?: ItemIdConversionMap): ItemEntry;
@@ -32,13 +32,13 @@ export declare class ItemEntry {
     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;

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

@@ -0,0 +1,18 @@
+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;
+    templateOptions: any;
+    templateColumns: any;
+    deferRequest: any;
+    isDuplicate: any;
+    constructor(values: ItemEntryOptionsInterface);
+}

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

@@ -1,15 +1,15 @@
-import { ItemEntry } from '../models';
+import { ItemEntry, ItemResourceOptions } from '../models';
 import { FieldMap, ResponseColumn } from '../types';
 export declare class ItemResource {
     entry: ItemEntry;
-    options: any;
+    options: ItemResourceOptions;
     protected readonly _isNew: boolean;
     columns: {
         [columnId: string]: ResponseColumn;
     };
     fields: FieldMap;
     derived: FieldMap;
-    constructor(entry: ItemEntry, options: any, _isNew?: boolean);
+    constructor(entry: ItemEntry, options: ItemResourceOptions, _isNew?: boolean);
     isNew(): boolean;
     isLocal(): boolean;
     clearResource(): void;

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

@@ -0,0 +1,13 @@
+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;
+    constructor(values: ItemResourceOptionsInterface);
+}

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

@@ -1,4 +1,4 @@
-import { ItemEntry, ItemResource } from '../models';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
 export declare class ViewResource extends ItemResource {
-    constructor(entry: ItemEntry, options: any, isNew?: boolean);
+    constructor(entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
 }

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

@@ -1,9 +1,13 @@
-export * from './CollectionEntry';
-export * from './CollectionResource';
-export * from './CollectionViewResource';
-export * from './CollectionEditResource';
+export * from './ItemEntryOptions';
+export * from './ItemResourceOptions';
 export * from './ItemEntry';
 export * from './ItemResource';
 export * from './ViewResource';
 export * from './EditResource';
+export * from './CollectionEntryOptions';
+export * from './CollectionResourceOptions';
+export * from './CollectionEntry';
+export * from './CollectionResource';
+export * from './CollectionViewResource';
+export * from './CollectionEditResource';
 export * from './Template';