@rentman/rm-core 1.5.6 → 1.5.7

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

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

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

@@ -1,20 +1,12 @@
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull, OptionsInterface } from '../types';
-export declare abstract class CollectionEntryOptionsInterface implements OptionsInterface {
-    columns?: ApiRequestColumns;
-    query?: ApiQuery | null;
-    queryParams?: object;
-    parent?: EntryParentNull;
-    deferRequest?: boolean;
-    limit?: ApiRequestLimit | null;
-    entryKey?: string | null;
-}
-export declare class CollectionEntryOptions extends CollectionEntryOptionsInterface {
-    columns: any;
-    query: any;
-    queryParams: any;
-    parent: any;
-    deferRequest: any;
-    limit: any;
-    entryKey: any;
-    constructor(values: CollectionEntryOptionsInterface);
-}
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull } from '../types';
+export declare type CollectionEntryOptionsInterface = Partial<CollectionEntryOptions>;
+export declare class CollectionEntryOptions {
+    columns: ApiRequestColumns;
+    query: ApiQuery | null;
+    queryParams: any;
+    parent: EntryParentNull;
+    deferRequest: boolean;
+    limit: ApiRequestLimit | null;
+    entryKey: string | null;
+    constructor(values: CollectionEntryOptionsInterface);
+}

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

@@ -1,40 +1,40 @@
-import { LocalCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
-import { CollectionResourceOptions, ItemEntry, ItemResource } from '../models';
-import { ItemResourceItemIdMap, PromiseInterface } from '../types';
-import { CollectionEntry } from './CollectionEntry';
-export declare class CollectionResource {
-    private itemResourceFactory;
-    entry: CollectionEntry;
-    options: CollectionResourceOptions;
-    localCache: LocalCache;
-    items: ItemResource[];
-    itemIdMap: ItemResourceItemIdMap;
-    columns: any;
-    constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
-    getItemById(itemId: number): ItemResource;
-    rebuildMap(): void;
-    addItemResources(itemEntries: ItemEntry[]): ItemResource[];
-    /**
-     * @param itemEntries
-     * @returns {ItemResource[]}
-     *
-     * Returns the Itemresources that where removed Collection.
-     * Filters on ItemResource.entry === ItemEntry
-     */
-    removeItemResources(itemEntries: ItemEntry[]): ItemResource[];
-    callOnAdd(itemResources: ItemResource[]): void;
-    callOnRemove(itemResources: ItemResource[]): void;
-    forEach(callback: (itemResource: ItemResource) => void): void;
-    filter(callback: (itemResource: ItemResource) => boolean): ItemResource[];
-    first(callback: (itemResource: ItemResource) => boolean): ItemResource | null;
-    some(callback: (itemResource: ItemResource) => boolean): boolean;
-    groupBy(argument: string | ((itemResource: ItemResource) => string | null)): {
-        [key: string]: ItemResource[];
-    };
-    map<T>(argument: string | ((itemResource: ItemResource) => T)): T[];
-    reduce<T>(callback: (itemResource: ItemResource, value: T) => T, value: T): T;
-    extend(queryCallback: any, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<ItemResource[] | null>;
-    deactivate(): void;
-    clearResource(): void;
-}
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
+import { CollectionResourceOptions, EditResource, ItemEntry, ViewResource } from '../models';
+import { ItemResourceItemIdMap, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
+import { CollectionEntry } from './CollectionEntry';
+export declare class CollectionResource<T extends ViewResource | EditResource = ViewResource> {
+    private itemResourceFactory;
+    entry: CollectionEntry;
+    options: CollectionResourceOptions;
+    localCache: LocalCache;
+    items: T[];
+    itemIdMap: ItemResourceItemIdMap<T>;
+    columns: ResponseColumnMap;
+    constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+    getItemById(itemId: number): T;
+    rebuildMap(): void;
+    addItemResources(itemEntries: ItemEntry[]): T[];
+    /**
+     * @param itemEntries
+     * @returns {ItemResource[]}
+     *
+     * Returns the Itemresources that where removed Collection.
+     * Filters on ItemResource.entry === ItemEntry
+     */
+    removeItemResources(itemEntries: ItemEntry[]): T[];
+    callOnAdd(itemResources: this['items']): void;
+    callOnRemove(itemResources: this['items']): void;
+    forEach(callback: (itemResource: T) => void): void;
+    filter(callback: (itemResource: T) => boolean): T[];
+    first(callback: (itemResource: T) => boolean): T | null;
+    some(callback: (itemResource: T) => boolean): boolean;
+    groupBy(argument: string | ((itemResource: T) => string | null)): {
+        [key: string]: T[];
+    };
+    map<U>(argument: string | ((itemResource: T) => U)): U[];
+    reduce<U>(callback: (itemResource: T, value: U) => U, value: U): U;
+    extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<this['items']>;
+    deactivate(): void;
+    clearResource(): void;
+}

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

@@ -1,38 +1,23 @@
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { ItemIdConversionMap, OnChangeFunction, OptionsInterface } from '../types';
-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);
-}
+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;
+export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
+export declare type CollectionResourceOptionsInterface = Partial<CollectionResourceOptions>;
+export declare class CollectionResourceOptions {
+    editItems: boolean;
+    editCollection: boolean;
+    modInstant: boolean;
+    enableSave: boolean;
+    onItemsCreated: OnItemsCreatedCallback;
+    onChange: OnChangeFunction;
+    onAdd: CollectionResourceCallback;
+    onRemove: CollectionResourceCallback;
+    onAddInitial: CollectionResourceInitialCallback;
+    onRemoveInitial: CollectionResourceInitialCallback;
+    resourceKey: string | null;
+    clearOnTabChange: boolean;
+    clearOnSubTabChange: boolean;
+    custom: any;
+    constructor(values: CollectionResourceOptionsInterface);
+}

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

@@ -1,6 +1,6 @@
-import { LocalCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions } from '../models';
-export declare class CollectionViewResource extends CollectionResource {
-    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
-}
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, EditResource, ViewResource } from '../models';
+export declare class CollectionViewResource<T extends EditResource | ViewResource = ViewResource> extends CollectionResource<T> {
+    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+}

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

@@ -1,18 +1,18 @@
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, PromiseInterface } from '../types';
-export declare class EditResource extends ItemResource {
-    private factory;
-    localCopies: FieldMap[];
-    transactions: number;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
-    isNew(): boolean;
-    start(): this;
-    rollback(): this;
-    commit(callOnChange?: boolean): this;
-    getLocalCopy(): FieldMap | null;
-    copyFields(destination?: FieldMap): FieldMap;
-    setFields(values: FieldMap, callOnChange?: boolean): this;
-    callOnChange(previous: FieldMap): this;
-    save(parameters?: any): PromiseInterface<this>;
-}
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
+import { FieldMap, PromiseInterface } from '../types';
+export declare class EditResource extends ItemResource {
+    private factory;
+    localCopies: FieldMap[];
+    transactions: number;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
+    isNew(): boolean;
+    start(): this;
+    rollback(): this;
+    commit(callOnChange?: boolean): this;
+    getLocalCopy(): FieldMap | null;
+    copyFields(destination?: FieldMap): FieldMap;
+    setFields(values: FieldMap, callOnChange?: boolean): this;
+    callOnChange(previous?: FieldMap): this;
+    save(parameters?: any): PromiseInterface<this>;
+}

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

@@ -1,71 +1,73 @@
-import { ColumnSet } from '../classes';
-import { ItemEntryFactory } from '../factories';
-import { ItemResource } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType } from '../types';
-export declare class ItemEntry {
-    private factory;
-    itemType: string;
-    itemId: ItemId;
-    columns: ColumnSet;
-    id: number;
-    reloadQueued: boolean;
-    deferRequest: boolean;
-    deferred: any;
-    parent: EntryParentNull;
-    initial: FieldMap;
-    modified: FieldMap;
-    derived: FieldMap;
-    resources: ItemResource[];
-    constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
-    queueReload(): this;
-    defer(deferRequest?: boolean): this;
-    resolve(): this;
-    resolveDeferred(initial: any, derived: any, columns: any): this;
-    isDeferred(): boolean;
-    reject(error?: ItemError): this;
-    setFields(initial: FieldMap, derived: FieldMap): this;
-    setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
-    clone(conversionMap?: ItemIdConversionMap): ItemEntry;
-    resetDerived(columnIds: any): this;
-    clearResources(): this;
-    deactivateResources(): this;
-    getFields(): FieldMap;
-    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
-    expandLocal(columnExpansionResult: ColumnExpansionResult): this;
-    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;
-    updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
-    formatRequest(): FieldMap;
-    setDisplayName(): this;
-    getDisplayName(): string;
-    /**
-     * @param {Boolean} returnAll Returns all initial values if true
-     * @returns {Object}
-     */
-    getChanges(returnAll?: boolean): FieldMap;
-    isLocal(): boolean;
-    isLockable(): boolean;
-    hasChanges(): boolean;
-    resetModified(): this;
-    setInitial(values: FieldMap, enableCallbacks?: boolean): this;
-    /**
-     * Does a shallow copy of values!
-     */
-    setModified(values?: FieldMap): this;
-    setDerived(values: FieldMap): this;
-    setParent(parentType: ItemType, parentId: ItemId): this;
-    callOnChange(previous: FieldMap): this;
-    toJSON(): {
-        id: number;
-        parent: EntryParentNull;
-        initial: FieldMap;
-        modified: FieldMap;
-        derived: FieldMap;
-        columns: ColumnSet;
-    };
-}
+import { ColumnSet } from '../classes';
+import { ItemEntryFactory } from '../factories';
+import { ItemResource } from '../models';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+import { Deferred } from '../interfaces';
+export declare class ItemEntry {
+    private factory;
+    itemType: string;
+    itemId: ItemId;
+    columns: ColumnSet;
+    id: number;
+    reloadQueued: boolean;
+    deferRequest: boolean;
+    deferred?: Deferred<this>;
+    parent: EntryParentNull;
+    initial: FieldMap;
+    modified: FieldMap;
+    derived: FieldMap;
+    resources: ItemResource[];
+    constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
+    queueReload(): this;
+    defer(deferRequest?: boolean): this;
+    getPromise(): PromiseInterface<this>;
+    resolve(): this;
+    resolveDeferred(initial: FieldMap, derived: FieldMap, columns: ColumnSet): this;
+    isDeferred(): boolean;
+    reject(error?: ItemError): this;
+    setFields(initial: FieldMap, derived: FieldMap): this;
+    setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
+    clone(conversionMap?: ItemIdConversionMap): ItemEntry;
+    resetDerived(columnIds: string[]): this;
+    clearResources(): this;
+    deactivateResources(): this;
+    getFields(): FieldMap;
+    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
+    expandLocal(columnExpansionResult: ColumnExpansionResult): this;
+    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;
+    updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
+    formatRequest(): FieldMap;
+    setDisplayName(): this;
+    getDisplayName(): string;
+    /**
+     * @param {Boolean} returnAll Returns all initial values if true
+     * @returns {Object}
+     */
+    getChanges(returnAll?: boolean): FieldMap;
+    isLocal(): boolean;
+    isLockable(): boolean;
+    hasChanges(): boolean;
+    resetModified(): this;
+    setInitial(values: FieldMap, enableCallbacks?: boolean): this;
+    /**
+     * Does a shallow copy of values!
+     */
+    setModified(values?: FieldMap): this;
+    setDerived(values: FieldMap): this;
+    setParent(parentType: ItemType, parentId: ItemId): this;
+    callOnChange(previous?: FieldMap): this;
+    toJSON(): {
+        id: number;
+        parent: EntryParentNull;
+        initial: FieldMap;
+        modified: FieldMap;
+        derived: FieldMap;
+        columns: ColumnSet;
+    };
+}

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

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

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

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

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

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