@rentman/rm-core 1.1.19 → 1.2.0

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

@@ -1,25 +1,29 @@
-import { ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
-import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory } from '../factories';
+import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ApiResponse, ApiTemplateItemTypeMap, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
+import { ItemEntry, Template } from '../models';
+import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
 export declare class ItemHandler {
+    private apiFormatter;
     private apiRequestService;
-    private errorHandler;
-    private itemEntryFactory;
-    private columnHandler;
-    private itemCacheFactory;
     private batchStatusFactory;
     private columnExpansionFactory;
+    private columnHandler;
     private columnSetFactory;
+    private columnUtil;
+    private errorHandler;
+    private itemCacheFactory;
+    private itemEntryFactory;
     private itemEntryService;
     private keyService;
     private promiseService;
-    private columnUtil;
+    private templateFactory;
     entries: ItemCache;
-    templates: ApiTemplateItemTypeMap;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, columnHandler: ColumnHandler, itemCacheFactory: ItemCacheFactory, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface, columnUtil: ColumnUtil);
+    templates: {
+        [itemType: string]: Template;
+    };
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface, templateFactory: TemplateFactory);
     fetchItem(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): Promise<ItemEntry | TemplateResponseItemEntryMap>;
     /**
      *
@@ -31,7 +35,7 @@ export declare class ItemHandler {
      * For every itemid find the status of the ItemEntry and resolve the promises so the result is
      * a usable ItemEntry
      */
-    fetchItems(itemType: any, itemIds: any, options: any, localItemCache: ItemCache): Promise<ItemEntry[]>;
+    fetchItems(itemType: ItemType, itemIds: ItemId[], options: any, localItemCache: ItemCache): Promise<ItemEntry[]>;
     resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): Promise<ItemEntry>;
     resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateResponseItemEntryMap;
     resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
@@ -41,7 +45,7 @@ export declare class ItemHandler {
         initial: FieldMap;
         derived: FieldMap;
     } | null;
-    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
+    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<Template>;
     getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry>;
     isColumnSuperset(itemEntry: ItemEntry, columns: RequestColumns): any;
     getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
@@ -59,6 +63,10 @@ export declare class ItemHandler {
     batchResolve(itemType: ItemType, batchStatus: BatchStatus, requestColumns: RequestColumns, resolved: any, localItemCache: ItemCache): ItemEntry[] | Promise<any>;
     createLocalEntries(parentType: ItemType, localParentId: ItemId, template: any, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, excludeItemTypes?: ItemType[]): TemplateResponseLinkedItemEntryMap[];
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): Promise<any>;
+    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): Promise<ItemEntry[]>;
+    private getDefaultValuesByColumn(itemEntries, rootColumn);
+    private getItemIdByColumn(itemEntry, column);
+    private fetchDerivedValuesByColumn(itemEntries, rootColumn, localItemCache);
     requestItem(itemEntry: ItemEntry, requestColumns?: RequestColumns): Promise<ApiResponseProcessor>;
     requestItems(itemType: ItemType, itemIds: ItemId[], columns: RequestColumns): Promise<ApiResponseProcessor>;
 }

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

@@ -27,6 +27,6 @@ export declare class SocketMessageHandler {
     handleResponse(itemType: any, requestIds: any, requestColumns: any, response: any, collectionMap: any): {};
     handleCreate(message: any): Promise<any> | undefined;
     handleUpdate(message: any): Promise<any>;
-    handleDelete(message: any): Promise<any>;
+    handleDelete(message: any): Promise<{}>;
     handleLinkMove(): void;
 }

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

@@ -1,16 +1,18 @@
-import { CollectionEntryService, ItemEntryService, ItemRequestService, KeyService, QueryService } from '../classes';
-import { ColumnSetFactory } from '../factories';
+import { CollectionEntryService, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
+import { ColumnSetFactory, ItemEntryFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry } from '../models/';
 export declare class CollectionEntryFactory {
     collectionEntryService: CollectionEntryService;
     columnSetFactory: ColumnSetFactory;
     errorHandler: ErrorHandlerInterface;
+    itemEntryFactory: ItemEntryFactory;
     itemEntryService: ItemEntryService;
+    itemHandler: ItemHandler;
     itemRequestService: ItemRequestService;
     keyService: KeyService;
     promiseService: PromiseInterface;
     queryService: QueryService;
-    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService);
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService);
     construct(itemType: string, options: any): CollectionEntry;
 }

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

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

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

@@ -1,8 +1,6 @@
 import { ColumnExpansion, ColumnUtil } from '../classes';
-import { ColumnSetFactory } from '../factories';
 export declare class ColumnExpansionFactory {
-    private columnSetFactory;
     private columnUtil;
-    constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
+    constructor(columnUtil: ColumnUtil);
     construct(itemType: string, requestColumns: any | boolean, responseColumns: any): ColumnExpansion;
 }

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

@@ -1,7 +1,7 @@
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
 import { ColumnSetFactory } from '../factories';
 import { AuthInterface, PromiseInterface } from '../interfaces';
-import { ItemEntry } from '../models';
+import { ItemEntry, Template } from '../models';
 import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
 export declare class ItemEntryFactory {
     authInterface: AuthInterface;
@@ -11,9 +11,9 @@ export declare class ItemEntryFactory {
     keyService: KeyService;
     promiseService: PromiseInterface;
     constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface);
-    constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: any): ItemEntry;
-    constructLocalLinked(itemType: ItemType, localItemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
-    constructLocal(itemId: ItemId, template: any, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, conversionMap?: any): ItemEntry;
+    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;
     constructDeferred(itemType: ItemType, itemId: ItemId, requestColumns: RequestColumns, deferRequest: boolean): ItemEntry;
     construct(itemId: ItemId, initial: FieldMap, derived: FieldMap, columnInfo: ColumnSet): ItemEntry;
 }

package/dist/dist/factories/TemplateFactory.d.ts

@@ -0,0 +1,10 @@
+import { ColumnUtil } from '../classes';
+import { ColumnSetFactory } from '../factories';
+import { Template } from '../models';
+import { ApiResponse, ItemType, ResponseColumnMap } from '../types';
+export declare class TemplateFactory {
+    columnSetFactory: ColumnSetFactory;
+    columnUtil: ColumnUtil;
+    constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
+    construct(itemType: ItemType, response: ApiResponse, additionalColumns: ResponseColumnMap): Template;
+}

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

@@ -18,3 +18,4 @@ export * from './ModuleChangesCompilationFactory';
 export * from './QueryMatcherFactory';
 export * from './QueryParserFactory';
 export * from './RequestColumnExpansionFactory';
+export * from './TemplateFactory';

package/dist/dist/interfaces/PromiseInterface.d.ts

@@ -5,7 +5,7 @@ export interface PromiseInterface {
     }): Promise<{
         [key: string]: any;
     }>;
-    when(value?: any): Promise<any>;
+    when<T>(value?: T): Promise<T>;
     reject(value?: any): Promise<any>;
     defer(): {
         (value?): any;

package/dist/dist/main.d.ts

@@ -1,46 +1,47 @@
 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 } from './factories';
+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 { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseInterface } from './interfaces';
 export declare class RmCore {
     version: string;
     noop: typeof noop;
     apiFormatter: ApiFormatter;
-    keyService: KeyService;
-    queryService: QueryService;
-    columnUtil: ColumnUtil;
+    apiRequestService: ApiRequestService;
     apiResponseProcessorFactory: ApiResponseProcessorFactory;
-    itemEntryService: ItemEntryService;
-    itemResourceService: ItemResourceService;
-    itemAdministrator: ItemAdministrator;
-    itemRequestService: ItemRequestService;
-    columnCache: ColumnCache;
-    columnHandler: ColumnHandler;
-    itemEntryFactory: ItemEntryFactory;
-    collectionEntryFactory: CollectionEntryFactory;
+    batchStatusFactory: BatchStatusFactory;
+    changesCompilationFactory: ChangesCompilationFactory;
+    changesProcessorFactory: ChangesProcessorFactory;
     collectionCacheFactory: CollectionCacheFactory;
-    collectionMatcherFactory: CollectionMatcherFactory;
-    itemHandler: ItemHandler;
-    collectionHandler: CollectionHandler;
-    lockService: LockService;
+    collectionEntryFactory: CollectionEntryFactory;
     collectionEntryService: CollectionEntryService;
-    collectionResourceService: CollectionResourceService;
+    collectionHandler: CollectionHandler;
+    collectionMatcherFactory: CollectionMatcherFactory;
     collectionResourceFactory: CollectionResourceFactory;
-    queryMatcherFactory: QueryMatcherFactory;
-    itemCacheFactory: ItemCacheFactory;
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    changesCompilationFactory: ChangesCompilationFactory;
-    changesProcessorFactory: ChangesProcessorFactory;
+    collectionResourceService: CollectionResourceService;
+    columnCache: ColumnCache;
     columnExpansionFactory: ColumnExpansionFactory;
-    columnSetFactory: ColumnSetFactory;
+    columnHandler: ColumnHandler;
     columnInfoFactory: ColumnInfoFactory;
+    columnSetFactory: ColumnSetFactory;
+    columnUtil: ColumnUtil;
     createRequestFactory: CreateRequestFactory;
+    itemAdministrator: ItemAdministrator;
+    itemCacheFactory: ItemCacheFactory;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    itemHandler: ItemHandler;
+    itemRequestService: ItemRequestService;
     itemResourceFactory: ItemResourceFactory;
+    itemResourceService: ItemResourceService;
+    keyService: KeyService;
     localCacheFactory: LocalCacheFactory;
+    lockService: LockService;
     moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    queryMatcherFactory: QueryMatcherFactory;
     queryParserFactory: QueryParserFactory;
-    batchStatusFactory: BatchStatusFactory;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
     socketMessageHandler: SocketMessageHandler;
-    apiRequestService: ApiRequestService;
+    templateFactory: TemplateFactory;
     constructor(externalApiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface, promiseInterface: PromiseInterface);
 }
 export declare function noop(): void;

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

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

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

@@ -1,7 +1,7 @@
-import { ColumnExpansion, ColumnInfo, ColumnSet } from '../classes';
+import { ColumnExpansion, ColumnInfo, ColumnSet, ItemCache } from '../classes';
 import { CollectionEntryFactory } from '../factories';
 import { CollectionResource, ItemEntry, ItemResource } from '../models';
-import { EntryParentNull, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
+import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
 export declare class CollectionEntry {
     private factory;
     itemType: ItemType;
@@ -9,6 +9,7 @@ export declare class CollectionEntry {
     id: number;
     query: any;
     columns: ColumnSet;
+    templateColumns: ColumnSet | null;
     parent: EntryParentNull;
     initial: ItemEntry[];
     items: ItemEntry[];
@@ -19,7 +20,7 @@ export declare class CollectionEntry {
     hasEditResources: boolean;
     hasItemEditResources: boolean;
     constructor(factory: CollectionEntryFactory, itemType: ItemType, options: any);
-    defer(): void;
+    defer(): this;
     isDeferred(): boolean;
     _resolve(): this;
     resolve(itemEntryCompound: {
@@ -31,6 +32,8 @@ export declare class CollectionEntry {
     forEach(callback: (itemEntry: ItemEntry) => void): void;
     getItemById(itemId: any): ItemEntry | undefined;
     getIdArray(accumulator?: ItemId[]): ItemId[];
+    createItems(valuesArray: FieldMap[]): Promise<ItemEntry[]>;
+    resolveDerivedValues(itemEntries: ItemEntry[], localItemCache: ItemCache): Promise<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;

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

@@ -1,3 +1,4 @@
+import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource } from '../models';
 import { ItemResourceItemIdMap } from '../types';
@@ -6,10 +7,11 @@ export declare class CollectionResource {
     private itemResourceFactory;
     entry: CollectionEntry;
     options: any;
+    localCache: LocalCache;
     items: ItemResource[];
     itemIdMap: ItemResourceItemIdMap;
     columns: any;
-    constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: any);
+    constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: any, localCache: LocalCache);
     getItemById(itemId: number): ItemResource;
     rebuildMap(): void;
     addItemResources(itemEntries: ItemEntry[]): ItemResource[];

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

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

package/dist/dist/models/Template.d.ts

@@ -0,0 +1,11 @@
+import { ColumnSet } from '../classes';
+import { TemplateFactory } from '../factories';
+import { ApiResponse, FieldMap, ItemType, ResponseColumnMap } from '../types';
+export declare class Template {
+    itemType: ItemType;
+    response: ApiResponse;
+    fields: FieldMap;
+    responseColumns: ResponseColumnMap;
+    columns: ColumnSet;
+    constructor(factory: TemplateFactory, itemType: ItemType, response: ApiResponse, additionalColumns: ResponseColumnMap);
+}

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

@@ -6,3 +6,4 @@ export * from './ItemEntry';
 export * from './ItemResource';
 export * from './ViewResource';
 export * from './EditResource';
+export * from './Template';

package/dist/dist/types/ItemTypesCollection.d.ts

@@ -94,12 +94,6 @@ export declare type ColumnExpansionResult = {
     difference: ColumnSet;
 };
 export declare type ApiResponse = ApiResponseProcessor;
-export interface ApiTemplate {
-    fields: any;
-    columns: any;
-    response: ApiResponse;
-    responseColumns: ResponseColumnMap;
-}
 export declare type TemplateResponseItemEntryMap = {
     main: ItemEntry;
     linked: TemplateResponseLinkedItemEntryMap[];
@@ -108,9 +102,6 @@ export declare type TemplateResponseLinkedItemEntryMap = {
     itemType: string;
     itemEntries: ItemEntry[];
 };
-export declare type ApiTemplateItemTypeMap = {
-    [itemType: string]: ApiTemplate;
-};
 export declare type ItemTypeMap = {
     [itemType: string]: any;
 };