@rentman/rm-core 12.1.2 → 12.1.4

package/dist/types/src/models/CollectionOptions.d.ts

@@ -1,44 +1,44 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemEntry, ItemResource, ItemTypeColumnIds } from '../internal';
-export declare type CollectionResourceOnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemEntries: ItemEntry<ItemTypeType>[], collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isCalledAfterSocketUpdate: boolean) => void;
-export declare type CollectionResourceOnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
-export declare type ChildCollectionOptions = {
-    [ChildItemType in ApiEnumItemType]?: CollectionOptions<ChildItemType>;
-};
-export interface CollectionOptionsInterface<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> {
-    columns?: ApiRequestColumns;
-    query?: ApiQuery | null;
-    queryColumns?: ApiRequestColumns;
-    parent?: EntryParentNull;
-    limit?: ApiRequestLimit | null;
-    onAdd?: CollectionResourceOnAddCallback<ItemTypeType, ColumnIds>;
-    onRemove?: CollectionResourceOnRemoveCallback<ItemTypeType, ColumnIds>;
-    onChange?: FieldChangeCallback;
-    custom?: any;
-    callOnAddWithInitialItems?: boolean;
-    children?: {
-        [ChildItemType in ApiEnumItemType]?: CollectionOptionsInterface<ChildItemType>;
-    } | null;
-    preventCaching?: boolean;
-    usePrivateBuffer?: boolean;
-}
-export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> implements Required<CollectionOptionsInterface> {
-    columns: ApiRequestColumns;
-    query: ApiQuery | null;
-    queryColumns: ApiRequestColumns;
-    parent: EntryParentNull;
-    limit: ApiRequestLimit | null;
-    onAdd: CollectionResourceOnAddCallback<ItemTypeType, ColumnIds>;
-    onRemove: CollectionResourceOnRemoveCallback<ItemTypeType, ColumnIds>;
-    onChange: FieldChangeCallback;
-    custom: any;
-    callOnAddWithInitialItems: boolean;
-    children: ChildCollectionOptions | null;
-    /**
-     * @description
-     * Prevents a CachedQueryItem from being cached (the CollectionResource will still be cached), you can use this when you fetch an Itemtype for which the backend doesn't send socket messages (so it never automatically updates)
-     */
-    preventCaching: boolean;
-    usePrivateBuffer: boolean;
-    constructor(optionsInterface: CollectionOptionsInterface<ItemTypeType, ColumnIds>);
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemEntry, ItemResource, ItemTypeColumnIds } from '../internal';
+export declare type CollectionResourceOnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemEntries: ItemEntry<ItemTypeType>[], collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+export declare type ChildCollectionOptions = {
+    [ChildItemType in ApiEnumItemType]?: CollectionOptions<ChildItemType>;
+};
+export interface CollectionOptionsInterface<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> {
+    columns?: ApiRequestColumns;
+    query?: ApiQuery | null;
+    queryColumns?: ApiRequestColumns;
+    parent?: EntryParentNull;
+    limit?: ApiRequestLimit | null;
+    onAdd?: CollectionResourceOnAddCallback<ItemTypeType, ColumnIds>;
+    onRemove?: CollectionResourceOnRemoveCallback<ItemTypeType, ColumnIds>;
+    onChange?: FieldChangeCallback;
+    custom?: any;
+    callOnAddWithInitialItems?: boolean;
+    children?: {
+        [ChildItemType in ApiEnumItemType]?: CollectionOptionsInterface<ChildItemType>;
+    } | null;
+    preventCaching?: boolean;
+    usePrivateBuffer?: boolean;
+}
+export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> implements Required<CollectionOptionsInterface> {
+    columns: ApiRequestColumns;
+    query: ApiQuery | null;
+    queryColumns: ApiRequestColumns;
+    parent: EntryParentNull;
+    limit: ApiRequestLimit | null;
+    onAdd: CollectionResourceOnAddCallback<ItemTypeType, ColumnIds>;
+    onRemove: CollectionResourceOnRemoveCallback<ItemTypeType, ColumnIds>;
+    onChange: FieldChangeCallback;
+    custom: any;
+    callOnAddWithInitialItems: boolean;
+    children: ChildCollectionOptions | null;
+    /**
+     * @description
+     * Prevents a CachedQueryItem from being cached (the CollectionResource will still be cached), you can use this when you fetch an Itemtype for which the backend doesn't send socket messages (so it never automatically updates)
+     */
+    preventCaching: boolean;
+    usePrivateBuffer: boolean;
+    constructor(optionsInterface: CollectionOptionsInterface<ItemTypeType, ColumnIds>);
+}

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

@@ -1,87 +1,87 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiRequestLimit, ChangesDeltaResult, ChildCollectionResourcesNull, CollectionEntry, CollectionOptions, CollectionResourceFactory, CompareFieldCallback, DeregFunction, FieldMap, ItemEntry, ItemResource, ItemTypeColumnIds, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache } from '../internal';
-export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> {
-    protected factory: CollectionResourceFactory;
-    options: CollectionOptions<ItemTypeType, ColumnIds>;
-    transaction: TransactionCache;
-    entry: CollectionEntry<ItemTypeType, ColumnIds>;
-    columns: ResponseColumnItemTypeMap;
-    items: ItemResource<ItemTypeType, ColumnIds, Children>[];
-    protected itemIdMap: {
-        [itemId: number]: ItemResource<ItemTypeType, ColumnIds, Children>;
-    };
-    private fieldChangeDeregFns;
-    private readonly onChangeCallbacks;
-    private readonly onAddCallbacks;
-    private readonly onRemoveCallbacks;
-    /**
-     * @description
-     * We store the ItemIds of the items that were taking out the collections so that we can include those when doing a not-in when having a limit
-     */
-    private removedItemIds;
-    constructor(factory: CollectionResourceFactory, options: CollectionOptions<ItemTypeType, ColumnIds>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap: Children);
-    onConstruct(): void;
-    /**
-     * @description
-     * Removes the query (if it's cached) from the TransactionCachedQueryHandler and redoes the query
-     */
-    refresh(): PromiseInterface<void>;
-    setLimit(newLimit: number | ApiRequestLimit): void;
-    onAdd(callback: OnAddCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
-    onChange(callback: OnChangeCallback<ItemTypeType, ColumnIds>): DeregFunction;
-    onRemove(callback: OnRemoveCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
-    __clear(): void;
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
-     */
-    moveItems(itemEntries: ItemEntry<ItemTypeType>[], destinationResource: CollectionResource<ItemTypeType>): void;
-    removeItems(idArray: ItemId[]): PromiseInterface<ChangesDeltaResult>;
-    removeItem(itemId: ItemId): PromiseInterface<ChangesDeltaResult>;
-    addItems(valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<ChangesDeltaResult>;
-    addItem(values: Partial<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
-    getIdArray(): ItemId[];
-    getItemById(itemId: ItemId): ItemResource<ItemTypeType, ColumnIds, Children>;
-    /**
-     * Creates item resources and adds them to the `items` array.
-     * @param itemEntriesToBeAdded
-     */
-    addItemEntries(itemEntriesToBeAdded: ItemEntry<ItemTypeType>[], isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds, Children>[]>;
-    /**
-     * @description
-     * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.
-     * Filters on {@link ItemResource ItemResource}.{@link ItemEntry entry} === {@link ItemEntry entry}
-     */
-    removeItemResources(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): ItemEntry<ItemTypeType>[];
-    callOnAdd(itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
-    callOnChange(itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback<FieldMap<ItemTypeType, ColumnIds>>, fields: FieldMap<ItemTypeType, ColumnIds>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType, ColumnIds>): void;
-    callOnRemove(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): void;
-    forEach(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => void): void;
-    filter(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children>[];
-    first(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children> | null;
-    some(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): boolean;
-    groupBy(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => string | null)): {
-        [key: string]: ItemResource<ItemTypeType, ColumnIds, Children>[];
-    };
-    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => U)): U[];
-    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>, value: U) => U, value: U): U;
-    /**
-     * @description
-     * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}
-     *
-     * @remarks
-     * - Doesn't revert changes on the items themselves
-     */
-    clearResource(): void;
-    /**
-     * Creates item resources and adds them to the `items` array. This function is also called when the collection
-     * resource is constructed. When adding item resources to the collection externally, {@link addItemEntries} should
-     * be called.
-     * @param itemEntriesToBeAdded - These item entries are assumed not to be in the collection yet.
-     */
-    private addItemResources;
-    private registerListeners;
-    private __registerCallback;
-    private limitAfterRemove;
-    private limitAfterAdd;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestLimit, ChangesDeltaResult, ChildCollectionResourcesNull, CollectionEntry, CollectionOptions, CollectionResourceFactory, CompareFieldCallback, DeregFunction, FieldMap, ItemEntry, ItemResource, ItemTypeColumnIds, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache } from '../internal';
+export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> {
+    protected factory: CollectionResourceFactory;
+    options: CollectionOptions<ItemTypeType, ColumnIds>;
+    transaction: TransactionCache;
+    entry: CollectionEntry<ItemTypeType, ColumnIds>;
+    columns: ResponseColumnItemTypeMap;
+    items: ItemResource<ItemTypeType, ColumnIds, Children>[];
+    protected itemIdMap: {
+        [itemId: number]: ItemResource<ItemTypeType, ColumnIds, Children>;
+    };
+    private fieldChangeDeregFns;
+    private readonly onChangeCallbacks;
+    private readonly onAddCallbacks;
+    private readonly onRemoveCallbacks;
+    /**
+     * @description
+     * We store the ItemIds of the items that were taking out the collections so that we can include those when doing a not-in when having a limit
+     */
+    private removedItemIds;
+    constructor(factory: CollectionResourceFactory, options: CollectionOptions<ItemTypeType, ColumnIds>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap: Children);
+    onConstruct(): void;
+    /**
+     * @description
+     * Removes the query (if it's cached) from the TransactionCachedQueryHandler and redoes the query
+     */
+    refresh(): PromiseInterface<void>;
+    setLimit(newLimit: number | ApiRequestLimit): void;
+    onAdd(callback: OnAddCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
+    onChange(callback: OnChangeCallback<ItemTypeType, ColumnIds>): DeregFunction;
+    onRemove(callback: OnRemoveCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
+    __clear(): void;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
+     */
+    moveItems(itemEntries: ItemEntry<ItemTypeType>[], destinationResource: CollectionResource<ItemTypeType>): void;
+    removeItems(idArray: ItemId[]): PromiseInterface<ChangesDeltaResult>;
+    removeItem(itemId: ItemId): PromiseInterface<ChangesDeltaResult>;
+    addItems(valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<ChangesDeltaResult>;
+    addItem(values: Partial<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
+    getIdArray(): ItemId[];
+    getItemById(itemId: ItemId): ItemResource<ItemTypeType, ColumnIds, Children>;
+    /**
+     * Creates item resources and adds them to the `items` array.
+     * @param itemEntriesToBeAdded
+     */
+    addItemEntries(itemEntriesToBeAdded: ItemEntry<ItemTypeType>[], isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds, Children>[]>;
+    /**
+     * @description
+     * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.
+     * Filters on {@link ItemResource ItemResource}.{@link ItemEntry entry} === {@link ItemEntry entry}
+     */
+    removeItemResources(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): ItemEntry<ItemTypeType>[];
+    callOnAdd(itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
+    callOnChange(itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback<FieldMap<ItemTypeType, ColumnIds>>, fields: FieldMap<ItemTypeType, ColumnIds>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType, ColumnIds>): void;
+    callOnRemove(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): void;
+    forEach(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => void): void;
+    filter(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children>[];
+    first(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children> | null;
+    some(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): boolean;
+    groupBy(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => string | null)): {
+        [key: string]: ItemResource<ItemTypeType, ColumnIds, Children>[];
+    };
+    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => U)): U[];
+    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>, value: U) => U, value: U): U;
+    /**
+     * @description
+     * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}
+     *
+     * @remarks
+     * - Doesn't revert changes on the items themselves
+     */
+    clearResource(): void;
+    /**
+     * Creates item resources and adds them to the `items` array. This function is also called when the collection
+     * resource is constructed. When adding item resources to the collection externally, {@link addItemEntries} should
+     * be called.
+     * @param itemEntriesToBeAdded - These item entries are assumed not to be in the collection yet.
+     */
+    private addItemResources;
+    private registerListeners;
+    private __registerCallback;
+    private limitAfterRemove;
+    private limitAfterAdd;
+}

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

@@ -1,19 +1,19 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ColumnSet, ItemEntryFactory } from '../internal';
-export declare class ItemEntry<ItemTypeType extends ApiEnumItemType = any> {
-    private factory;
-    itemType: ItemTypeType;
-    itemId: ItemId;
-    columns: ColumnSet<ItemTypeType>;
-    private static currentId;
-    id: number;
-    reloadQueued: boolean;
-    constructor(factory: ItemEntryFactory, itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
-    queueReload(): this;
-    isLocal(): boolean;
-    isLockable(): boolean;
-    toJSON(): {
-        id: number;
-        columns: ColumnSet<ItemTypeType>;
-    };
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ColumnSet, ItemEntryFactory } from '../internal';
+export declare class ItemEntry<ItemTypeType extends ApiEnumItemType = any> {
+    private factory;
+    itemType: ItemTypeType;
+    itemId: ItemId;
+    columns: ColumnSet<ItemTypeType>;
+    private static currentId;
+    id: number;
+    reloadQueued: boolean;
+    constructor(factory: ItemEntryFactory, itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
+    queueReload(): this;
+    isLocal(): boolean;
+    isLockable(): boolean;
+    toJSON(): {
+        id: number;
+        columns: ColumnSet<ItemTypeType>;
+    };
+}

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

@@ -1,8 +1,8 @@
-import { ApiRequestColumns, EntryParentNull } from '../internal';
-export declare type ItemEntryOptionsInterface = Partial<ItemEntryOptions>;
-export declare class ItemEntryOptions {
-    columns: ApiRequestColumns;
-    parent: EntryParentNull;
-    templateOptions: any;
-    constructor(values: ItemEntryOptionsInterface);
-}
+import { ApiRequestColumns, EntryParentNull } from '../internal';
+export declare type ItemEntryOptionsInterface = Partial<ItemEntryOptions>;
+export declare class ItemEntryOptions {
+    columns: ApiRequestColumns;
+    parent: EntryParentNull;
+    templateOptions: any;
+    constructor(values: ItemEntryOptionsInterface);
+}

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

@@ -1,95 +1,95 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { CollectionResource, EntryParentNull, ExtractApiItemType, FieldMap, ItemEntry, ItemResourceFactory, ItemTypeColumnIds, PromiseInterface, ResponseColumnMap, TransactionCache } from '../internal';
-export declare type ChildCollectionResources = {
-    [ChildItemType in ApiEnumItemType]?: CollectionResource<ChildItemType>;
-};
-export declare type ChildCollectionResourcesNull = ChildCollectionResources | null;
-export declare class ItemResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> {
-    protected readonly factory: ItemResourceFactory;
-    readonly entry: ItemEntry<ItemTypeType>;
-    protected readonly transaction: TransactionCache;
-    children: Children;
-    private readonly _isNew;
-    columns: ResponseColumnMap<ItemTypeType, ColumnIds>;
-    fields: FieldMap<ItemTypeType, ColumnIds>;
-    initial: Readonly<FieldMap<ItemTypeType, ColumnIds>>;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, transaction: TransactionCache, children: Children, _isNew: boolean);
-    onConstruct(): void;
-    /**
-     * Collects all the fields from this item, useful while debugging when you want to look at the complete fieldset
-     * (because this.fields is now a proxy class)
-     */
-    collectFields(): FieldMap<ItemTypeType, ColumnIds>;
-    /**
-     * @description
-     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
-     */
-    setFields(values: Partial<FieldMap<ItemTypeType, ColumnIds>>): PromiseInterface<this>;
-    copyFields(destination?: FieldMap<ItemTypeType, []>): FieldMap<ItemTypeType, ColumnIds>;
-    /**
-     * Fetches the ItemResource's parent with the current fields
-     *
-     * ----------------
-     *
-     * @remark
-     * Use this if you need to get the parent after an item has been deleted
-     */
-    getParent(fromInitial?: boolean): EntryParentNull;
-    /**
-     * @deprecated
-     * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
-     */
-    callOnChange(previous: FieldMap<ItemTypeType, ColumnIds>): void;
-    /**
-     * @description
-     * Utility function to easily check if a field is changed.
-     * Will return `false` if the field is changed
-     *
-     * @example
-     * onChange: (
-     *     itemResource,
-     *     previous,
-     *     compareItemField
-     * ) {
-     *     if (!compareItemField('columnId')) {
-     *         processItem(itemResource);
-     *     }
-     * }
-     */
-    compareItemField(columnId: ColumnIds[number], previous: FieldMap<ItemTypeType, ColumnIds>): boolean;
-    hasChanges(): boolean;
-    setTransactionParameters(parameters: any): void;
-    /**
-     * @description
-     * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
-     */
-    isNew(): boolean;
-    isLocal(): boolean;
-    toJSON(): {
-        columns: string[];
-        fields: FieldMap<ItemTypeType, ColumnIds>;
-        entry: ItemEntry<ItemTypeType>;
-    };
-    /**
-     * @description
-     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
-     *
-     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
-     */
-    getDerivedValue<T1 extends string>(columnPath: T1): any | undefined;
-    getDerivedValue<T1 extends ColumnIds[number]>(columnPath: [T1]): FieldMap<ItemTypeType>[T1] | undefined;
-    getDerivedValue<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>]>(columnPath: [T1, T2]): FieldMap<ExtractApiItemType<ApiFields[ItemTypeType][T1]>>[T2] | undefined;
-    getDerivedValue<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>], T3 extends keyof ApiFields[ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>]>(columnPath: [T1, T2, T3]): FieldMap<ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>>[T3] | undefined;
-    /**
-     * @description
-     * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
-     *
-     * ---------------------
-     *
-     * @remark
-     * Assumes the derived item's values are already cached
-     */
-    getDerivedValues<T1 extends ColumnIds[number]>(columnPath: [T1]): FieldMap<ExtractApiItemType<ApiFields[ItemTypeType][T1]>> | undefined;
-    getDerivedValues<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>]>(columnPath: [T1, T2]): FieldMap<ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>> | undefined;
-    getDerivedValues<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>], T3 extends keyof ApiFields[ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>]>(columnPath: [T1, T2, T3]): FieldMap<ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>]>> | undefined;
-}
+import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
+import { CollectionResource, EntryParentNull, ExtractApiItemType, FieldMap, ItemEntry, ItemResourceFactory, ItemTypeColumnIds, PromiseInterface, ResponseColumnMap, TransactionCache } from '../internal';
+export declare type ChildCollectionResources = {
+    [ChildItemType in ApiEnumItemType]?: CollectionResource<ChildItemType>;
+};
+export declare type ChildCollectionResourcesNull = ChildCollectionResources | null;
+export declare class ItemResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> {
+    protected readonly factory: ItemResourceFactory;
+    readonly entry: ItemEntry<ItemTypeType>;
+    protected readonly transaction: TransactionCache;
+    children: Children;
+    private readonly _isNew;
+    columns: ResponseColumnMap<ItemTypeType, ColumnIds>;
+    fields: FieldMap<ItemTypeType, ColumnIds>;
+    initial: Readonly<FieldMap<ItemTypeType, ColumnIds>>;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, transaction: TransactionCache, children: Children, _isNew: boolean);
+    onConstruct(): void;
+    /**
+     * Collects all the fields from this item, useful while debugging when you want to look at the complete fieldset
+     * (because this.fields is now a proxy class)
+     */
+    collectFields(): FieldMap<ItemTypeType, ColumnIds>;
+    /**
+     * @description
+     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
+     */
+    setFields(values: Partial<FieldMap<ItemTypeType, ColumnIds>>): PromiseInterface<this>;
+    copyFields(destination?: FieldMap<ItemTypeType, []>): FieldMap<ItemTypeType, ColumnIds>;
+    /**
+     * Fetches the ItemResource's parent with the current fields
+     *
+     * ----------------
+     *
+     * @remark
+     * Use this if you need to get the parent after an item has been deleted
+     */
+    getParent(fromInitial?: boolean): EntryParentNull;
+    /**
+     * @deprecated
+     * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
+     */
+    callOnChange(previous: FieldMap<ItemTypeType, ColumnIds>): void;
+    /**
+     * @description
+     * Utility function to easily check if a field is changed.
+     * Will return `false` if the field is changed
+     *
+     * @example
+     * onChange: (
+     *     itemResource,
+     *     previous,
+     *     compareItemField
+     * ) {
+     *     if (!compareItemField('columnId')) {
+     *         processItem(itemResource);
+     *     }
+     * }
+     */
+    compareItemField(columnId: ColumnIds[number], previous: FieldMap<ItemTypeType, ColumnIds>): boolean;
+    hasChanges(): boolean;
+    setTransactionParameters(parameters: any): void;
+    /**
+     * @description
+     * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
+     */
+    isNew(): boolean;
+    isLocal(): boolean;
+    toJSON(): {
+        columns: string[];
+        fields: FieldMap<ItemTypeType, ColumnIds>;
+        entry: ItemEntry<ItemTypeType>;
+    };
+    /**
+     * @description
+     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
+     *
+     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
+     */
+    getDerivedValue<T1 extends string>(columnPath: T1): any | undefined;
+    getDerivedValue<T1 extends ColumnIds[number]>(columnPath: [T1]): FieldMap<ItemTypeType>[T1] | undefined;
+    getDerivedValue<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>]>(columnPath: [T1, T2]): FieldMap<ExtractApiItemType<ApiFields[ItemTypeType][T1]>>[T2] | undefined;
+    getDerivedValue<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>], T3 extends keyof ApiFields[ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>]>(columnPath: [T1, T2, T3]): FieldMap<ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>>[T3] | undefined;
+    /**
+     * @description
+     * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
+     *
+     * ---------------------
+     *
+     * @remark
+     * Assumes the derived item's values are already cached
+     */
+    getDerivedValues<T1 extends ColumnIds[number]>(columnPath: [T1]): FieldMap<ExtractApiItemType<ApiFields[ItemTypeType][T1]>> | undefined;
+    getDerivedValues<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>]>(columnPath: [T1, T2]): FieldMap<ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>> | undefined;
+    getDerivedValues<T1 extends ColumnIds[number], T2 extends keyof ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>], T3 extends keyof ApiFields[ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>]>(columnPath: [T1, T2, T3]): FieldMap<ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ExtractApiItemType<ApiFields[ItemTypeType][T1]>][T2]>]>> | undefined;
+}

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

@@ -1,11 +1,11 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { ApiRequestColumnMap, ApiResponse, ColumnSet, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, TemplateFactory } from '../internal';
-export declare class Template<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = any> {
-    itemType: ItemTypeType;
-    response: ApiResponse;
-    additionalRequestColumns: ApiRequestColumnMap;
-    responseColumns: ResponseColumnItemTypeMap;
-    columns: ColumnSet<ItemTypeType>;
-    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ItemTypeMap<ResponseColumnItemTypeMap>);
-    getFields(): FieldMap<ItemTypeType, ColumnIds>;
-}
+import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiResponse, ColumnSet, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, TemplateFactory } from '../internal';
+export declare class Template<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = any> {
+    itemType: ItemTypeType;
+    response: ApiResponse;
+    additionalRequestColumns: ApiRequestColumnMap;
+    responseColumns: ResponseColumnItemTypeMap;
+    columns: ColumnSet<ItemTypeType>;
+    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ItemTypeMap<ResponseColumnItemTypeMap>);
+    getFields(): FieldMap<ItemTypeType, ColumnIds>;
+}