@rentman/rm-core 1.7.2 → 1.7.3

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

@@ -3,67 +3,67 @@ import { CollectionEntryFactory } from '../factories';
 import { Deferred } from '../interfaces';
 import { CollectionEntryOptions, CollectionResource, ItemEntry } from '../models';
 import { ApiRequestColumns, CollectionQuery, ConversionMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, QueryCallback } from '../types';
-export declare class CollectionEntry {
+export declare class CollectionEntry<ItemTypeType extends ItemType = any> {
     private factory;
-    itemType: ItemType;
+    itemType: ItemTypeType;
     options: CollectionEntryOptions;
     id: number;
     parent: EntryParentNull;
     query: CollectionQuery;
-    columns: ColumnSet;
+    columns: ColumnSet<ItemTypeType>;
     private templateColumns;
-    initial: ItemEntry[];
-    items: ItemEntry[];
+    initial: Array<ItemEntry<ItemTypeType>>;
+    items: Array<ItemEntry<ItemTypeType>>;
     deferred?: Deferred<this>;
     promise: PromiseInterface<this>;
     reloadQueued: boolean;
     hasEditResources: boolean;
     hasItemEditResources: boolean;
-    constructor(factory: CollectionEntryFactory, itemType: ItemType, options: CollectionEntryOptions);
+    constructor(factory: CollectionEntryFactory, itemType: ItemTypeType, options: CollectionEntryOptions);
     private getResources;
     defer(): this;
     isDeferred(): boolean;
     _resolve(): this;
     resolve(itemEntryCompound: {
-        columns: ColumnSet;
-        initial: ItemEntry[];
-        modified?: ItemEntry[];
+        columns: ColumnSet<ItemTypeType>;
+        initial: Array<ItemEntry<ItemTypeType>>;
+        modified?: Array<ItemEntry<ItemTypeType>>;
     }): this;
     isLocal(): boolean;
     matchParent(itemType: ItemType, itemId: ItemId): boolean;
-    forEach(callback: (itemEntry: ItemEntry) => void): void;
-    getItemById(itemId: ItemId): ItemEntry | undefined;
+    forEach(callback: (itemEntry: this['items'][0]) => void): void;
+    getItemById(itemId: ItemId): this['items'][0] | undefined;
     getIdArray(accumulator?: ItemId[]): ItemId[];
-    createItems(valuesArray: FieldMap[]): PromiseInterface<ItemEntry[]>;
-    resolveDerivedValues(itemEntries: ItemEntry[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    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;
+    createItems(valuesArray: FieldMap[]): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    resolveDerivedValues(itemEntries: Array<ItemEntry<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource: U, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'];
+    addItems(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): null;
+    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, 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<U extends CollectionResource<ItemTypeType>>(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'];
+    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
+    clear<U extends CollectionResource<ItemTypeType>>(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;
+    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
+    handleRemovedItems(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
+    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => 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): CollectionQuery;
-    extend<U extends CollectionResource>(queryCallback: QueryCallback, collectionResource?: U, callOnAdd?: boolean): PromiseInterface<U['items']>;
+    extend<U extends CollectionResource<ItemTypeType>>(queryCallback: QueryCallback, collectionResource?: U, callOnAdd?: boolean): PromiseInterface<U['items']>;
     extend(queryCallback: QueryCallback, collectionResource?: null, callOnAdd?: boolean): PromiseInterface<null>;
     queueReload(): void;
-    expandColumns(columnExpansion: ColumnExpansion): void;
+    expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
     expandRequestColumns(requestColumns: ApiRequestColumns): void;
     getAddedItems(returnItemIds: true): ItemId[];
-    getAddedItems(returnItemIds?: boolean): ItemEntry[];
+    getAddedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
     getRemovedItems(returnItemIds: true): ItemId[];
-    getRemovedItems(returnItemIds?: boolean): ItemEntry[];
-    getUpdatedItems(): ItemEntry[];
+    getRemovedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
+    getUpdatedItems(): Array<ItemEntry<ItemTypeType>>;
     hasAddedItems(): boolean;
     hasRemovedItems(): boolean;
     hasUpdatedItems(): boolean;
@@ -76,7 +76,7 @@ export declare class CollectionEntry {
     private onAddInitial;
     private onRemoveInitial;
     getUpdatedItemColumns(conversionMap: ItemIdConversionMap): {
-        [columnId: string]: ColumnInfo;
+        [columnId: string]: ColumnInfo<ItemTypeType>;
     };
-    clone(parent: EntryParentNull, conversionMap?: ItemIdConversionMap): CollectionEntry;
+    clone(parent: EntryParentNull, conversionMap?: ItemIdConversionMap): CollectionEntry<ItemTypeType>;
 }

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

@@ -1,21 +1,21 @@
 import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
-import { ItemResourceItemIdMap, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
-export declare abstract class CollectionResource<T extends ItemResource = LocalViewResource> {
+import { ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
+export declare abstract class CollectionResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> {
     protected factory: CollectionResourceFactory;
-    entry: CollectionEntry;
-    options: CollectionResourceOptions;
+    entry: CollectionEntry<ItemTypeType>;
+    options: CollectionResourceOptions<ItemTypeType>;
     level: number;
     localCache: LocalCache | null;
     items: T[];
     columns: ResponseColumnMap;
     protected itemIdMap: ItemResourceItemIdMap<T>;
     private readonly onChange;
-    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, level: number, localCache: LocalCache | null);
+    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
     getItemById(itemId: number): T;
     rebuildMap(): void;
-    addItemResources(itemEntries: ItemEntry[]): T[];
+    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
     /**
      * @param itemEntries
      * @returns {ItemResource[]}
@@ -23,7 +23,7 @@ export declare abstract class CollectionResource<T extends ItemResource = LocalV
      * Returns the Itemresources that where removed Collection.
      * Filters on ItemResource.entry === ItemEntry
      */
-    removeItemResources(itemEntries: ItemEntry[]): T[];
+    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
     callOnAdd(itemResources: T[]): void;
     callOnRemove(itemResources: T[]): void;
     forEach(callback: (itemResource: T) => void): void;

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

@@ -1,10 +1,10 @@
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { ConversionMap, OnChangeFunction } from '../types';
-export declare type CollectionResourceCallback = (itemResources: ItemResource[], collectionResource: CollectionResource) => void;
-export declare type CollectionResourceInitialCallback = (itemEntries: ItemEntry[], collectionEntry: CollectionEntry) => void;
+import { ConversionMap, ItemType, OnChangeFunction } from '../types';
+export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
+export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
 export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
-export declare type CollectionResourceOptionsInterface = Partial<CollectionResourceOptions>;
-export declare class CollectionResourceOptions {
+export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
+export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
     editItems: boolean;
     remoteItems: boolean;
     editCollection: boolean;
@@ -12,11 +12,11 @@ export declare class CollectionResourceOptions {
     enableSave: boolean;
     onItemsCreated: OnItemsCreatedCallback;
     onChange: OnChangeFunction;
-    onAdd: CollectionResourceCallback;
-    onRemove: CollectionResourceCallback;
-    onAddInitial: CollectionResourceInitialCallback;
-    onRemoveInitial: CollectionResourceInitialCallback;
+    onAdd: CollectionResourceCallback<ItemTypeType>;
+    onRemove: CollectionResourceCallback<ItemTypeType>;
+    onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
+    onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
     resourceKey: string | null;
     custom: any;
-    constructor(values: CollectionResourceOptionsInterface);
+    constructor(values: CollectionResourceOptionsInterface<ItemTypeType>);
 }

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

@@ -1,6 +1,7 @@
 import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-export declare class CollectionViewResource<T extends ItemResource = LocalViewResource> extends CollectionResource<T> {
-    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, level: number, localCache: LocalCache | null);
+import { ItemType } from '../types';
+export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
+    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
 }

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

@@ -1,11 +1,11 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, PromiseInterface } from '../types';
-export declare class EditResource extends ItemResource {
+import { FieldMap, ItemType, PromiseInterface } from '../types';
+export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
     protected localCopies: FieldMap[];
     protected transactions: number;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
     isNew(): boolean;
     start(): this;
     rollback(): this;

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

@@ -2,11 +2,11 @@ import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
 import { Deferred } from '../interfaces';
 import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
-export declare class ItemEntry {
+export declare class ItemEntry<ItemTypeType extends ItemType = any> {
     private factory;
-    itemType: string;
+    itemType: ItemTypeType;
     itemId: ItemId;
-    columns: ColumnSet;
+    columns: ColumnSet<ItemTypeType>;
     id: number;
     reloadQueued: boolean;
     deferRequest: boolean;
@@ -15,22 +15,22 @@ export declare class ItemEntry {
     initial: FieldMap;
     modified: FieldMap;
     derived: FieldMap;
-    constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
+    constructor(factory: ItemEntryFactory, itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
     private getResources;
     queueReload(): this;
     defer(deferRequest?: boolean): this;
     getPromise(): PromiseInterface<this>;
     resolve(): this;
-    resolveDeferred(initial: FieldMap, derived: FieldMap, columns: ColumnSet): this;
+    resolveDeferred(initial: FieldMap, derived: FieldMap, columns: ColumnSet<ItemTypeType>): 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;
+    setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet<ItemTypeType>): this;
+    clone(conversionMap?: ItemIdConversionMap): ItemEntry<ItemTypeType>;
     resetDerived(columnIds: string[]): this;
     getFields(): FieldMap;
-    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
-    expandLocal(columnExpansionResult: ColumnExpansionResult): this;
+    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult<ItemTypeType>): this;
+    expandLocal(columnExpansionResult: ColumnExpansionResult<ItemTypeType>): this;
     private setLocalValues;
     /**
      * This function assumes the initial, modified, derived properties are already set. It will update the values
@@ -38,7 +38,7 @@ export declare class ItemEntry {
      */
     updateFields(fields: FieldMap, derived?: FieldMap | null, overwrite?: boolean): this;
     private updateItemValues;
-    updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
+    updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet<ItemTypeType>): this;
     formatRequest(): FieldMap;
     setDisplayName(): this;
     getDisplayName(): string;
@@ -46,7 +46,7 @@ export declare class ItemEntry {
      * @param {Boolean} returnAll Returns all initial values if true
      * @returns {Object}
      */
-    getChanges(returnAll?: boolean): FieldMap;
+    getChanges(returnAll?: boolean): FieldMap<any>;
     isLocal(): boolean;
     isLockable(): boolean;
     hasChanges(): boolean;
@@ -62,9 +62,9 @@ export declare class ItemEntry {
     toJSON(): {
         id: number;
         parent: EntryParentNull;
-        initial: FieldMap;
-        modified: FieldMap;
-        derived: FieldMap;
-        columns: ColumnSet;
+        initial: FieldMap<any>;
+        modified: FieldMap<any>;
+        derived: FieldMap<any>;
+        columns: ColumnSet<ItemTypeType>;
     };
 }

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

@@ -1,11 +1,11 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions } from '../models';
-import { FieldMap, ResponseColumn } from '../types';
-export declare abstract class ItemResource {
+import { FieldMap, ItemType, ResponseColumn } from '../types';
+export declare abstract class ItemResource<ItemTypeType extends ItemType = any> {
     protected readonly factory: ItemResourceFactory;
-    readonly entry: ItemEntry;
-    readonly options: ItemResourceOptions;
+    readonly entry: ItemEntry<ItemTypeType>;
+    readonly options: ItemResourceOptions<ItemResource<ItemTypeType>>;
     protected readonly _isNew: boolean;
     protected readonly localCache: LocalCache | null;
     columns: {
@@ -13,15 +13,15 @@ export declare abstract class ItemResource {
     };
     fields: FieldMap;
     derived: FieldMap;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, _isNew: boolean, localCache: LocalCache | null);
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, localCache: LocalCache | null);
     isNew(): boolean;
     isLocal(): boolean;
     clearResource(): void;
     deactivate(): void;
     toJSON(): {
         columns: string[];
-        fields: FieldMap;
-        derived: FieldMap;
-        entry: ItemEntry;
+        fields: FieldMap<any>;
+        derived: FieldMap<any>;
+        entry: ItemEntry<ItemTypeType>;
     };
 }

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

@@ -1,8 +1,9 @@
 import { OnChangeFunction } from '../types';
-export declare type ItemResourceOptionsInterface = Partial<ItemResourceOptions>;
-export declare class ItemResourceOptions {
+import { ItemResource } from './ItemResource';
+export declare type ItemResourceOptionsInterface<ItemResourceType extends ItemResource<any> = ItemResource<any>> = Partial<ItemResourceOptions<ItemResourceType>>;
+export declare class ItemResourceOptions<ItemResourceType extends ItemResource<any> = ItemResource<any>> {
     edit: boolean;
     remote: boolean;
-    onChange: OnChangeFunction;
-    constructor(values: ItemResourceOptionsInterface);
+    onChange: OnChangeFunction<ItemResourceType>;
+    constructor(values: ItemResourceOptionsInterface<ItemResourceType>);
 }

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

@@ -1,6 +1,7 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
-export declare class LocalViewResource extends ViewResource {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+import { ItemType } from '../types';
+export declare class LocalViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
 }

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

@@ -1,6 +1,7 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
-export declare class RemoteViewResource extends ViewResource {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+import { ItemType } from '../types';
+export declare class RemoteViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<RemoteViewResource<ItemTypeType>>, isNew: boolean, localCache: LocalCache | null);
 }

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

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

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

@@ -1,8 +1,8 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap } from '../types';
-export declare abstract class ViewResource extends ItemResource {
+import { FieldMap, ItemType } from '../types';
+export declare abstract class ViewResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
     fields: Readonly<FieldMap>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ViewResource<ItemTypeType>>, isNew: boolean, localCache: LocalCache | null);
 }

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

@@ -6,22 +6,22 @@ export declare type EntryParent = {
     itemId: number;
 };
 export declare type EntryParentNull = EntryParent | null;
-export declare type FieldMap = {
+export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
     [key: string]: any;
 };
 export declare type ItemOptionsInterface = ItemEntryOptionsInterface & ItemResourceOptionsInterface;
-export declare type CollectionOptionsInterface = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface;
-export interface CollectionDefinition {
-    itemType: ItemType;
+export declare type CollectionOptionsInterface<ItemTypeType extends ItemType = any> = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface<ItemTypeType>;
+export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
+    itemType: ItemTypeType;
     options: {
         entry: CollectionEntryOptions;
-        resource: CollectionResourceOptions;
+        resource: CollectionResourceOptions<ItemTypeType>;
     };
 }
-export interface LinkCollectionDefinition extends CollectionDefinition {
+export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> extends CollectionDefinition<ItemTypeType> {
     linkField: string;
 }
-export declare type OnChangeFunction = (itemResource: ItemResource, previous?: FieldMap) => void;
+export declare type OnChangeFunction<ItemResourceType extends ItemResource<any> = ItemResource<any>> = (itemResource: ItemResourceType, previous?: FieldMap) => void;
 export declare const enum StateKeyType {
     New = "new",
     Duplicate = "duplicate"
@@ -78,10 +78,10 @@ export interface FunctionChangesResolveSocketMessage extends SocketMessage {
         [key: string]: any;
     };
 }
-export declare type ItemResourceItemIdMap<T extends ItemResource = ItemResource> = {
+export declare type ItemResourceItemIdMap<T extends ItemResource<any> = ItemResource<any>> = {
     [itemId: number]: T;
 };
-export declare type ItemResourcesItemTypeMap<T extends ItemResource = ItemResource> = {
+export declare type ItemResourcesItemTypeMap<T extends ItemResource<any> = ItemResource<any>> = {
     [itemType: string]: T[];
 };
 export declare type ItemId = number;
@@ -91,17 +91,17 @@ export declare type ItemMap<T> = {
         [itemId: string]: T;
     };
 };
-export declare type ItemEntryMap = ItemMap<ItemEntry>;
-export declare type LinkedItemEntryMap = {
-    itemType: string;
-    itemEntries: ItemEntry[];
-    columnSet: ColumnSet;
+export declare type ItemEntryMap<ItemTypeType extends ItemType> = ItemMap<ItemEntry<ItemTypeType>>;
+export declare type LinkedItemEntryMap<ItemTypeType extends ItemType = any> = {
+    itemType: ItemTypeType;
+    itemEntries: Array<ItemEntry<ItemTypeType>>;
+    columnSet: ColumnSet<ItemTypeType>;
 };
 export declare type EntryStatusMap<T> = {
     [entryStatus: string]: T[];
 };
-export declare type ItemEntryParentIdMap = {
-    [parentId: number]: ItemEntry[];
+export declare type ItemEntryParentIdMap<ItemTypeType extends ItemType> = {
+    [parentId: number]: Array<ItemEntry<ItemTypeType>>;
 };
 export declare type ConversionMap = {
     [itemId: number]: number;
@@ -109,7 +109,7 @@ export declare type ConversionMap = {
 export declare type ItemIdConversionMap = {
     [itemType: string]: ConversionMap;
 };
-export declare type CreateRequestParameterMap = ItemMap<any>;
+export declare type CreateRequestParameterMap<T = any> = ItemMap<T>;
 export declare type ItemError = {
     message: string;
 };
@@ -119,22 +119,22 @@ export declare type CollectionQuery = {
     string: string;
 };
 export declare type QueryCallback = (queryParams: QueryParams) => QueryParams;
-export declare type CollectionEntryParentIdMap = {
-    [parentId: number]: CollectionEntry;
+export declare type CollectionEntryParentIdMap<ItemTypeType extends ItemType> = {
+    [parentId: number]: CollectionEntry<ItemTypeType>;
 };
-export declare type CollectionResourceParentIdMap<T extends CollectionResource<ItemResource> = CollectionResource<ItemResource>> = {
+export declare type CollectionResourceParentIdMap<T extends CollectionResource<any> = CollectionResource<any>> = {
     [parentId: number]: T;
 };
-export declare type CollectionMatchResult = {
-    fitting: CollectionEntry[];
-    notfitting: CollectionEntry[];
-    maybe: CollectionEntry[];
+export declare type CollectionMatchResult<ItemTypeType extends ItemType> = {
+    fitting: Array<CollectionEntry<ItemTypeType>>;
+    notfitting: Array<CollectionEntry<ItemTypeType>>;
+    maybe: Array<CollectionEntry<ItemTypeType>>;
 };
-export interface ExtendedCollectionMatchResult extends CollectionMatchResult {
-    collection: CollectionEntry;
+export interface ExtendedCollectionMatchResult<ItemTypeType extends ItemType> extends CollectionMatchResult<ItemTypeType> {
+    collection: CollectionEntry<ItemTypeType>;
 }
-export interface GroupedExtendedCollectionMatchResult {
-    [collectionId: number]: ExtendedCollectionMatchResult;
+export interface GroupedExtendedCollectionMatchResult<ItemTypeType extends ItemType> {
+    [collectionId: number]: ExtendedCollectionMatchResult<ItemTypeType>;
 }
 export declare type ResponseColumn = any;
 export declare type ResponseColumnMap = {
@@ -142,9 +142,9 @@ export declare type ResponseColumnMap = {
         [columnId: string]: ResponseColumn;
     };
 };
-export declare type ColumnExpansionResult = {
-    merged: ColumnSet;
-    difference: ColumnSet;
+export declare type ColumnExpansionResult<ItemTypeType extends ItemType> = {
+    merged: ColumnSet<ItemTypeType>;
+    difference: ColumnSet<ItemTypeType>;
 };
 export declare type RootColumnMap = {
     [columnId: string]: {
@@ -153,13 +153,13 @@ export declare type RootColumnMap = {
     };
 };
 export declare type ApiResponse = ApiResponseProcessor;
-export declare type TemplateItemResourceMap<T extends ItemResource> = {
+export declare type TemplateItemResourceMap<T extends ItemResource<any>> = {
     main: T;
     linked: ItemResourcesItemTypeMap;
 };
-export declare type TemplateItemEntryMap = {
-    main: ItemEntry;
-    linked: LinkedItemEntryMap[];
+export declare type TemplateItemEntryMap<ItemTypeType extends ItemType> = {
+    main: ItemEntry<ItemTypeType>;
+    linked: Array<LinkedItemEntryMap<ItemType>>;
 };
 export declare type ItemTypeMap = {
     [itemType: string]: any;
@@ -196,10 +196,10 @@ export declare type ApiRequestLimit = {
 export declare type ApiRequestMoveItems = {
     [itemType: string]: ItemId[];
 };
-export declare type CreateRequestEntry = {
+export declare type CreateRequestEntry<ItemTypeType extends ItemType> = {
     request: {
         requestType: 'create';
-        itemType?: ItemType;
+        itemType?: ItemTypeType;
         parentType?: ItemType;
         parentId?: {
             [itemId: string]: ItemId;
@@ -208,6 +208,6 @@ export declare type CreateRequestEntry = {
         columns: ApiRequestColumnMap;
     };
     columns: RequestColumnExpansion;
-    items: ItemEntryMap;
-    collections: CollectionMatcher;
+    items: ItemEntryMap<ItemTypeType>;
+    collections: CollectionMatcher<ItemTypeType>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/src/index.d.ts",