@rentman/rm-core 1.0.0 → 1.0.1

package/dist/definitions/classes/ItemEntryService.d.ts

@@ -0,0 +1,50 @@
+import ApiFormatter from './ApiFormatter';
+import KeyService from './KeyService';
+import PromiseService from "./PromiseService";
+export default class ItemEntryService {
+    private apiFormatter;
+    private keyService;
+    private promiseService;
+    undefinedItemError: string;
+    ALL_PERMISSIONS: number;
+    constructor(apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseService);
+    resetDerived(itemEntry: any, columnIds: any): void;
+    defer(itemEntry: any, deferRequest: any): any;
+    resolve(itemEntry: any): any;
+    reject(itemEntry: any, error?: string): any;
+    clearResources(itemEntry: any): void;
+    deactivateResources(itemEntry: any): void;
+    getFields(itemEntry: any): any;
+    expand(entry: any, main: any, derived: any, expandResource: any): any;
+    processOptions(options: any): any;
+    getConversionValue(itemType: any, itemId: any, map: any): any;
+    updateFields(entry: any, source: any, overwrite?: boolean): any;
+    updateItemValue(entry: any, fields: any, apiColumn: any, conversionMap: any): void;
+    updateItemFields(entry: any, conversionMap: any): void;
+    process(entry: any): any;
+    formatRequest(entry: any): {};
+    setDisplayName(entry: any): void;
+    getDisplayName(entry: any): any;
+    getFullName(firstName: any, infix: any, lastName: any): any;
+    getTitleField(itemType: any): "serienummer" | "nummer" | "friendlyname" | "naamintern" | "omschrijving" | "code" | "naam" | "displayname";
+    /**
+     *
+     * @param {Object} entry
+     * @param {Boolean} returnAll Returns all initial values if true
+     * @returns {Object}
+     */
+    getChanges(entry: any, returnAll: any): any[];
+    isLocal(entry: any): boolean;
+    isLockable(entry: any): boolean;
+    hasChanges(entry: any): boolean;
+    resetModified(entry: any): void;
+    setInitial(entry: any, values: any, enableCallbacks: any): any;
+    /**
+     * Does a shallow copy of values!
+     */
+    setModified(entry: any, values?: any): any;
+    setDerived(entry: any, values: any): any;
+    processLocal(entry: any, initial: any, modified: any, derived: any, conversionMap: any): any;
+    setParent(entry: any, parentType: any, parentId: any): any;
+    callOnChange(entry: any, previous: any): void;
+}

package/dist/definitions/classes/ItemHandler.d.ts

@@ -0,0 +1,70 @@
+import BatchStatusFactory from "../factories/BatchStatusFactory";
+import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import ItemCacheFactory from "../factories/ItemCacheFactory";
+import ItemEntryFactory from "../factories/ItemEntryFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import AuthInterface from '../interfaces/AuthInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ItemEntry from "../models/ItemEntry";
+import ApiFormatter from "./ApiFormatter";
+import ColumnHandler from './ColumnHandler';
+import ColumnUtil from './ColumnUtil';
+import ItemCache from "./ItemCache";
+import ItemEntryService from "./ItemEntryService";
+import KeyService from "./KeyService";
+import PromiseService from "./PromiseService";
+export default class ItemHandler {
+    private apiRequestService;
+    private authInterface;
+    private errorHandler;
+    private itemEntryFactory;
+    private columnHandler;
+    private itemCacheFactory;
+    private batchStatusFactory;
+    private columnExpansionFactory;
+    private columnSetFactory;
+    private itemEntryService;
+    private apiFormatter;
+    private keyService;
+    private promiseService;
+    private columnUtil;
+    entries: ItemCache;
+    templates: {};
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, columnHandler: ColumnHandler, itemCacheFactory: ItemCacheFactory, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseService, columnUtil: ColumnUtil);
+    getItemId(itemEntry: ItemEntry): number;
+    getPromise(itemEntry: ItemEntry): any;
+    fetchItem(itemType: string, itemId: number, options: any): any;
+    fetchItems(itemType: any, itemIds: any, options: any): Promise<any>;
+    resolveCached(itemEntry: ItemEntry, status: any, options: any): any;
+    resolveLocal(itemEntry: ItemEntry, parent: any, template: any): {
+        main: ItemEntry;
+        linked: any[];
+    };
+    resolveExpansion(itemEntry: any, columnExpansion: any, response: any): any;
+    resolveRemote(itemEntry: any, columnInfo: any, response: any): any;
+    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
+    getEntryStatus(itemType: string, itemId: number, options: any): {
+        entry: any;
+        status: string;
+    };
+    getCachedEntryStatus(itemEntry: ItemEntry, options: any): string;
+    createDeferredEntry(itemType: string, itemId: number, requestColumns: any, deferRequest: any): any;
+    createEntryStub(itemType: string, itemId: number): ItemEntry;
+    createEntry(itemId: number, initial: any, derived: any, columnInfo: any): any;
+    resolveDeferredEntry(itemEntry: any, initial: any, derived: any, columns: any): any;
+    batchResolve(itemType: any, batchStatus: any, requestColumns: any, resolved: any): any;
+    cloneItem(newItemId: any, itemEntry: any, conversionMap?: any): any;
+    createConversionMap(itemType: string, itemId: number, extend: boolean, response: any): {
+        [x: string]: {
+            [x: number]: number;
+        };
+    };
+    createLocalEntries(parentType: string, localParentId: number, template: any, conversionMap: any): any[];
+    createLocalEntry(itemId: number, template: any, modified: any, derived: any, parent?: any): ItemEntry;
+    extendConversionMap(conversionMap: any, links: any, apiResponse: any): void;
+    fetchTitle(itemType: string, itemId: number, deferRequest?: boolean): any;
+    requestItem(itemType: string, itemId: number | number[], columns: any): Promise<any>;
+    updateItemId(itemEntry: any, itemId: any): ItemEntry;
+    private setCreator;
+}

package/dist/definitions/classes/ItemRequestService.d.ts

@@ -0,0 +1,31 @@
+import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import ItemEntry from "../models/ItemEntry";
+import ColumnExpansion from "./ColumnExpansion";
+import ColumnHandler from "./ColumnHandler";
+import ItemEntryService from "./ItemEntryService";
+import ItemHandler from "./ItemHandler";
+import PromiseService from "./PromiseService";
+import QueryService from "./QueryService";
+export default class ItemRequestService {
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    private columnHandler;
+    private columnExpansionFactory;
+    private columnSetFactory;
+    private itemEntryService;
+    private queryService;
+    private promiseService;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, queryService: QueryService, promiseService: PromiseService);
+    requestItem(itemType: any, itemId: any, columns: any): Promise<any>;
+    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<any>;
+    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<any>;
+    processExpansion(requestColumns: any, response: any, itemType: string, itemEntries: ItemEntry[]): ColumnExpansion;
+    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): Promise<ItemEntry[]>;
+    handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
+    processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): Promise<any>;
+}

package/dist/definitions/classes/ItemResourceService.d.ts

@@ -0,0 +1,8 @@
+import ItemEntryService from "./ItemEntryService";
+export default class ItemResourceService {
+    private itemEntryService;
+    constructor(itemEntryService: ItemEntryService);
+    processOptions(options: any): any;
+    compareOptions(first: any, second: any): boolean;
+    isNew(resource: any): boolean;
+}

package/dist/definitions/classes/KeyService.d.ts

@@ -0,0 +1,28 @@
+export default class KeyService {
+    NEW_PREFIX: string;
+    DUPLICATE_PREFIX: string;
+    NEW_KEYWORD: string;
+    DUPLICATE_KEYWORD: string;
+    seperator: string;
+    constructor();
+    getSingleKey(itemType: string, itemId: number | string): string;
+    getCollectionCacheKey(parentType: string, parentId: number, childType: string): string;
+    getCssKey(): any;
+    parseStateKey(stateKey: string): {
+        type: string;
+        template: string;
+        itemId?: undefined;
+    } | {
+        type: string;
+        itemId: string;
+        template?: undefined;
+    };
+    getDuplicateStateKey(itemId: string | number): string;
+    getNewStateKey(templateType: string): string;
+    getLocalId(): number;
+    getLocalDuplicateId(): number;
+    getRandomString(): string;
+    isLocalId(itemId: number | string): boolean;
+    isNewId(itemId: number | string): boolean;
+    isDuplicateId(itemId: number | string): boolean;
+}

package/dist/definitions/classes/LockService.d.ts

@@ -0,0 +1,25 @@
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ItemEntry from "../models/ItemEntry";
+import KeyService from "./KeyService";
+import PromiseService from "./PromiseService";
+export default class LockService {
+    private apiRequestService;
+    private errorHandler;
+    private keyService;
+    private promiseService;
+    lockItems: {};
+    promises: {};
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseService);
+    getValue(itemEntry: ItemEntry, map: any): any;
+    setValue(itemEntry: ItemEntry, value: any, map: any): any;
+    getLocks(): {};
+    hasLock(lockTokenId: any): boolean;
+    isLocked(itemEntry: ItemEntry): any;
+    getMessage(itemEntry: any): any;
+    fetchCachedLock(itemEntry: ItemEntry): any;
+    fetchLock(itemEntry: ItemEntry): any;
+    requestLock(itemEntry: ItemEntry): any;
+    deleteLock(itemEntry: any): any;
+    clearLock(itemEntry: any): boolean;
+}

package/dist/definitions/classes/ModuleChangesCompiler.d.ts

@@ -0,0 +1,18 @@
+import ItemEntry from "../models/ItemEntry";
+import CollectionCache from "./CollectionCache";
+import ItemCache from "./ItemCache";
+import ItemEntryService from "./ItemEntryService";
+export default class ModuleChangesCompiler {
+    private itemEntryService;
+    private rootItemEntry;
+    private singleItemCache;
+    private collectionCache;
+    parentMap: any;
+    destination: any;
+    constructor(itemEntryService: ItemEntryService, rootItemEntry: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache);
+    process(): void;
+    private createParentMap;
+    private processItems;
+    private processItem;
+    private getItemsByParent;
+}

package/dist/definitions/classes/PromiseService.d.ts

@@ -0,0 +1,10 @@
+export default class PromiseService {
+    all(iterable: any): Promise<any>;
+    when(value?: any): Promise<any>;
+    reject(value?: any): Promise<any>;
+    defer(): {
+        resolve(value?: any): any;
+        reject(value?: any): any;
+        promise: Promise<any>;
+    };
+}

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

@@ -0,0 +1,14 @@
+import ApiFormatter from './ApiFormatter';
+export default class QueryMatcher {
+    private apiFormatter;
+    parentType: string;
+    parentId: number;
+    fields: object;
+    itemType?: string;
+    constructor(apiFormatter: ApiFormatter, parentType: string, parentId: number, fields: object, itemType?: string);
+    private compareValues;
+    matchQuery(query: any): boolean | string;
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
+}

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

@@ -0,0 +1,16 @@
+export default class QueryParser {
+    query: any;
+    parameters: any;
+    constructor(query: any, parameters: any);
+    private processValue;
+    private compareParsedQueries;
+    parse(query?: any): any;
+    private parseSearchQuery;
+    private parseCustomQuery;
+    private parseCustomParameters;
+    private parseSimpleQuery;
+    private parseLinkedToQuery;
+    private parseComplexQuery;
+    private parseConditions;
+    private formatValue;
+}

package/dist/definitions/classes/QueryService.d.ts

@@ -0,0 +1,19 @@
+export default class QueryService {
+    constructor();
+    addAndCondition(query: any, condition: any): {
+        conditions: any;
+    };
+    addOrCondition(query: any, condition: any): {
+        conditions: any;
+        operator?: undefined;
+    } | {
+        conditions: any[];
+        operator: string;
+    };
+    addParentCondition(query: any, parent: any): any;
+    createNotIn(idArray: any): {
+        comparator: string;
+        key: string;
+        value: any;
+    };
+}

package/dist/definitions/classes/RequestColumnExpansion.d.ts

@@ -0,0 +1,9 @@
+import ColumnUtil from "./ColumnUtil";
+export default class RequestColumnExpansion {
+    private columnUtil;
+    private columns;
+    private columnInfoIdMap;
+    constructor(columnUtil: ColumnUtil);
+    expand(columnInfo: any): void;
+    get(): {};
+}

package/dist/definitions/classes/ResourceCache.d.ts

@@ -0,0 +1,78 @@
+import ChangesProcessorFactory from "../factories/ChangesProcessorFactory";
+import CollectionCacheFactory from "../factories/CollectionCacheFactory";
+import CollectionResourceFactory from "../factories/CollectionResourceFactory";
+import ItemCacheFactory from "../factories/ItemCacheFactory";
+import ItemResourceFactory from "../factories/ItemResourceFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import CollectionResource from "../models/CollectionResource";
+import ItemEntry from "../models/ItemEntry";
+import ItemResource from "../models/ItemResource";
+import CollectionCache from "./CollectionCache";
+import CollectionHandler from "./CollectionHandler";
+import ColumnHandler from "./ColumnHandler";
+import ItemCache from './ItemCache';
+import ItemEntryService from './ItemEntryService';
+import ItemHandler from "./ItemHandler";
+import ItemResourceService from './ItemResourceService';
+import LockService from "./LockService";
+import PromiseService from "./PromiseService";
+export default class ResourceCache {
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    private collectionHandler;
+    private columnHandler;
+    private lockService;
+    private itemResourceFactory;
+    private collectionCacheFactory;
+    private changesProcessorFactory;
+    private itemCacheFactory;
+    private collectionResourceFactory;
+    private itemEntryService;
+    private itemResourceService;
+    private promiseService;
+    collections: CollectionCache;
+    deferredCollections: CollectionCache;
+    items: ItemCache;
+    collectionOptions: {};
+    tabRequestParameters: {};
+    callbacks: {
+        onBeforeSave: {};
+        onSaveSuccess: {};
+        onSaveWithoutClosing: {};
+    };
+    changesInterval: null | number;
+    _hasChanges: boolean;
+    rootItem: ItemEntry;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemEntryService: ItemEntryService, itemResourceService: ItemResourceService, promiseService: PromiseService);
+    addSingleItem(itemEntry: ItemEntry, options: any, isRoot: any): ItemResource;
+    addCollection(collectionEntry: CollectionEntry, resourceOptions: any): CollectionResource;
+    clearCollection(collectionResource: CollectionResource): void;
+    clearItem(itemResource: ItemResource): void;
+    clearResources(isSubTabChange?: boolean): void;
+    updateSingleItems(conversionMap: any): void;
+    revertChanges(): void;
+    resetCollection(collectionEntry: CollectionEntry): void;
+    hasChanges(): boolean;
+    detectChanges(): boolean;
+    collectionHasChanges(collectionEntry: CollectionEntry): boolean;
+    isLockable(): boolean;
+    save(closeTab: boolean, parameters: any, breakUpByParent: any, onAfterCreateCallback: any): any;
+    executeCallbacks(event: any, callbackParameter: any): Promise<any>;
+    enableChangesWatcher(): void;
+    /**
+     * @deprecated
+     */
+    enableWatcher(): void;
+    disableChangesWatcher(): void;
+    /**
+     * @deprecated
+     */
+    disableWatcher(): void;
+    /**
+     * @deprecated
+     */
+    registerCallback(event: string, key: string, callback: any): () => void;
+}

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

@@ -0,0 +1,25 @@
+export declare function shallowMerge(object: any, defaults: any): any;
+export declare function hasProperties(object: any): boolean;
+export declare function getFirstProperty(object: any): string;
+export declare function inArray(needle: any, haystack: any): boolean;
+export declare function filterArray(source: any, callback: any): boolean;
+export declare function emptyArray(array: any): void;
+export declare function pathExists(source: any, path: any): boolean;
+export declare function createPath(object: any, path: any, defaults: any): any;
+export declare function getPath(object: any, path: any, create?: boolean): any;
+export declare function extend(dst: any, ...args: any[]): any;
+export declare function merge(dst: any, ...args: any[]): any;
+export declare function isObject(value: any): boolean;
+export declare function isBlankObject(value: any): boolean;
+export declare function isString(value: any): boolean;
+export declare function isNumber(value: any): boolean;
+export declare function isDate(value: any): boolean;
+export declare const isArray: (arg: any) => arg is any[];
+export declare function isFunction(value: any): boolean;
+export declare function isRegExp(value: any): boolean;
+export declare function isBoolean(value: any): boolean;
+export declare function isElement(node: any): boolean;
+export declare function isWindow(obj: any): boolean;
+export declare function isDefined(value: any): boolean;
+export declare function equals(o1: any, o2: any): boolean;
+export declare function copy(source: any, destination?: any, maxDepth?: number): any;

package/dist/definitions/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const ENTRY_STATUS: {
+    CACHED: string;
+    PROMISED: string;
+    EXPAND: string;
+    PROMISED_EXPAND: string;
+    RESOLVE: string;
+    LOCAL: string;
+};
+export declare const COLUMN_SEPERATOR = ">";
+export declare const RENDER_AS_SEPERATOR = ":";

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

@@ -0,0 +1,8 @@
+import BatchStatus from "../classes/BatchStatus";
+import PromiseService from '../classes/PromiseService';
+import ItemEntry from "../models/ItemEntry";
+export default class BatchStatusFactory {
+    private promiseService;
+    constructor(promiseService: PromiseService);
+    construct(getItemId: (itemEntry: ItemEntry) => number, getPromise: (itemEntry: ItemEntry) => Promise<any>): BatchStatus;
+}

package/dist/definitions/factories/ChangesCompilerFactory.d.ts

@@ -0,0 +1,9 @@
+import ChangesCompiler from "../classes/ChangesCompiler";
+import ItemEntryService from '../classes/ItemEntryService';
+import CollectionEntry from "../models/CollectionEntry";
+import ItemEntry from "../models/ItemEntry";
+export default class ChangesCompilerFactory {
+    private itemEntryService;
+    constructor(itemEntryService: ItemEntryService);
+    construct(singleItems: ItemEntry[], collections: CollectionEntry[], collectionOptions: any): ChangesCompiler;
+}

package/dist/definitions/factories/ChangesProcessorFactory.d.ts

@@ -0,0 +1,31 @@
+import ApiFormatter from '../classes/ApiFormatter';
+import ChangesProcessor from "../classes/ChangesProcessor";
+import CollectionEntryService from "../classes/CollectionEntryService";
+import CollectionHandler from "../classes/CollectionHandler";
+import ColumnHandler from "../classes/ColumnHandler";
+import ItemEntryService from '../classes/ItemEntryService';
+import ItemHandler from "../classes/ItemHandler";
+import PromiseService from '../classes/PromiseService';
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ChangesCompilerFactory from "./ChangesCompilerFactory";
+import ColumnExpansionFactory from "./ColumnExpansionFactory";
+import CreateRequestFactory from "./CreateRequestFactory";
+import RequestColumnExpansionFactory from "./RequestColumnExpansionFactory";
+export default class ChangesProcessorFactory {
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    private collectionHandler;
+    private columnHandler;
+    private changesCompilerFactory;
+    private createRequestFactory;
+    private columnExpansionFactory;
+    private requestColumnExpansionFactory;
+    private collectionEntryService;
+    private itemEntryService;
+    private apiFormatter;
+    private promiseService;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, changesCompilerFactory: ChangesCompilerFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, promiseService: PromiseService);
+    construct(): ChangesProcessor;
+}

package/{src/factories/CollectionCacheFactory.ts → dist/definitions/factories/CollectionCacheFactory.d.ts}

@@ -1,15 +1,7 @@
 import CollectionCache from "../classes/CollectionCache";
 import QueryMatcherFactory from "./QueryMatcherFactory";
-
 export default class CollectionCacheFactory {
-	constructor (
-		private queryMatcherFactory: QueryMatcherFactory
-	) {
-	}
-
-	construct () {
-		return new CollectionCache(
-			this.queryMatcherFactory
-		);
-	}
+    private queryMatcherFactory;
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    construct(): CollectionCache;
 }

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

@@ -0,0 +1,19 @@
+import CollectionEntryService from "../classes/CollectionEntryService";
+import ItemEntryService from '../classes/ItemEntryService';
+import ItemRequestService from "../classes/ItemRequestService";
+import KeyService from '../classes/KeyService';
+import PromiseService from '../classes/PromiseService';
+import QueryService from '../classes/QueryService';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+export default class CollectionEntryFactory {
+    private errorHandler;
+    private collectionEntryService;
+    private itemRequestService;
+    private itemEntryService;
+    private keyService;
+    private queryService;
+    private promiseService;
+    constructor(errorHandler: ErrorHandlerInterface, collectionEntryService: CollectionEntryService, itemRequestService: ItemRequestService, itemEntryService: ItemEntryService, keyService: KeyService, queryService: QueryService, promiseService: PromiseService);
+    construct(itemType: string, options: any): CollectionEntry;
+}

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

@@ -0,0 +1,18 @@
+import ItemHandler from "../classes/ItemHandler";
+import KeyService from '../classes/KeyService';
+import PromiseService from '../classes/PromiseService';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import CollectionResource from "../models/CollectionResource";
+import ChangesProcessorFactory from './ChangesProcessorFactory';
+import ItemResourceFactory from "./ItemResourceFactory";
+export default class CollectionResourceFactory {
+    private errorHandler;
+    private itemHandler;
+    private itemResourceFactory;
+    private changesProcessorFactory;
+    private keyService;
+    private promiseService;
+    constructor(errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseService);
+    construct(collectionEntry: CollectionEntry, options: any): CollectionResource;
+}

package/dist/definitions/factories/ColumnExpansionFactory.d.ts

@@ -0,0 +1,11 @@
+import ColumnExpansion from "../classes/ColumnExpansion";
+import ColumnHandler from "../classes/ColumnHandler";
+import ColumnUtil from '../classes/ColumnUtil';
+import ColumnSetFactory from "./ColumnSetFactory";
+export default class ColumnExpansionFactory {
+    private columnHandler;
+    private columnSetFactory;
+    private columnUtil;
+    constructor(columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
+    construct(itemType: string, requestColumns: any | boolean, responseColumns: any): ColumnExpansion;
+}

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

@@ -0,0 +1,9 @@
+import ColumnHandler from "../classes/ColumnHandler";
+import ColumnSet from "../classes/ColumnSet";
+import ColumnUtil from '../classes/ColumnUtil';
+export default class ColumnSetFactory {
+    private columnHandler;
+    private columnUtil;
+    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil);
+    construct(itemType: string, requestColumns: any, responseColumns: any, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet;
+}

package/dist/definitions/factories/CreateRequestFactory.d.ts

@@ -0,0 +1,13 @@
+import CollectionHandler from "../classes/CollectionHandler";
+import CreateRequest from "../classes/CreateRequest";
+import ItemEntryService from '../classes/ItemEntryService';
+import KeyService from '../classes/KeyService';
+import RequestColumnExpansionFactory from "./RequestColumnExpansionFactory";
+export default class CreateRequestFactory {
+    private collectionHandler;
+    private requestColumnExpansionFactory;
+    private itemEntryService;
+    private keyService;
+    constructor(collectionHandler: CollectionHandler, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, keyService: KeyService);
+    construct(compilation: any, parameterMap: any, breakupByParent?: boolean): CreateRequest;
+}

package/dist/definitions/factories/ItemCacheFactory.d.ts

@@ -0,0 +1,9 @@
+import ItemCache from "../classes/ItemCache";
+import ItemEntryService from '../classes/ItemEntryService';
+import QueryMatcherFactory from "./QueryMatcherFactory";
+export default class ItemCacheFactory {
+    private queryMatcherFactory;
+    private itemEntryService;
+    constructor(queryMatcherFactory: QueryMatcherFactory, itemEntryService: ItemEntryService);
+    construct(): ItemCache;
+}

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

@@ -0,0 +1,6 @@
+import ItemEntry from "../models/ItemEntry";
+import ItemResource from "../models/ItemResource";
+export default class ItemEntryFactory {
+    constructor();
+    construct(itemType: string, itemId: number, columns?: any, initial?: {}, derived?: {}, resources?: ItemResource[]): ItemEntry;
+}

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

@@ -0,0 +1,12 @@
+import ItemEntryService from '../classes/ItemEntryService';
+import ItemResourceService from "../classes/ItemResourceService";
+import { EditResource } from "../models/EditResource";
+import ItemEntry from "../models/ItemEntry";
+import ItemResource from "../models/ItemResource";
+export default class ItemResourceFactory {
+    private itemEntryService;
+    private itemResourceService;
+    constructor(itemEntryService: ItemEntryService, itemResourceService: ItemResourceService);
+    getConstructor(options: any): (itemEntry: any) => EditResource;
+    construct(itemEntry: ItemEntry, options: any): ItemResource;
+}

package/{src/factories/ModuleChangesCompilerFactory.ts → dist/definitions/factories/ModuleChangesCompilerFactory.d.ts}

@@ -3,19 +3,8 @@ import ItemCache from "../classes/ItemCache";
 import ItemEntryService from '../classes/ItemEntryService';
 import ModuleChangesCompiler from "../classes/ModuleChangesCompiler";
 import ItemEntry from "../models/ItemEntry";
-
 export default class ModuleChangesCompilerFactory {
-	constructor (
-		private itemEntryService: ItemEntryService
-	) {
-	}
-
-	construct (rootItem: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache) {
-		return new ModuleChangesCompiler(
-			this.itemEntryService,
-			rootItem,
-			singleItemCache,
-			collectionCache
-		);
-	}
+    private itemEntryService;
+    constructor(itemEntryService: ItemEntryService);
+    construct(rootItem: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache): ModuleChangesCompiler;
 }

package/dist/definitions/factories/QueryMatcherFactory.d.ts

@@ -0,0 +1,7 @@
+import ApiFormatter from '../classes/ApiFormatter';
+import QueryMatcher from "../classes/QueryMatcher";
+export default class QueryMatcherFactory {
+    private apiFormatter;
+    constructor(apiFormatter: ApiFormatter);
+    construct(parentType: string, parentId: number, fields: object, itemType?: string): QueryMatcher;
+}