@bryntum/taskboard-angular 7.1.1

package/esm2015/lib/bryntum-task-board-project-model.component.js

@@ -0,0 +1,690 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Angular wrapper for Bryntum ProjectModel
+ */
+import { Component, EventEmitter, Output, Input } from '@angular/core';
+import WrapperHelper from './wrapper.helper';
+import { ProjectModel } from '@bryntum/taskboard';
+import * as i0 from "@angular/core";
+export class BryntumTaskBoardProjectModelComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * Fires before an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onBeforeDestroy = new EventEmitter();
+        /**
+         * Fires before [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) is sent. Return `false` to cancel load request.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.
+         */
+        this.onBeforeLoad = new EventEmitter();
+        /**
+         * Fires before loaded data get applied to the stores. Return `false` to prevent data applying.
+         * This event can be used for server data preprocessing. To achieve it user can modify the `response` object.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.response The decoded server response object.
+         * @param {object} event.options Options provided to the [load](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) method.
+         */
+        this.onBeforeLoadApply = new EventEmitter();
+        /**
+         * Fires before server response gets applied to the stores. Return `false` to prevent data applying.
+         * This event can be used for server data preprocessing. To achieve it user can modify the `response` object.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {'sync','load'} event.requestType The request type (`sync` or `load`).
+         * @param {object} event.response The decoded server response object.
+         */
+        this.onBeforeResponseApply = new EventEmitter();
+        /**
+         * Fires before a request is sent to the server.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-beforeSend)
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.crudManager The CRUD manager.
+         * @param {object} event.params HTTP request params to be passed in the request URL.
+         * @param {'sync','load'} event.requestType CrudManager request type (`load`/`sync`)
+         * @param {object} event.requestConfig Configuration object for Ajax request call
+         */
+        this.onBeforeSend = new EventEmitter();
+        /**
+         * Fires before [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) is sent. Return `false` to cancel sync request.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-beforeSync)
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.
+         */
+        this.onBeforeSync = new EventEmitter();
+        /**
+         * Fires before sync response data get applied to the stores. Return `false` to prevent data applying.
+         * This event can be used for server data preprocessing. To achieve it user can modify the `response` object.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.response The decoded server response object.
+         */
+        this.onBeforeSyncApply = new EventEmitter();
+        /**
+         * Fires when any other event is fired from the object.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-catchAll)
+         * @param {object} event Event object
+         * @param {{[key: string]: any, type: string}} event.event The Object that contains event details
+         * @param {string} event.event.type The type of the event which is caught by the listener
+         */
+        this.onCatchAll = new EventEmitter();
+        /**
+         * Fired when data in any of the projects stores changes.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-change)
+         * @param {object} event Event object
+         * @param {Scheduler.model.SchedulerProjectModel,any} event.source This project
+         * @param {Core.data.Store} event.store Affected store
+         * @param {'remove','removeAll','add','clearchanges','filter','update','dataset','replace'} event.action Name of action which triggered the change. May be one of:  * `'remove'` * `'removeAll'` * `'add'` * `'clearchanges'` * `'filter'` * `'update'` * `'dataset'` * `'replace'`
+         * @param {Core.data.Model} event.record Changed record, for actions that affects exactly one record (`'update'`)
+         * @param {Core.data.Model[]} event.records Changed records, passed for all actions except `'removeAll'`
+         * @param {object} event.changes Passed for the `'update'` action, info on which record fields changed
+         */
+        this.onChange = new EventEmitter();
+        /**
+         * Fired when the engine has finished its calculations and the results has been written back to the records.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-dataReady)
+         * @param {object} event Event object
+         * @param {Scheduler.model.SchedulerProjectModel,any} event.source The project
+         * @param {boolean} event.isInitialCommit Flag that shows if this commit is initial
+         * @param {Set<any>} event.records Set of all [Model](https://bryntum.com/products/taskboard/docs/api/Core/data/Model)s that were modified in the completed transaction. Use the [modifications](https://bryntum.com/products/taskboard/docs/api/Core/data/Model#property-modifications) property of each Model to identify modified fields.
+         */
+        this.onDataReady = new EventEmitter();
+        /**
+         * Fires when an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onDestroy = new EventEmitter();
+        /**
+         * Fires when data in any of the registered data stores is changed.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-hasChanges)
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         */
+        this.onHasChanges = new EventEmitter();
+        /**
+         * Fires on successful [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) completion after data gets loaded to the stores.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.response The decoded server response object.
+         * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`
+         * @param {object} event.requestOptions The request options passed to the request.
+         * @param {Response} event.rawResponse The native Response object
+         */
+        this.onLoad = new EventEmitter();
+        /**
+         * Fired after [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) was canceled by some [beforeLoad](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#event-beforeLoad)
+         * listener or due to incomplete prior load request.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.
+         */
+        this.onLoadCanceled = new EventEmitter();
+        /**
+         * Fires when a [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) fails.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager instance.
+         * @param {object} event.response The decoded server response object.
+         * @param {string} event.responseText The raw server response text
+         * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`
+         * @param {object} event.requestOptions The request options passed to the request.
+         * @param {Response} event.rawResponse The native Response object
+         */
+        this.onLoadFail = new EventEmitter();
+        /**
+         * Fires when registered stores get into state when they don't have any
+         * not persisted change. This happens after [load](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) or [sync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) request
+         * completion. Or this may happen after a record update which turns its fields back to their original state.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-noChanges)
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         */
+        this.onNoChanges = new EventEmitter();
+        /**
+         * Fires on successful request completion after data gets applied to the stores.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {'sync','load'} event.requestType The request type (`sync` or `load`).
+         * @param {object} event.response The decoded server response object.
+         * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`
+         * @param {object} event.requestOptions The request options passed to the request.
+         * @param {Response} event.rawResponse The native Response object
+         */
+        this.onRequestDone = new EventEmitter();
+        /**
+         * Fires when a request fails.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager instance.
+         * @param {'sync','load'} event.requestType The request type (`sync` or `load`).
+         * @param {object} event.response The decoded server response object.
+         * @param {string} event.responseText The raw server response text
+         * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`
+         * @param {object} event.requestOptions The request options passed to the request.
+         * @param {Response} event.rawResponse The native Response object
+         */
+        this.onRequestFail = new EventEmitter();
+        /**
+         * Fires on successful [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) completion.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.response The decoded server response object.
+         * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`
+         * @param {object} event.requestOptions The request options passed to the request.
+         * @param {Response} event.rawResponse The native Response object
+         */
+        this.onSync = new EventEmitter();
+        /**
+         * Fires after [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) was canceled by some [beforeSync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#event-beforeSync) listener.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.
+         */
+        this.onSyncCanceled = new EventEmitter();
+        /**
+         * Fires after [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) was delayed due to incomplete previous one.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.
+         * @param {object} event.arguments The arguments of [sync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) call.
+         */
+        this.onSyncDelayed = new EventEmitter();
+        /**
+         * Fires when a [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) fails.
+         * @param {object} event Event object
+         * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager instance.
+         * @param {object} event.response The decoded server response object.
+         * @param {string} event.responseText The raw server response text
+         * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`
+         * @param {object} event.requestOptions The request options passed to the request.
+         * @param {Response} event.rawResponse The native Response object
+         */
+        this.onSyncFail = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumTaskBoardProjectModelComponent;
+        bryntumConfigs.filter(prop => prop in this).forEach(prop => {
+            // @ts-ignore
+            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);
+            if (['features', 'config'].includes(prop)) {
+                WrapperHelper.devWarningConfigProp(instanceName, prop);
+            }
+        });
+        // @ts-ignore
+        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {
+            const uncapitalize = (str) => str.charAt(0).toLowerCase() + str.slice(1), eventName = (str) => uncapitalize(str.slice(2));
+            // @ts-ignore
+            bryntumConfig.listeners[eventName(event)] = e => {
+                // @ts-ignore
+                me[event].emit(e);
+                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag
+                // in Angular listeners
+                return e.returnValue;
+            };
+        });
+        // If component has no container specified in config then use adopt to Wrapper's element
+        const containerParam = [
+            'adopt',
+            'appendTo',
+            'insertAfter',
+            'insertBefore'
+            // @ts-ignore
+        ].find(prop => bryntumConfig[prop]);
+        if (!containerParam) {
+            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {
+                // Button should always be <a> or <button> inside owner element
+                bryntumConfig.appendTo = elementRef.nativeElement;
+            }
+            else {
+                bryntumConfig.adopt = elementRef.nativeElement;
+            }
+        }
+        else {
+            WrapperHelper.devWarningContainer(instanceName, containerParam);
+        }
+        // @ts-ignore
+        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);
+    }
+    /**
+     * Watch for changes
+     * @param changes
+     */
+    ngOnChanges(changes) {
+        const { instance } = this, { instanceName } = BryntumTaskBoardProjectModelComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumTaskBoardProjectModelComponent;
+            if (bryntumProps.includes(prop)) {
+                WrapperHelper.applyPropValue(instance, prop, newValue, false);
+                if (bryntumConfigsOnly.includes(prop)) {
+                    WrapperHelper.devWarningUpdateProp(instanceName, prop);
+                }
+            }
+        });
+    }
+    /**
+     * Destroy the component
+     */
+    ngOnDestroy() {
+        // @ts-ignore
+        if (this.instance && this.instance.destroy) {
+            this.instance.destroy();
+        }
+    }
+}
+BryntumTaskBoardProjectModelComponent.instanceClass = ProjectModel;
+BryntumTaskBoardProjectModelComponent.instanceName = 'ProjectModel';
+BryntumTaskBoardProjectModelComponent.bryntumEvents = [
+    'onBeforeDestroy',
+    'onBeforeLoad',
+    'onBeforeLoadApply',
+    'onBeforeResponseApply',
+    'onBeforeSend',
+    'onBeforeSync',
+    'onBeforeSyncApply',
+    'onCatchAll',
+    'onChange',
+    'onDataReady',
+    'onDestroy',
+    'onHasChanges',
+    'onLoad',
+    'onLoadCanceled',
+    'onLoadFail',
+    'onNoChanges',
+    'onRequestDone',
+    'onRequestFail',
+    'onSync',
+    'onSyncCanceled',
+    'onSyncDelayed',
+    'onSyncFail'
+];
+BryntumTaskBoardProjectModelComponent.bryntumFeatureNames = [];
+BryntumTaskBoardProjectModelComponent.bryntumConfigs = BryntumTaskBoardProjectModelComponent.bryntumFeatureNames.concat([
+    'adjustDurationToDST',
+    'assignmentModelClass',
+    'assignments',
+    'assignmentsData',
+    'assignmentStore',
+    'assignmentStoreClass',
+    'autoLoad',
+    'autoSync',
+    'autoSyncTimeout',
+    'bubbleEvents',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'children',
+    'crudStores',
+    'dependencies',
+    'dependenciesData',
+    'dependencyModelClass',
+    'dependencyStore',
+    'dependencyStoreClass',
+    'encoder',
+    'events',
+    'eventsData',
+    'eventStore',
+    'expanded',
+    'forceSync',
+    'id',
+    'ignoreRemoteChangesInSTM',
+    'includeChildrenInRemoveRequest',
+    'includeLegacyDataProperties',
+    'isFullyLoaded',
+    'json',
+    'listeners',
+    'loadUrl',
+    'orderedParentIndex',
+    'parentId',
+    'parentIndex',
+    'phantomIdField',
+    'phantomParentIdField',
+    'readOnly',
+    'remoteChildCount',
+    'resetIdsBeforeSync',
+    'resourceModelClass',
+    'resources',
+    'resourcesData',
+    'resourceStore',
+    'resourceStoreClass',
+    'shouldSyncDataOnLoad',
+    'silenceInitialCommit',
+    'skipSuccessProperty',
+    'stm',
+    'storeIdProperty',
+    'supportShortSyncResponse',
+    'syncApplySequence',
+    'syncUrl',
+    'taskModelClass',
+    'tasks',
+    'tasksData',
+    'taskStore',
+    'taskStoreClass',
+    'timeZone',
+    'toJSONResultFormat',
+    'trackResponseType',
+    'transport',
+    'useRawData',
+    'validateResponse',
+    'writeAllFields'
+]);
+BryntumTaskBoardProjectModelComponent.bryntumConfigsOnly = [
+    'adjustDurationToDST',
+    'assignmentModelClass',
+    'assignmentsData',
+    'assignmentStoreClass',
+    'autoLoad',
+    'autoSync',
+    'autoSyncTimeout',
+    'bubbleEvents',
+    'children',
+    'dependenciesData',
+    'dependencyModelClass',
+    'dependencyStoreClass',
+    'encoder',
+    'eventsData',
+    'expanded',
+    'ignoreRemoteChangesInSTM',
+    'includeChildrenInRemoveRequest',
+    'listeners',
+    'orderedParentIndex',
+    'parentIndex',
+    'phantomIdField',
+    'phantomParentIdField',
+    'resetIdsBeforeSync',
+    'resourceModelClass',
+    'resourcesData',
+    'resourceStoreClass',
+    'silenceInitialCommit',
+    'skipSuccessProperty',
+    'storeIdProperty',
+    'supportShortSyncResponse',
+    'taskModelClass',
+    'tasksData',
+    'taskStoreClass',
+    'toJSONResultFormat',
+    'trackResponseType',
+    'transport',
+    'useRawData',
+    'validateResponse',
+    'writeAllFields'
+];
+BryntumTaskBoardProjectModelComponent.bryntumProps = BryntumTaskBoardProjectModelComponent.bryntumFeatureNames.concat([
+    'allChildren',
+    'allUnfilteredChildren',
+    'assignments',
+    'assignmentStore',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'crudStores',
+    'dependencies',
+    'dependencyStore',
+    'descendantCount',
+    'events',
+    'eventStore',
+    'forceSync',
+    'hasGeneratedId',
+    'id',
+    'includeLegacyDataProperties',
+    'inlineData',
+    'internalId',
+    'isCommitting',
+    'isCreating',
+    'isFullyLoaded',
+    'isValid',
+    'json',
+    'loadUrl',
+    'parentId',
+    'previousSiblingsTotalCount',
+    'readOnly',
+    'remoteChildCount',
+    'resources',
+    'resourceStore',
+    'resourceTimeRanges',
+    'shouldSyncDataOnLoad',
+    'stm',
+    'syncApplySequence',
+    'syncUrl',
+    'tasks',
+    'taskStore',
+    'timeRanges',
+    'timeZone',
+    'visibleDescendantCount'
+]);
+BryntumTaskBoardProjectModelComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumTaskBoardProjectModelComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumTaskBoardProjectModelComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumTaskBoardProjectModelComponent, selector: "bryntum-task-board-project-model", inputs: { adjustDurationToDST: "adjustDurationToDST", assignmentModelClass: "assignmentModelClass", assignmentsData: "assignmentsData", assignmentStoreClass: "assignmentStoreClass", autoLoad: "autoLoad", autoSync: "autoSync", autoSyncTimeout: "autoSyncTimeout", bubbleEvents: "bubbleEvents", children: "children", dependenciesData: "dependenciesData", dependencyModelClass: "dependencyModelClass", dependencyStoreClass: "dependencyStoreClass", encoder: "encoder", eventsData: "eventsData", expanded: "expanded", ignoreRemoteChangesInSTM: "ignoreRemoteChangesInSTM", includeChildrenInRemoveRequest: "includeChildrenInRemoveRequest", listeners: "listeners", orderedParentIndex: "orderedParentIndex", parentIndex: "parentIndex", phantomIdField: "phantomIdField", phantomParentIdField: "phantomParentIdField", resetIdsBeforeSync: "resetIdsBeforeSync", resourceModelClass: "resourceModelClass", resourcesData: "resourcesData", resourceStoreClass: "resourceStoreClass", silenceInitialCommit: "silenceInitialCommit", skipSuccessProperty: "skipSuccessProperty", storeIdProperty: "storeIdProperty", supportShortSyncResponse: "supportShortSyncResponse", taskModelClass: "taskModelClass", tasksData: "tasksData", taskStoreClass: "taskStoreClass", toJSONResultFormat: "toJSONResultFormat", trackResponseType: "trackResponseType", transport: "transport", useRawData: "useRawData", validateResponse: "validateResponse", writeAllFields: "writeAllFields", assignments: "assignments", assignmentStore: "assignmentStore", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", crudStores: "crudStores", dependencies: "dependencies", dependencyStore: "dependencyStore", events: "events", eventStore: "eventStore", forceSync: "forceSync", id: "id", includeLegacyDataProperties: "includeLegacyDataProperties", isFullyLoaded: "isFullyLoaded", json: "json", loadUrl: "loadUrl", parentId: "parentId", readOnly: "readOnly", remoteChildCount: "remoteChildCount", resources: "resources", resourceStore: "resourceStore", shouldSyncDataOnLoad: "shouldSyncDataOnLoad", stm: "stm", syncApplySequence: "syncApplySequence", syncUrl: "syncUrl", tasks: "tasks", taskStore: "taskStore", timeZone: "timeZone", allChildren: "allChildren", allUnfilteredChildren: "allUnfilteredChildren", descendantCount: "descendantCount", hasGeneratedId: "hasGeneratedId", inlineData: "inlineData", internalId: "internalId", isCommitting: "isCommitting", isCreating: "isCreating", isValid: "isValid", previousSiblingsTotalCount: "previousSiblingsTotalCount", resourceTimeRanges: "resourceTimeRanges", timeRanges: "timeRanges", visibleDescendantCount: "visibleDescendantCount" }, outputs: { onBeforeDestroy: "onBeforeDestroy", onBeforeLoad: "onBeforeLoad", onBeforeLoadApply: "onBeforeLoadApply", onBeforeResponseApply: "onBeforeResponseApply", onBeforeSend: "onBeforeSend", onBeforeSync: "onBeforeSync", onBeforeSyncApply: "onBeforeSyncApply", onCatchAll: "onCatchAll", onChange: "onChange", onDataReady: "onDataReady", onDestroy: "onDestroy", onHasChanges: "onHasChanges", onLoad: "onLoad", onLoadCanceled: "onLoadCanceled", onLoadFail: "onLoadFail", onNoChanges: "onNoChanges", onRequestDone: "onRequestDone", onRequestFail: "onRequestFail", onSync: "onSync", onSyncCanceled: "onSyncCanceled", onSyncDelayed: "onSyncDelayed", onSyncFail: "onSyncFail" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumTaskBoardProjectModelComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-task-board-project-model',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { adjustDurationToDST: [{
+                type: Input
+            }], assignmentModelClass: [{
+                type: Input
+            }], assignmentsData: [{
+                type: Input
+            }], assignmentStoreClass: [{
+                type: Input
+            }], autoLoad: [{
+                type: Input
+            }], autoSync: [{
+                type: Input
+            }], autoSyncTimeout: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], children: [{
+                type: Input
+            }], dependenciesData: [{
+                type: Input
+            }], dependencyModelClass: [{
+                type: Input
+            }], dependencyStoreClass: [{
+                type: Input
+            }], encoder: [{
+                type: Input
+            }], eventsData: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }], ignoreRemoteChangesInSTM: [{
+                type: Input
+            }], includeChildrenInRemoveRequest: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], orderedParentIndex: [{
+                type: Input
+            }], parentIndex: [{
+                type: Input
+            }], phantomIdField: [{
+                type: Input
+            }], phantomParentIdField: [{
+                type: Input
+            }], resetIdsBeforeSync: [{
+                type: Input
+            }], resourceModelClass: [{
+                type: Input
+            }], resourcesData: [{
+                type: Input
+            }], resourceStoreClass: [{
+                type: Input
+            }], silenceInitialCommit: [{
+                type: Input
+            }], skipSuccessProperty: [{
+                type: Input
+            }], storeIdProperty: [{
+                type: Input
+            }], supportShortSyncResponse: [{
+                type: Input
+            }], taskModelClass: [{
+                type: Input
+            }], tasksData: [{
+                type: Input
+            }], taskStoreClass: [{
+                type: Input
+            }], toJSONResultFormat: [{
+                type: Input
+            }], trackResponseType: [{
+                type: Input
+            }], transport: [{
+                type: Input
+            }], useRawData: [{
+                type: Input
+            }], validateResponse: [{
+                type: Input
+            }], writeAllFields: [{
+                type: Input
+            }], assignments: [{
+                type: Input
+            }], assignmentStore: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], crudStores: [{
+                type: Input
+            }], dependencies: [{
+                type: Input
+            }], dependencyStore: [{
+                type: Input
+            }], events: [{
+                type: Input
+            }], eventStore: [{
+                type: Input
+            }], forceSync: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], includeLegacyDataProperties: [{
+                type: Input
+            }], isFullyLoaded: [{
+                type: Input
+            }], json: [{
+                type: Input
+            }], loadUrl: [{
+                type: Input
+            }], parentId: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], remoteChildCount: [{
+                type: Input
+            }], resources: [{
+                type: Input
+            }], resourceStore: [{
+                type: Input
+            }], shouldSyncDataOnLoad: [{
+                type: Input
+            }], stm: [{
+                type: Input
+            }], syncApplySequence: [{
+                type: Input
+            }], syncUrl: [{
+                type: Input
+            }], tasks: [{
+                type: Input
+            }], taskStore: [{
+                type: Input
+            }], timeZone: [{
+                type: Input
+            }], allChildren: [{
+                type: Input
+            }], allUnfilteredChildren: [{
+                type: Input
+            }], descendantCount: [{
+                type: Input
+            }], hasGeneratedId: [{
+                type: Input
+            }], inlineData: [{
+                type: Input
+            }], internalId: [{
+                type: Input
+            }], isCommitting: [{
+                type: Input
+            }], isCreating: [{
+                type: Input
+            }], isValid: [{
+                type: Input
+            }], previousSiblingsTotalCount: [{
+                type: Input
+            }], resourceTimeRanges: [{
+                type: Input
+            }], timeRanges: [{
+                type: Input
+            }], visibleDescendantCount: [{
+                type: Input
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeLoad: [{
+                type: Output
+            }], onBeforeLoadApply: [{
+                type: Output
+            }], onBeforeResponseApply: [{
+                type: Output
+            }], onBeforeSend: [{
+                type: Output
+            }], onBeforeSync: [{
+                type: Output
+            }], onBeforeSyncApply: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onChange: [{
+                type: Output
+            }], onDataReady: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onHasChanges: [{
+                type: Output
+            }], onLoad: [{
+                type: Output
+            }], onLoadCanceled: [{
+                type: Output
+            }], onLoadFail: [{
+                type: Output
+            }], onNoChanges: [{
+                type: Output
+            }], onRequestDone: [{
+                type: Output
+            }], onRequestFail: [{
+                type: Output
+            }], onSync: [{
+                type: Output
+            }], onSyncCanceled: [{
+                type: Output
+            }], onSyncDelayed: [{
+                type: Output
+            }], onSyncFail: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bryntum-task-board-project-model.component.js","sourceRoot":"","sources":["../../../component/src/lib/bryntum-task-board-project-model.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Angular wrapper for Bryntum ProjectModel\n */\n\nimport { Component, ElementRef, EventEmitter, Output, Input, SimpleChange, SimpleChanges, OnDestroy, OnInit } from '@angular/core';\n\nimport WrapperHelper from './wrapper.helper';\n\nimport { AbstractCrudManager, AssignmentModel, AssignmentModelConfig, AssignmentStore, AssignmentStoreConfig, Base, CrudManagerStoreDescriptor, DependencyModel, DependencyModelConfig, DependencyStore, DependencyStoreConfig, EventModel, EventModelConfig, EventStore, EventStoreConfig, Model, ModelConfig, ProjectModel, ProjectModelListeners, ResourceModel, ResourceModelConfig, ResourceStore, ResourceStoreConfig, ResourceTimeRangeModel, ResourceTimeRangeModelConfig, SchedulerProjectModel, StateTrackingManager, StateTrackingManagerConfig, Store, StoreConfig, TaskModel, TaskModelConfig, TaskStore, TaskStoreConfig, TimeRangeModel, TimeRangeModelConfig } from '@bryntum/taskboard';\n\nimport { StringHelper } from '@bryntum/taskboard';\n\nexport type BryntumTaskBoardProjectModelProps = {\n    // Configs\n    /**\n     * A flag, indicating whether the dates and duration calculations should adjust the result to DST time shift.\n     */\n    adjustDurationToDST ? : boolean\n    /**\n     * The constructor of the assignment model class, to be used in the project. Will be set as the\n     * [modelClass](https://bryntum.com/products/taskboard/docs/api/Core/data/Store#config-modelClass) property of the [assignmentStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-assignmentStore)\n     */\n    assignmentModelClass ? : typeof AssignmentModel\n    /**\n     * Data use to fill the [assignmentStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-assignmentStore). Should be an array of\n     * [AssignmentModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/AssignmentModel) or its configuration objects.\n     */\n    assignments ? : AssignmentModel[]|AssignmentModelConfig[]\n    /**\n     * The initial data, to fill the [assignmentStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-assignmentStore) with.\n     * Should be an array of [AssignmentModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/AssignmentModel) or its configuration\n     * objects.\n     * @deprecated 6.3.0 Use [assignments](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#config-assignments) instead\n     */\n    assignmentsData ? : AssignmentModel[]|AssignmentModelConfig[]\n    /**\n     * An [AssignmentStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/AssignmentStore) instance or a config object.\n     */\n    assignmentStore ? : AssignmentStore|AssignmentStoreConfig\n    /**\n     * The constructor to create an assignment store instance with. Should be a class, subclassing the\n     * [AssignmentStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/AssignmentStore)\n     */\n    assignmentStoreClass ? : typeof AssignmentStore|object\n    /**\n     * Specify `true` to automatically call [load](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) method on the next frame after creation.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-autoLoad)\n     */\n    autoLoad ? : boolean\n    /**\n     * `true` to automatically persist store changes after edits are made in any of the stores monitored.\n     * Please note that sync request will not be invoked immediately but only after\n     * [autoSyncTimeout](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#config-autoSyncTimeout) interval.\n     */\n    autoSync ? : boolean\n    /**\n     * The timeout in milliseconds to wait before persisting changes to the server.\n     * Used when [autoSync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#config-autoSync) is set to `true`.\n     */\n    autoSyncTimeout ? : number\n    /**\n     * An object where property names with a truthy value indicate which events should bubble up the ownership\n     * hierarchy when triggered.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-bubbleEvents)\n     */\n    bubbleEvents ? : object\n    /**\n     * Set to `true` to call onXXX method names (e.g. `onShow`, `onClick`), as an easy way to listen for events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-callOnFunctions)\n     */\n    callOnFunctions ? : boolean\n    /**\n     * By default, if an event handler throws an exception, the error propagates up the stack and the\n     * application state is undefined. Code which follows the event handler will *not* be executed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-catchEventHandlerExceptions)\n     */\n    catchEventHandlerExceptions ? : boolean\n    /**\n     * Child nodes. To allow loading children on demand, specify `children : true` in your data. Omit the field for leaf\n     * tasks.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-children)\n     */\n    children ? : boolean|object[]|Model[]|ModelConfig[]\n    /**\n     * Sets the list of stores controlled by the CRUD manager.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-crudStores)\n     */\n    crudStores ? : Store[]|string[]|CrudManagerStoreDescriptor[]|StoreConfig[]\n    /**\n     * Data use to fill the [dependencyStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-dependencyStore). Should be an array of\n     * [DependencyModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/DependencyModel) or its configuration objects.\n     */\n    dependencies ? : DependencyModel[]|DependencyModelConfig[]\n    /**\n     * The initial data, to fill the [dependencyStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-dependencyStore) with.\n     * Should be an array of [DependencyModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/DependencyModel) or its configuration\n     * objects.\n     * @deprecated 6.3.0 Use [dependencies](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#config-dependencies) instead\n     */\n    dependenciesData ? : DependencyModel[]|DependencyModelConfig[]\n    /**\n     * The constructor of the dependency model class, to be used in the project. Will be set as the\n     * [modelClass](https://bryntum.com/products/taskboard/docs/api/Core/data/Store#config-modelClass) property of the [dependencyStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-dependencyStore)\n     */\n    dependencyModelClass ? : typeof DependencyModel\n    /**\n     * A [DependencyStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/DependencyStore) instance or a config object.\n     */\n    dependencyStore ? : DependencyStore|DependencyStoreConfig\n    /**\n     * The constructor to create a dependency store instance with. Should be a class, subclassing the\n     * [DependencyStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/DependencyStore)\n     */\n    dependencyStoreClass ? : typeof DependencyStore|object\n    /**\n     * Configuration of the JSON encoder used by the *Crud Manager*.\n     */\n    encoder ? : {\n        requestData?: object\n    }\n    /**\n     * Data use to fill the [eventStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-eventStore). Should be an array of\n     * [EventModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/EventModel) or its configuration objects.\n     */\n    events ? : EventModel[]|EventModelConfig[]\n    /**\n     * The initial data, to fill the [eventStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-eventStore) with.\n     * Should be an array of [EventModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/EventModel) or its configuration objects.\n     * @deprecated 6.3.0 Use [events](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#config-events) instead\n     */\n    eventsData ? : EventModel[]|EventModelConfig[]\n    /**\n     * An [EventStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/EventStore) instance or a config object.\n     */\n    eventStore ? : EventStore|EventStoreConfig\n    /**\n     * Start expanded or not (only valid for tree data)\n     */\n    expanded ? : boolean\n    /**\n     * Specify as `true` to force sync requests to be sent when calling `sync()`, even if there are no local\n     * changes. Useful in a polling scenario, to keep client up to date with the backend.\n     */\n    forceSync ? : boolean\n    /**\n     * Unique identifier for the record. Might be mapped to another dataSource using idField, but always exposed as\n     * record.id. Will get a generated value if none is specified in records data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-id)\n     */\n    id ? : string|number\n    /**\n     * Set to `true` to make STM ignore changes coming from the backend. This will allow user to only undo redo\n     * local changes.\n     */\n    ignoreRemoteChangesInSTM ? : boolean\n    /**\n     * Set to `false` to only include the id of a removed parent node in the request to the backend (also\n     * affects programmatic calls to get [changes](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#property-changes) etc.), and not the ids of its children.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-includeChildrenInRemoveRequest)\n     */\n    includeChildrenInRemoveRequest ? : boolean\n    /**\n     * Whether to include legacy data properties in the JSON / inlineData output. The legacy data properties are\n     * the `xxData` (`eventsData`, `resourcesData` etc.) properties that are deprecated and will be removed in\n     * the future.\n     * @deprecated 6.3.0 This config will be removed when the eventsData, resourcesData etc. properties are removed in a future release.\n     */\n    includeLegacyDataProperties ? : boolean\n    /**\n     * This field is added to the class at runtime when the Store is configured with\n     * [lazyLoad](https://bryntum.com/products/taskboard/docs/api/Core/data/Store#config-lazyLoad). If set on a parent record at load time, that parent will not cause any\n     * more child load requests. If omitted, it will be automatically set to `true` when a load request receives fewer\n     * child records than requested.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-isFullyLoaded)\n     */\n    isFullyLoaded ? : boolean\n    /**\n     * Project data as a JSON string, used to populate its stores.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-json)\n     */\n    json ? : string\n    /**\n     * The listener set for this object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-listeners)\n     */\n    listeners ? : ProjectModelListeners\n    /**\n     * Convenience shortcut to set only the url to load from, when you do not need to supply any other config\n     * options in the `load` section of the `transport` config.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-loadUrl)\n     */\n    loadUrl ? : string\n    /**\n     * This is a read-only field provided in server synchronization packets to specify\n     * which position the node takes in the parent's ordered children array.\n     * This index is set on load and gets updated on reordering nodes in tree. Sorting and filtering\n     * have no effect on it.\n     */\n    orderedParentIndex ? : number\n    /**\n     * This is a read-only field provided in server synchronization packets to specify\n     * which record id is the parent of the record.\n     */\n    parentId ? : string|number|null\n    /**\n     * This is a read-only field provided in server synchronization packets to specify\n     * which position the node takes in the parent's children array.\n     * This index is set on load and gets updated automatically after row reordering, sorting, etc.\n     * To save the order, need to persist the field on the server and when data is fetched to be loaded,\n     * need to sort by this field.\n     */\n    parentIndex ? : number\n    /**\n     * Field name to be used to transfer a phantom record identifier.\n     */\n    phantomIdField ? : string\n    /**\n     * Field name to be used to transfer a phantom parent record identifier.\n     */\n    phantomParentIdField ? : string\n    /**\n     * Flag the record as read-only on the UI level, preventing the end user from manipulating it using editing\n     * features such as cell editing and event dragging.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-readOnly)\n     */\n    readOnly ? : boolean\n    /**\n     * This field is added to the class at runtime when the Store is configured with\n     * [lazyLoad](https://bryntum.com/products/taskboard/docs/api/Core/data/Store#config-lazyLoad). The\n     * number specified should reflect the <strong>total</strong> amount of children of a parent node, including nested descendants.\n     * @deprecated This field has been deprecated. Please read the [guide](https://bryntum.com/products/grid/docs/guide/Grid/data/lazyloading) to find out if your app needs to use the new [isFullyLoaded](https://bryntum.com/products/taskboard/docs/api/Core/data/mixin/TreeNode#field-isFullyLoaded) field.\n     */\n    remoteChildCount ? : number\n    /**\n     * `True` to reset identifiers (defined by `idField` config) of phantom records before submitting them\n     * to the server.\n     */\n    resetIdsBeforeSync ? : boolean\n    /**\n     * The constructor of the resource model class, to be used in the project. Will be set as the\n     * [modelClass](https://bryntum.com/products/taskboard/docs/api/Core/data/Store#config-modelClass) property of the [resourceStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-resourceStore)\n     */\n    resourceModelClass ? : typeof ResourceModel\n    /**\n     * Data use to fill the [resourceStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-resourceStore). Should be an array of\n     * [ResourceModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/ResourceModel) or its configuration objects.\n     */\n    resources ? : ResourceModel[]|ResourceModelConfig[]\n    /**\n     * The initial data, to fill the [resourceStore](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#property-resourceStore) with.\n     * Should be an array of [ResourceModels](https://bryntum.com/products/scheduler/docs#Scheduler/model/ResourceModel) or its configuration objects.\n     * @deprecated 6.3.0 Use [resources](https://bryntum.com/products/scheduler/docs#Scheduler/model/ProjectModel#config-resources) instead\n     */\n    resourcesData ? : ResourceModel[]|ResourceModelConfig[]\n    /**\n     * A [ResourceStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/ResourceStore) instance or a config object.\n     */\n    resourceStore ? : ResourceStore|ResourceStoreConfig\n    /**\n     * The constructor to create a resource store instance with. Should be a class, subclassing the\n     * [ResourceStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/ResourceStore)\n     */\n    resourceStoreClass ? : typeof ResourceStore|object\n    /**\n     * Experimental hook that lets the app determine if a bound dataset needs syncing with the store or not, and\n     * if it does - which records that should be processed. Only called for stores that are configured with\n     * `syncDataOnLoad: true` (which is the default in the React, Angular and Vue wrappers).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-shouldSyncDataOnLoad)\n     * @param {object} options Options passed by the store to this hook\n     * @param {Core.data.Store} options.store Store about to be synced\n     * @param {Core.data.Model} options.records Records currently in the store\n     * @param {object[]} options.data Incoming data\n     * @returns {Set<any>,boolean} Return `false` to prevent the store from syncing, or a set of record ids that need further processing (for records that has some kind of change, eg. an update, removal or addition)\n     */\n    shouldSyncDataOnLoad ? : (options: { store: Store, records: Model, data: object[] }) => Set<any>|boolean\n    /**\n     * Silences propagations caused by the project loading.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-silenceInitialCommit)\n     */\n    silenceInitialCommit ? : boolean\n    /**\n     * When `true` treats parsed responses without `success` property as successful.\n     * In this mode a parsed response is treated as invalid if it has explicitly set `success : false`.\n     */\n    skipSuccessProperty ? : boolean\n    /**\n     * Configuration options to provide to the STM manager\n     */\n    stm ? : StateTrackingManagerConfig|StateTrackingManager\n    /**\n     * Name of a store property to retrieve store identifiers from. Make sure you have an instance of a\n     * store to use it by id. Store identifier is used as a container name holding corresponding store data\n     * while transferring them to/from the server. By default, `id` property is used. And in case a\n     * container identifier has to differ this config can be used:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-storeIdProperty)\n     */\n    storeIdProperty ? : string\n    /**\n     * When `true` the Crud Manager does not require all updated and removed records to be mentioned in the\n     * *sync* response. In this case response should include only server side changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-supportShortSyncResponse)\n     */\n    supportShortSyncResponse ? : boolean\n    /**\n     * An array of store identifiers sets an alternative sync responses apply order.\n     * By default, the order in which sync responses are applied to the stores is the same as they\n     * registered in. But in case of some tricky dependencies between stores this order can be changed:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-syncApplySequence)\n     */\n    syncApplySequence ? : string[]|CrudManagerStoreDescriptor[]\n    /**\n     * Convenience shortcut to set only the url to sync to, when you do not need to supply any other config\n     * options in the `sync` section of the `transport` config.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-syncUrl)\n     */\n    syncUrl ? : string\n    /**\n     * The constructor of the task model class, to be used in the project.\n     * Will be set as the [modelClass](https://bryntum.com/products/taskboard/docs/api/Core/data/Store#config-modelClass)\n     * property of the [taskStore](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#property-taskStore).\n     */\n    taskModelClass ? : typeof TaskModel\n    /**\n     * The initial data, to fill the [taskStore](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#property-taskStore) with. Should be an array of\n     * [TaskModel](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/TaskModel) or its configuration objects.\n     */\n    tasks ? : TaskModel[]|TaskModelConfig[]\n    /**\n     * The initial data, to fill the [taskStore](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#property-taskStore) with.\n     * Should be an array of [TaskModel](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/TaskModel) instances or its configuration objects.\n     * @deprecated 6.3.0 Use [tasks](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-tasks) instead\n     */\n    tasksData ? : TaskModel[]|TaskModelConfig[]\n    /**\n     * An [TaskStore](https://bryntum.com/products/taskboard/docs/api/TaskBoard/store/TaskStore) instance or a config object.\n     */\n    taskStore ? : TaskStoreConfig|TaskStore\n    /**\n     * The constructor to create a task store instance with.\n     * Should be a class, subclassing the [TaskStore](https://bryntum.com/products/taskboard/docs/api/TaskBoard/store/TaskStore).\n     */\n    taskStoreClass ? : typeof TaskStore\n    /**\n     * Set to a IANA time zone (i.e. `Europe/Stockholm`) or a UTC offset in minutes (i.e. `-120`). This will\n     * convert all events, tasks and time ranges to the specified time zone or offset. It will also affect the\n     * displayed timeline's headers as well at the start and end date of it.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-timeZone)\n     */\n    timeZone ? : string|number\n    /**\n     * Specifies the output format of [toJSON](https://bryntum.com/products/scheduler/docs#Scheduler/model/mixin/ProjectModelCommon#function-toJSON).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-toJSONResultFormat)\n     */\n    toJSONResultFormat ? : 'inlineData'|'model'\n    /**\n     * When `true` forces the CRUD manager to process responses depending on their `type` attribute.\n     * So `load` request may be responded with `sync` response for example.\n     * Can be used for smart server logic allowing the server to decide when it's better to respond with a\n     * complete data set (`load` response) or it's enough to return just a delta (`sync` response).\n     */\n    trackResponseType ? : boolean\n    /**\n     * Configuration of the AJAX requests used by *Crud Manager* to communicate with a server-side.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-transport)\n     */\n    transport ? : {\n        load?: object\n        sync?: object\n    }\n    /**\n     * By default, the stores of a project use the raw data objects passed to them as the data source for their\n     * records if data is loaded remotely (using an `AjaxStore` or a `CrudManager`). For data supplied inline,\n     * the data objects are instead by default cloned to avoid the original data object being modified by the\n     * store.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-useRawData)\n     */\n    useRawData ? : boolean\n    /**\n     * This config validates the response structure for requests made by the Crud Manager.\n     * When `true`, the Crud Manager checks every parsed response structure for errors\n     * and if the response format is invalid, a warning is logged to the browser console.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#config-validateResponse)\n     */\n    validateResponse ? : boolean\n    /**\n     * `true` to write all fields from the record to the server.\n     * If set to `false` it will only send the fields that were modified.\n     * Note that any fields that have [persist](https://bryntum.com/products/taskboard/docs/api/Core/data/field/DataField#config-persist) set to `false` will\n     * still be ignored and fields having [alwaysWrite](https://bryntum.com/products/taskboard/docs/api/Core/data/field/DataField#config-alwaysWrite) set to `true`\n     * will always be included.\n     */\n    writeAllFields ? : boolean\n\n}\n\n@Component({\n    selector : 'bryntum-task-board-project-model',\n    template : ''\n})\nexport class BryntumTaskBoardProjectModelComponent implements OnInit, OnDestroy {\n\n    public static instanceClass = ProjectModel;\n\n    public static instanceName = 'ProjectModel';\n\n    private static bryntumEvents: string[] = [\n        'onBeforeDestroy',\n        'onBeforeLoad',\n        'onBeforeLoadApply',\n        'onBeforeResponseApply',\n        'onBeforeSend',\n        'onBeforeSync',\n        'onBeforeSyncApply',\n        'onCatchAll',\n        'onChange',\n        'onDataReady',\n        'onDestroy',\n        'onHasChanges',\n        'onLoad',\n        'onLoadCanceled',\n        'onLoadFail',\n        'onNoChanges',\n        'onRequestDone',\n        'onRequestFail',\n        'onSync',\n        'onSyncCanceled',\n        'onSyncDelayed',\n        'onSyncFail'\n    ];\n\n    private static bryntumFeatureNames: string[] = [\n\n    ];\n\n    private static bryntumConfigs: string[] = BryntumTaskBoardProjectModelComponent.bryntumFeatureNames.concat([\n        'adjustDurationToDST',\n        'assignmentModelClass',\n        'assignments',\n        'assignmentsData',\n        'assignmentStore',\n        'assignmentStoreClass',\n        'autoLoad',\n        'autoSync',\n        'autoSyncTimeout',\n        'bubbleEvents',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'children',\n        'crudStores',\n        'dependencies',\n        'dependenciesData',\n        'dependencyModelClass',\n        'dependencyStore',\n        'dependencyStoreClass',\n        'encoder',\n        'events',\n        'eventsData',\n        'eventStore',\n        'expanded',\n        'forceSync',\n        'id',\n        'ignoreRemoteChangesInSTM',\n        'includeChildrenInRemoveRequest',\n        'includeLegacyDataProperties',\n        'isFullyLoaded',\n        'json',\n        'listeners',\n        'loadUrl',\n        'orderedParentIndex',\n        'parentId',\n        'parentIndex',\n        'phantomIdField',\n        'phantomParentIdField',\n        'readOnly',\n        'remoteChildCount',\n        'resetIdsBeforeSync',\n        'resourceModelClass',\n        'resources',\n        'resourcesData',\n        'resourceStore',\n        'resourceStoreClass',\n        'shouldSyncDataOnLoad',\n        'silenceInitialCommit',\n        'skipSuccessProperty',\n        'stm',\n        'storeIdProperty',\n        'supportShortSyncResponse',\n        'syncApplySequence',\n        'syncUrl',\n        'taskModelClass',\n        'tasks',\n        'tasksData',\n        'taskStore',\n        'taskStoreClass',\n        'timeZone',\n        'toJSONResultFormat',\n        'trackResponseType',\n        'transport',\n        'useRawData',\n        'validateResponse',\n        'writeAllFields'\n    ]);\n\n    private static bryntumConfigsOnly: string[] = [\n        'adjustDurationToDST',\n        'assignmentModelClass',\n        'assignmentsData',\n        'assignmentStoreClass',\n        'autoLoad',\n        'autoSync',\n        'autoSyncTimeout',\n        'bubbleEvents',\n        'children',\n        'dependenciesData',\n        'dependencyModelClass',\n        'dependencyStoreClass',\n        'encoder',\n        'eventsData',\n        'expanded',\n        'ignoreRemoteChangesInSTM',\n        'includeChildrenInRemoveRequest',\n        'listeners',\n        'orderedParentIndex',\n        'parentIndex',\n        'phantomIdField',\n        'phantomParentIdField',\n        'resetIdsBeforeSync',\n        'resourceModelClass',\n        'resourcesData',\n        'resourceStoreClass',\n        'silenceInitialCommit',\n        'skipSuccessProperty',\n        'storeIdProperty',\n        'supportShortSyncResponse',\n        'taskModelClass',\n        'tasksData',\n        'taskStoreClass',\n        'toJSONResultFormat',\n        'trackResponseType',\n        'transport',\n        'useRawData',\n        'validateResponse',\n        'writeAllFields'\n    ];\n\n    private static bryntumProps: string[] = BryntumTaskBoardProjectModelComponent.bryntumFeatureNames.concat([\n        'allChildren',\n        'allUnfilteredChildren',\n        'assignments',\n        'assignmentStore',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'crudStores',\n        'dependencies',\n        'dependencyStore',\n        'descendantCount',\n        'events',\n        'eventStore',\n        'forceSync',\n        'hasGeneratedId',\n        'id',\n        'includeLegacyDataProperties',\n        'inlineData',\n        'internalId',\n        'isCommitting',\n        'isCreating',\n        'isFullyLoaded',\n        'isValid',\n        'json',\n        'loadUrl',\n        'parentId',\n        'previousSiblingsTotalCount',\n        'readOnly',\n        'remoteChildCount',\n        'resources',\n        'resourceStore',\n        'resourceTimeRanges',\n        'shouldSyncDataOnLoad',\n        'stm',\n        'syncApplySequence',\n        'syncUrl',\n        'tasks',\n        'taskStore',\n        'timeRanges',\n        'timeZone',\n        'visibleDescendantCount'\n    ]);\n\n    private elementRef: ElementRef;\n    public instance!: ProjectModel;\n\n    private bryntumConfig = {\n        adopt            : undefined,\n        appendTo         : undefined,\n        href             : undefined,\n        angularComponent : this,\n        features         : {},\n        listeners        : {}\n    };\n\n    constructor(element: ElementRef) {\n        this.elementRef = element;\n    }\n\n    // Configs only\n    @Input() adjustDurationToDST            ! : boolean;\n    @Input() assignmentModelClass           ! : typeof AssignmentModel;\n    @Input() assignmentsData                ! : AssignmentModel[]|AssignmentModelConfig[];\n    @Input() assignmentStoreClass           ! : typeof AssignmentStore|object;\n    @Input() autoLoad                       ! : boolean;\n    @Input() autoSync                       ! : boolean;\n    @Input() autoSyncTimeout                ! : number;\n    @Input() bubbleEvents                   ! : object;\n    @Input() children                       ! : boolean|object[]|Model[]|ModelConfig[];\n    @Input() dependenciesData               ! : DependencyModel[]|DependencyModelConfig[];\n    @Input() dependencyModelClass           ! : typeof DependencyModel;\n    @Input() dependencyStoreClass           ! : typeof DependencyStore|object;\n    @Input() encoder                        ! : {\n        requestData?: object\n    };\n    @Input() eventsData                     ! : EventModel[]|EventModelConfig[];\n    @Input() expanded                       ! : boolean;\n    @Input() ignoreRemoteChangesInSTM       ! : boolean;\n    @Input() includeChildrenInRemoveRequest ! : boolean;\n    @Input() listeners                      ! : ProjectModelListeners;\n    @Input() orderedParentIndex             ! : number;\n    @Input() parentIndex                    ! : number;\n    @Input() phantomIdField                 ! : string;\n    @Input() phantomParentIdField           ! : string;\n    @Input() resetIdsBeforeSync             ! : boolean;\n    @Input() resourceModelClass             ! : typeof ResourceModel;\n    @Input() resourcesData                  ! : ResourceModel[]|ResourceModelConfig[];\n    @Input() resourceStoreClass             ! : typeof ResourceStore|object;\n    @Input() silenceInitialCommit           ! : boolean;\n    @Input() skipSuccessProperty            ! : boolean;\n    @Input() storeIdProperty                ! : string;\n    @Input() supportShortSyncResponse       ! : boolean;\n    @Input() taskModelClass                 ! : typeof TaskModel;\n    @Input() tasksData                      ! : TaskModel[]|TaskModelConfig[];\n    @Input() taskStoreClass                 ! : typeof TaskStore;\n    @Input() toJSONResultFormat             ! : 'inlineData'|'model';\n    @Input() trackResponseType              ! : boolean;\n    @Input() transport                      ! : {\n        load?: object\n        sync?: object\n    };\n    @Input() useRawData                     ! : boolean;\n    @Input() validateResponse               ! : boolean;\n    @Input() writeAllFields                 ! : boolean;\n\n    // Configs and properties\n    @Input() assignments                 ! : AssignmentModel[]|AssignmentModelConfig[];\n    @Input() assignmentStore             ! : AssignmentStore|AssignmentStoreConfig;\n    @Input() callOnFunctions             ! : boolean;\n    @Input() catchEventHandlerExceptions ! : boolean;\n    @Input() crudStores                  ! : CrudManagerStoreDescriptor[]|Store[]|string[]|StoreConfig[];\n    @Input() dependencies                ! : DependencyModel[]|DependencyModelConfig[];\n    @Input() dependencyStore             ! : DependencyStore|DependencyStoreConfig;\n    @Input() events                      ! : EventModel[]|EventModelConfig[];\n    @Input() eventStore                  ! : EventStore|EventStoreConfig;\n    @Input() forceSync                   ! : boolean;\n    @Input() id                          ! : string|number;\n    @Input() includeLegacyDataProperties ! : boolean;\n    @Input() isFullyLoaded               ! : boolean;\n    @Input() json                        ! : string;\n    @Input() loadUrl                     ! : string;\n    @Input() parentId                    ! : number|string|null;\n    @Input() readOnly                    ! : boolean;\n    @Input() remoteChildCount            ! : number;\n    @Input() resources                   ! : ResourceModel[]|ResourceModelConfig[];\n    @Input() resourceStore               ! : ResourceStore|ResourceStoreConfig;\n    @Input() shouldSyncDataOnLoad        ! : (options: { store: Store, records: Model, data: object[] }) => Set<any>|boolean;\n    @Input() stm                         ! : StateTrackingManager|StateTrackingManagerConfig;\n    @Input() syncApplySequence           ! : string[]|CrudManagerStoreDescriptor[];\n    @Input() syncUrl                     ! : string;\n    @Input() tasks                       ! : TaskModel[]|TaskModelConfig[];\n    @Input() taskStore                   ! : TaskStore|TaskStoreConfig;\n    @Input() timeZone                    ! : string|number;\n\n    // Properties only\n    @Input() allChildren                ! : Model[];\n    @Input() allUnfilteredChildren      ! : Model[];\n    @Input() descendantCount            ! : number;\n    @Input() hasGeneratedId             ! : boolean;\n    @Input() inlineData                 ! : object;\n    @Input() internalId                 ! : number;\n    @Input() isCommitting               ! : boolean;\n    @Input() isCreating                 ! : boolean;\n    @Input() isValid                    ! : boolean;\n    @Input() previousSiblingsTotalCount ! : number;\n    @Input() resourceTimeRanges         ! : ResourceTimeRangeModel[]|ResourceTimeRangeModelConfig[];\n    @Input() timeRanges                 ! : TimeRangeModel[]|TimeRangeModelConfig[];\n    @Input() visibleDescendantCount     ! : number;\n\n    // Events emitters\n    /**\n     * Fires before an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onBeforeDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Fires before [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) is sent. Return `false` to cancel load request.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.\n     */\n    @Output() onBeforeLoad: any = new EventEmitter<((event: { source: AbstractCrudManager, pack: object }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before loaded data get applied to the stores. Return `false` to prevent data applying.\n     * This event can be used for server data preprocessing. To achieve it user can modify the `response` object.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.response The decoded server response object.\n     * @param {object} event.options Options provided to the [load](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) method.\n     */\n    @Output() onBeforeLoadApply: any = new EventEmitter<((event: { source: AbstractCrudManager, response: object, options: object }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before server response gets applied to the stores. Return `false` to prevent data applying.\n     * This event can be used for server data preprocessing. To achieve it user can modify the `response` object.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {'sync','load'} event.requestType The request type (`sync` or `load`).\n     * @param {object} event.response The decoded server response object.\n     */\n    @Output() onBeforeResponseApply: any = new EventEmitter<((event: { source: AbstractCrudManager, requestType: 'sync'|'load', response: object }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before a request is sent to the server.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-beforeSend)\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.crudManager The CRUD manager.\n     * @param {object} event.params HTTP request params to be passed in the request URL.\n     * @param {'sync','load'} event.requestType CrudManager request type (`load`/`sync`)\n     * @param {object} event.requestConfig Configuration object for Ajax request call\n     */\n    @Output() onBeforeSend: any = new EventEmitter<((event: { crudManager: AbstractCrudManager, params: object, requestType: 'sync'|'load', requestConfig: object }) => Promise<void>)|string>();\n    /**\n     * Fires before [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) is sent. Return `false` to cancel sync request.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-beforeSync)\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.\n     */\n    @Output() onBeforeSync: any = new EventEmitter<((event: { source: AbstractCrudManager, pack: object }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before sync response data get applied to the stores. Return `false` to prevent data applying.\n     * This event can be used for server data preprocessing. To achieve it user can modify the `response` object.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.response The decoded server response object.\n     */\n    @Output() onBeforeSyncApply: any = new EventEmitter<((event: { source: AbstractCrudManager, response: object }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires when any other event is fired from the object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-catchAll)\n     * @param {object} event Event object\n     * @param {{[key: string]: any, type: string}} event.event The Object that contains event details\n     * @param {string} event.event.type The type of the event which is caught by the listener\n     */\n    @Output() onCatchAll: any = new EventEmitter<((event: {[key: string]: any, type: string}) => void)|string>();\n    /**\n     * Fired when data in any of the projects stores changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-change)\n     * @param {object} event Event object\n     * @param {Scheduler.model.SchedulerProjectModel,any} event.source This project\n     * @param {Core.data.Store} event.store Affected store\n     * @param {'remove','removeAll','add','clearchanges','filter','update','dataset','replace'} event.action Name of action which triggered the change. May be one of:  * `'remove'` * `'removeAll'` * `'add'` * `'clearchanges'` * `'filter'` * `'update'` * `'dataset'` * `'replace'`\n     * @param {Core.data.Model} event.record Changed record, for actions that affects exactly one record (`'update'`)\n     * @param {Core.data.Model[]} event.records Changed records, passed for all actions except `'removeAll'`\n     * @param {object} event.changes Passed for the `'update'` action, info on which record fields changed\n     */\n    @Output() onChange: any = new EventEmitter<((event: { source: SchedulerProjectModel|any, store: Store, action: 'remove'|'removeAll'|'add'|'clearchanges'|'filter'|'update'|'dataset'|'replace', record: Model, records: Model[], changes: object }) => void)|string>();\n    /**\n     * Fired when the engine has finished its calculations and the results has been written back to the records.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-dataReady)\n     * @param {object} event Event object\n     * @param {Scheduler.model.SchedulerProjectModel,any} event.source The project\n     * @param {boolean} event.isInitialCommit Flag that shows if this commit is initial\n     * @param {Set<any>} event.records Set of all [Model](https://bryntum.com/products/taskboard/docs/api/Core/data/Model)s that were modified in the completed transaction. Use the [modifications](https://bryntum.com/products/taskboard/docs/api/Core/data/Model#property-modifications) property of each Model to identify modified fields.\n     */\n    @Output() onDataReady: any = new EventEmitter<((event: { source: SchedulerProjectModel|any, isInitialCommit: boolean, records: Set<any> }) => void)|string>();\n    /**\n     * Fires when an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Fires when data in any of the registered data stores is changed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-hasChanges)\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     */\n    @Output() onHasChanges: any = new EventEmitter<((event: { source: AbstractCrudManager }) => void)|string>();\n    /**\n     * Fires on successful [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) completion after data gets loaded to the stores.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.response The decoded server response object.\n     * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`\n     * @param {object} event.requestOptions The request options passed to the request.\n     * @param {Response} event.rawResponse The native Response object\n     */\n    @Output() onLoad: any = new EventEmitter<((event: { source: AbstractCrudManager, response: object, responseOptions: object, requestOptions: object, rawResponse: any }) => void)|string>();\n    /**\n     * Fired after [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) was canceled by some [beforeLoad](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#event-beforeLoad)\n     * listener or due to incomplete prior load request.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.\n     */\n    @Output() onLoadCanceled: any = new EventEmitter<((event: { source: AbstractCrudManager, pack: object }) => void)|string>();\n    /**\n     * Fires when a [load request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) fails.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager instance.\n     * @param {object} event.response The decoded server response object.\n     * @param {string} event.responseText The raw server response text\n     * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`\n     * @param {object} event.requestOptions The request options passed to the request.\n     * @param {Response} event.rawResponse The native Response object\n     */\n    @Output() onLoadFail: any = new EventEmitter<((event: { source: AbstractCrudManager, response: object, responseText: string, responseOptions: object, requestOptions: object, rawResponse: any }) => void)|string>();\n    /**\n     * Fires when registered stores get into state when they don't have any\n     * not persisted change. This happens after [load](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-load) or [sync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) request\n     * completion. Or this may happen after a record update which turns its fields back to their original state.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#event-noChanges)\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     */\n    @Output() onNoChanges: any = new EventEmitter<((event: { source: AbstractCrudManager }) => void)|string>();\n    /**\n     * Fires on successful request completion after data gets applied to the stores.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {'sync','load'} event.requestType The request type (`sync` or `load`).\n     * @param {object} event.response The decoded server response object.\n     * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`\n     * @param {object} event.requestOptions The request options passed to the request.\n     * @param {Response} event.rawResponse The native Response object\n     */\n    @Output() onRequestDone: any = new EventEmitter<((event: { source: AbstractCrudManager, requestType: 'sync'|'load', response: object, responseOptions: object, requestOptions: object, rawResponse: any }) => void)|string>();\n    /**\n     * Fires when a request fails.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager instance.\n     * @param {'sync','load'} event.requestType The request type (`sync` or `load`).\n     * @param {object} event.response The decoded server response object.\n     * @param {string} event.responseText The raw server response text\n     * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`\n     * @param {object} event.requestOptions The request options passed to the request.\n     * @param {Response} event.rawResponse The native Response object\n     */\n    @Output() onRequestFail: any = new EventEmitter<((event: { source: AbstractCrudManager, requestType: 'sync'|'load', response: object, responseText: string, responseOptions: object, requestOptions: object, rawResponse: any }) => void)|string>();\n    /**\n     * Fires on successful [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) completion.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.response The decoded server response object.\n     * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`\n     * @param {object} event.requestOptions The request options passed to the request.\n     * @param {Response} event.rawResponse The native Response object\n     */\n    @Output() onSync: any = new EventEmitter<((event: { source: AbstractCrudManager, response: object, responseOptions: object, requestOptions: object, rawResponse: any }) => void)|string>();\n    /**\n     * Fires after [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) was canceled by some [beforeSync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#event-beforeSync) listener.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.pack The data package which contains data for all stores managed by the crud manager.\n     */\n    @Output() onSyncCanceled: any = new EventEmitter<((event: { source: AbstractCrudManager, pack: object }) => void)|string>();\n    /**\n     * Fires after [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) was delayed due to incomplete previous one.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager.\n     * @param {object} event.arguments The arguments of [sync](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) call.\n     */\n    @Output() onSyncDelayed: any = new EventEmitter<((event: { source: AbstractCrudManager, arguments: object }) => void)|string>();\n    /**\n     * Fires when a [sync request](https://bryntum.com/products/scheduler/docs#Scheduler/crud/AbstractCrudManagerMixin#function-sync) fails.\n     * @param {object} event Event object\n     * @param {Scheduler.crud.AbstractCrudManager} event.source The CRUD manager instance.\n     * @param {object} event.response The decoded server response object.\n     * @param {string} event.responseText The raw server response text\n     * @param {object} event.responseOptions [DEPRECATED] see `requestOptions`\n     * @param {object} event.requestOptions The request options passed to the request.\n     * @param {Response} event.rawResponse The native Response object\n     */\n    @Output() onSyncFail: any = new EventEmitter<((event: { source: AbstractCrudManager, response: object, responseText: string, responseOptions: object, requestOptions: object, rawResponse: any }) => void)|string>();\n\n    /**\n     * Create and append the underlying widget\n     */\n    ngOnInit(): void {\n        const\n            me = this,\n            {\n                elementRef,\n                bryntumConfig\n            } = me,\n            {\n                instanceClass,\n                instanceName,\n                bryntumConfigs,\n                bryntumEvents\n            } = BryntumTaskBoardProjectModelComponent;\n\n        bryntumConfigs.filter(prop => prop in this).forEach(prop => {\n            // @ts-ignore\n            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);\n            if (['features', 'config'].includes(prop)) {\n                WrapperHelper.devWarningConfigProp(instanceName, prop);\n            }\n        });\n        // @ts-ignore\n        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {\n            const\n                uncapitalize = (str: string) => str.charAt(0).toLowerCase() + str.slice(1),\n                eventName = (str: string) => uncapitalize(str.slice(2));\n\n            // @ts-ignore\n            bryntumConfig.listeners[eventName(event)] = e => {\n                // @ts-ignore\n                me[event].emit(e);\n                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag\n                // in Angular listeners\n                return e.returnValue;\n            };\n        });\n\n        // If component has no container specified in config then use adopt to Wrapper's element\n        const\n            containerParam = [\n                'adopt',\n                'appendTo',\n                'insertAfter',\n                'insertBefore'\n                // @ts-ignore\n            ].find(prop => bryntumConfig[prop]);\n        if (!containerParam) {\n            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {\n                // Button should always be <a> or <button> inside owner element\n                bryntumConfig.appendTo = elementRef.nativeElement;\n            }\n            else {\n                bryntumConfig.adopt = elementRef.nativeElement;\n            }\n        }\n        else {\n            WrapperHelper.devWarningContainer(instanceName, containerParam);\n        }\n\n        // @ts-ignore\n        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);\n\n    }\n\n    /**\n     * Watch for changes\n     * @param changes\n     */\n    ngOnChanges(changes: SimpleChanges): void {\n        const\n            { instance } = this,\n            { instanceName } = BryntumTaskBoardProjectModelComponent;\n        if (!instance) {\n            return;\n        }\n        // Iterate over all changes\n        Object.entries(changes).forEach(([prop, change]) => {\n            const\n                newValue = (change as SimpleChange).currentValue,\n                { instance } = this,\n                { bryntumConfigsOnly, bryntumProps } = BryntumTaskBoardProjectModelComponent;\n            if (bryntumProps.includes(prop)) {\n                WrapperHelper.applyPropValue(instance, prop, newValue, false);\n                if (bryntumConfigsOnly.includes(prop)) {\n                    WrapperHelper.devWarningUpdateProp(instanceName, prop);\n                }\n            }\n        });\n    }\n\n    /**\n     * Destroy the component\n     */\n    ngOnDestroy(): void {\n        // @ts-ignore\n        if (this.instance && this.instance.destroy) {\n            this.instance.destroy();\n        }\n    }\n}\n"]}