e5core-angular-ui/fesm2015/e5core-angular-ui.js

e5 Anywhere Angular UI

import { FileUploadModule } from 'primeng/fileupload';
import { TreeTableModule } from 'primeng/treetable';
import { HighchartsChartModule } from 'highcharts-angular';
import { HttpClient } from '@angular/common/http';
import { DomSanitizer } from '@angular/platform-browser';
import { map } from 'rxjs/operators';
import { animate, state, style, transition, trigger } from '@angular/animations';
import { Guid } from 'guid-typescript';
import { DataSource } from '@angular/cdk/table';
import { MatSort, MatPaginator, MatIconModule, MatButtonModule, MatCardModule, MatMenuModule, MatTabsModule, MatFormFieldModule, MatInputModule, MatDatepickerModule, MatNativeDateModule, MatSelectModule, MatBadgeModule, MatCheckboxModule, MatPaginatorModule, MatTableModule, MatSortModule, MatProgressSpinnerModule, MatChipsModule } from '@angular/material';
import * as Highcharts from 'highcharts/highstock';
import { Subject, BehaviorSubject, of } from 'rxjs';
import { UIWorkItemModel, WorkGetNextService, UiWorkItemService, ListSearchService, E5ConfigurationService, ConfigurationScopeService, UiDocumentService, TaxonomyFieldDefinitionService, TaxonomyCategory2Service, MonitorsSlaInventoryMonitorModel, MonitorsSlaInventoryMonitorService, UiSearchDefinitionService, WorkSearchFoundationService, MonitorsSlaInflowsMonitorModel, MonitorsSlaInflowsMonitorService, MonitorsSlaCompletionMonitorModel, MonitorsSlaCompletionMonitorService, MonitorsSlaMonitorService, WorkItemFoundationService, WorkAttachmentTypeFoundationService, WorkDocumentFoundationService, WorkItemService, WorkMenuItemFoundationService, MonitorsSlaTeamProductivityCompletionMonitorModel, MonitorsSlaTeamProductivityFacetimeMonitorModel, MonitorsSlaTeamProductivityCompletionMonitorService, MonitorsSlaTeamProductivityFacetimeMonitorService, E5coreAngularServicesModule } from 'e5core-angular-services';
import { CurrencyPipe, DatePipe, CommonModule } from '@angular/common';
import { FormControl, Validators, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';
import { Injectable, Input, Output, EventEmitter, Component, Pipe, ChangeDetectionStrategy, ChangeDetectorRef, ViewChildren, forwardRef, ViewChild, Inject, LOCALE_ID, ViewEncapsulation, NgModule, defineInjectable, inject } from '@angular/core';
import { NgxMaterialTimepickerModule } from 'ngx-material-timepicker';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * This class implements a
 * UIWorkItemModel {
 * fieldsets: UIFieldSetModel[] | undefined ;
 * menus: UIMenuModel[] | undefined ;
 * properties: UIPropertyModel[] | undefined ;
 * tabs: UITabModel[] | undefined ;
 * workId: string | undefined
 * }
 */
class WorkItemModel extends UIWorkItemModel {
    constructor() {
        super();
        this.menus = null;
        this.tabs = null;
        this.workId = null;
        this.fieldsets = null;
        this.properties = null;
    }
}
/**
 * DEPRECATED, use FieldValue
 * @param {?} model
 * @param {?} propertyId
 * @param {?=} defaultValue
 * @return {?}
 */
function PropertyValue(model, propertyId, defaultValue) {
    /** @type {?} */
    let value = undefined;
    if (model && propertyId && model.properties) {
        /** @type {?} */
        const property = model.properties.find(p => p.propertyId == propertyId);
        value = (property) ? property.value : undefined;
    }
    return (value == undefined && defaultValue) ? defaultValue : value;
}
/**
 * @param {?} model
 * @param {?} fieldId
 * @param {?=} defaultValue
 * @return {?}
 */
function FieldValue(model, fieldId, defaultValue) {
    return PropertyValue(model, fieldId, defaultValue);
}
/**
 * DEPRECATED, use ResolvedFieldValue
 * @param {?} model
 * @param {?} propertyId
 * @param {?=} defaultValue
 * @return {?}
 */
function ResolvedPropertyValue(model, propertyId, defaultValue) {
    /** @type {?} */
    let value = undefined;
    if (model && propertyId && model.properties) {
        /** @type {?} */
        const property = model.properties.find(p => p.propertyId == propertyId);
        value = (property) ? property.resolvedValue : undefined;
    }
    return (value == undefined && defaultValue) ? defaultValue : value;
}
/**
 * @param {?} model
 * @param {?} fieldId
 * @param {?=} defaultValue
 * @return {?}
 */
function ResolvedFieldValue(model, fieldId, defaultValue) {
    return ResolvedPropertyValue(model, fieldId, defaultValue);
}
/**
 * @return {?}
 */
function CreateBlankWorkItem() {
    return new WorkItemModel();
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * This service is used to provide work into the work item Subject/
 */
class WorkDeliveryService {
    /**
     * @param {?} getNextService
     * @param {?} uiWorkItemService
     */
    constructor(getNextService, uiWorkItemService) {
        this.getNextService = getNextService;
        this.uiWorkItemService = uiWorkItemService;
    }
    /**
     * @param {?} workItem$
     * @param {?=} lock
     * @return {?}
     */
    getNextWorkItem(workItem$, lock) {
        /** @type {?} */
        const subject$ = new Subject();
        this.getNextService.getNextWorkItem({ lockWorkItem: lock }).subscribe(response => {
            /** @type {?} */
            const wi = response.workItem;
            if (wi && wi.id && !wi.id.isEmpty) {
                this.uiWorkItemService.getAll(wi.id).subscribe(wim => {
                    /** @type {?} */
                    const current = workItem$.getValue();
                    /** @type {?} */
                    const updated = Object.assign({}, current, wim);
                    workItem$.next(updated);
                    subject$.next(updated);
                }, error => { subject$.error(error); }, () => { subject$.complete(); });
            }
            else {
                /** @type {?} */
                let blank = CreateBlankWorkItem();
                workItem$.next(blank);
                subject$.next(blank);
            }
        }, error => subject$.error(error));
        return (subject$);
    }
    /**
     * @param {?} workId
     * @param {?} workItem$
     * @param {?=} lock
     * @return {?}
     */
    getWorkItem(workId, workItem$, lock) {
        /** @type {?} */
        const subject$ = new Subject();
        this.uiWorkItemService.getAll(workId).subscribe(wim => {
            /** @type {?} */
            const updated = Object.assign({}, workItem$.getValue(), wim);
            workItem$.next(updated);
            subject$.next(updated);
        }, error => { subject$.error(error); }, () => { subject$.complete(); });
        return (subject$);
    }
}
WorkDeliveryService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
WorkDeliveryService.ctorParameters = () => [
    { type: WorkGetNextService },
    { type: UiWorkItemService }
];
/** @nocollapse */ WorkDeliveryService.ngInjectableDef = defineInjectable({ factory: function WorkDeliveryService_Factory() { return new WorkDeliveryService(inject(WorkGetNextService), inject(UiWorkItemService)); }, token: WorkDeliveryService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreAngularUiGetNextComponent {
    /**
     * @param {?} workDelivery
     */
    constructor(workDelivery) {
        this.workDelivery = workDelivery;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-angular-ui-get-next [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
    }
    /**
     * @return {?}
     */
    getNext() {
        this.workDelivery.getNextWorkItem(this.workItem$, this.lock ? true : false).subscribe(wim => { }, error => console.error(error));
    }
}
E5coreAngularUiGetNextComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-get-next',
                template: "<p>\n  <button mat-raised-button (click)=\"getNext()\">Get Next</button>\n</p>\n",
                styles: [""]
            }] }
];
/** @nocollapse */
E5coreAngularUiGetNextComponent.ctorParameters = () => [
    { type: WorkDeliveryService }
];
E5coreAngularUiGetNextComponent.propDecorators = {
    workItem$: [{ type: Input }],
    lock: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @enum {number} */
const UiStyle = {
    Box: 0,
    Bootstrap: 1,
    Material: 2,
};
UiStyle[UiStyle.Box] = 'Box';
UiStyle[UiStyle.Bootstrap] = 'Bootstrap';
UiStyle[UiStyle.Material] = 'Material';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class UiStyleService {
    /**
     * @return {?}
     */
    current() {
        return (UiStyle.Material);
    }
    ;
}
UiStyleService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */ UiStyleService.ngInjectableDef = defineInjectable({ factory: function UiStyleService_Factory() { return new UiStyleService(); }, token: UiStyleService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkMenuItemComponent {
    /**
     * @param {?} style
     */
    constructor(style$$1) {
        this.style = style$$1;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-menu-item [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        this.workItem$.subscribe(wi => {
            this.workItemModel = wi;
        });
    }
    /**
     * @param {?} $event
     * @return {?}
     */
    onClick($event) {
        alert('You clicked ' + $event.menuCode);
    }
}
E5coreUiWorkMenuItemComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-item',
                template: `
  <span [ngSwitch]="style.current()">
    <e5core-ui-work-menu-item-box (clickEvent)='onClick($event)' *ngSwitchCase='0' [workItem$]='workItem$' [menuItem]='menuItem'></e5core-ui-work-menu-item-box>
    <e5core-ui-work-menu-item-bootstrap (clickEvent)='onClick($event)' *ngSwitchCase='1' [workItem$]='workItem$' [menuItem]='menuItem'></e5core-ui-work-menu-item-bootstrap>
    <e5core-ui-work-menu-item-material (clickEvent)='onClick($event)' *ngSwitchCase='2' [workItem$]='workItem$' [menuItem]='menuItem'></e5core-ui-work-menu-item-material>
  </span>
  `,
                changeDetection: ChangeDetectionStrategy.Default
            }] }
];
/** @nocollapse */
E5coreUiWorkMenuItemComponent.ctorParameters = () => [
    { type: UiStyleService }
];
E5coreUiWorkMenuItemComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItem: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkMenuItemBoxComponent {
    constructor() {
        this.clickEvent = new EventEmitter();
    }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
    /**
     * @param {?} $event
     * @param {?} menuCode
     * @return {?}
     */
    onClick($event, menuCode) {
        this.clickEvent.emit({ $event: $event, menuCode: menuCode });
    }
}
E5coreUiWorkMenuItemBoxComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-item-box',
                template: "<div class='e5-component'>\n    <div class='e5-title'>e5core-ui-work-menu-item</div>\n    <div class='e5-content'>\n      <code>{{menuItem | json}}</code>\n    </div>\n  </div>",
                styles: [""]
            }] }
];
/** @nocollapse */
E5coreUiWorkMenuItemBoxComponent.ctorParameters = () => [];
E5coreUiWorkMenuItemBoxComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItem: [{ type: Input }],
    clickEvent: [{ type: Output }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkMenuItemMaterialComponent {
    constructor() {
        this.clickEvent = new EventEmitter();
    }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
    /**
     * @param {?} $event
     * @param {?} menuCode
     * @return {?}
     */
    onClick($event, menuCode) {
        this.clickEvent.emit({ $event: $event, menuCode: menuCode });
    }
    /**
     * @param {?} code
     * @return {?}
     */
    mapIcon(code) {
        switch (code.toLowerCase()) {
            case 'saveandclose': return 'close';
            case 'diarise': return 'date_range';
            case 'complete': return 'assignment_turned_in';
            case 'endgetnext': return 'stop';
            case 'clonewithoptions': return 'file_copy';
            case 'reject': return 'highlight_off';
        }
        return (code);
    }
}
E5coreUiWorkMenuItemMaterialComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-item-material',
                template: "<button (click)='onClick($event,menuItem.code)' mat-menu-item>\n  <mat-icon>{{mapIcon(menuItem.code)}}</mat-icon>\n  <span>{{menuItem.label}}</span>\n</button>",
                styles: [""]
            }] }
];
/** @nocollapse */
E5coreUiWorkMenuItemMaterialComponent.ctorParameters = () => [];
E5coreUiWorkMenuItemMaterialComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItem: [{ type: Input }],
    clickEvent: [{ type: Output }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkMenuItemBootstrapComponent {
    constructor() {
        this.clickEvent = new EventEmitter();
    }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
    /**
     * @param {?} $event
     * @param {?} menuCode
     * @return {?}
     */
    onClick($event, menuCode) {
        this.clickEvent.emit({ $event: $event, menuCode: menuCode });
    }
}
E5coreUiWorkMenuItemBootstrapComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-item-bootstrap',
                template: "<button (click)='onClick($event,menuItem.code)' type=\"button\" class=\"btn btn-secondary\" >{{menuItem.label}}</button>&nbsp;",
                styles: [""]
            }] }
];
/** @nocollapse */
E5coreUiWorkMenuItemBootstrapComponent.ctorParameters = () => [];
E5coreUiWorkMenuItemBootstrapComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItem: [{ type: Input }],
    clickEvent: [{ type: Output }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5CoreUiWorkMenuBoxComponent {
    constructor() { }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
}
E5CoreUiWorkMenuBoxComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-box',
                template: "<div class='e5-component' *ngIf='workItem$'>\n  <div class='e5-title'>e5core-ui-work-menu {{(workItem$ | async).workId}}</div>\n    <div class='e5-content' *ngIf='menuItems'>\n      <div *ngFor='let menuItem of menuItems'>\n       <e5core-ui-work-menu-item [workItem$]='workItem$' [menuItem]='menuItem'></e5core-ui-work-menu-item>\n    </div>\n  </div>\n</div>",
                styles: [""]
            }] }
];
/** @nocollapse */
E5CoreUiWorkMenuBoxComponent.ctorParameters = () => [];
E5CoreUiWorkMenuBoxComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItems: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5CoreUiWorkMenuBootstrapComponent {
    constructor() { }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
}
E5CoreUiWorkMenuBootstrapComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-bootstrap',
                template: "<div>\n    <e5core-ui-work-menu-item *ngFor='let menuItem of menuItems' [workItem$]='workItem$' [menuItem]='menuItem'></e5core-ui-work-menu-item>\n</div>",
                styles: [""]
            }] }
];
/** @nocollapse */
E5CoreUiWorkMenuBootstrapComponent.ctorParameters = () => [];
E5CoreUiWorkMenuBootstrapComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItems: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5CoreUiWorkMenuMaterialComponent {
    constructor() { }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
}
E5CoreUiWorkMenuMaterialComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu-material',
                template: "<button mat-icon-button [matMenuTriggerFor]=\"menu\">\n<mat-icon>more_vert</mat-icon>\n</button>\n<mat-menu #menu=\"matMenu\">\n    <e5core-ui-work-menu-item\n        *ngFor='let menuItem of menuItems'\n        [workItem$]='workItem$'\n        [menuItem]='menuItem'>\n    </e5core-ui-work-menu-item>\n</mat-menu>",
                styles: [""]
            }] }
];
/** @nocollapse */
E5CoreUiWorkMenuMaterialComponent.ctorParameters = () => [];
E5CoreUiWorkMenuMaterialComponent.propDecorators = {
    workItem$: [{ type: Input }],
    menuItems: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkMenuComponent {
    /**
     * @param {?} style
     * @param {?} cd
     */
    constructor(style$$1, cd) {
        this.style = style$$1;
        this.cd = cd;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-menu [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        this.workItem$.subscribe(wi => {
            this.workItemModel = wi;
            this.menuItems = [];
            if (this.workItemModel && this.workItemModel.menus) {
                this.menuItems = this.workItemModel.menus;
            }
            this.cd.markForCheck();
        }, e => this.menuItems = null);
    }
}
E5coreUiWorkMenuComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-menu',
                template: `
    <span [ngSwitch]="style.current()">
      <e5core-ui-work-menu-box       *ngSwitchCase='0' [workItem$]='workItem$' [menuItems]='menuItems'></e5core-ui-work-menu-box>
      <e5core-ui-work-menu-bootstrap *ngSwitchCase='1' [workItem$]='workItem$' [menuItems]='menuItems'></e5core-ui-work-menu-bootstrap>
      <e5core-ui-work-menu-material  *ngSwitchCase='2' [workItem$]='workItem$' [menuItems]='menuItems'></e5core-ui-work-menu-material>
    </span>
  `,
                changeDetection: ChangeDetectionStrategy.OnPush
            }] }
];
/** @nocollapse */
E5coreUiWorkMenuComponent.ctorParameters = () => [
    { type: UiStyleService },
    { type: ChangeDetectorRef }
];
E5coreUiWorkMenuComponent.propDecorators = {
    workItem$: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkItemComponent {
    /**
     * @param {?} style
     * @param {?} cd
     */
    constructor(style$$1, cd) {
        this.style = style$$1;
        this.cd = cd;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-item [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        this.workItem$.subscribe(n => {
            this.workItem = n;
            this.cd.markForCheck();
        }, e => this.workItem = null);
    }
}
E5coreUiWorkItemComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-item',
                // templateUrl: './components/e5core-ui-work-item.component.html',
                template: `
    <span [ngSwitch]="style.current()">
      <e5core-ui-work-item-box       *ngSwitchCase='0'  [workItem$]='workItem$' [workItem]='workItem'></e5core-ui-work-item-box>
      <e5core-ui-work-item-bootstrap *ngSwitchCase='1'  [workItem$]='workItem$' [workItem]='workItem'></e5core-ui-work-item-bootstrap>
      <e5core-ui-work-item-material  *ngSwitchCase='2'  [workItem$]='workItem$' [workItem]='workItem'></e5core-ui-work-item-material>
    </span>
  `,
                changeDetection: ChangeDetectionStrategy.OnPush
            }] }
];
/** @nocollapse */
E5coreUiWorkItemComponent.ctorParameters = () => [
    { type: UiStyleService },
    { type: ChangeDetectorRef }
];
E5coreUiWorkItemComponent.propDecorators = {
    workItem$: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkTabComponent {
    /**
     * @param {?} style
     * @param {?} cd
     */
    constructor(style$$1, cd) {
        this.style = style$$1;
        this.cd = cd;
    }
    /**
     * @private
     * @param {?} tabId
     * @return {?}
     */
    updateTabModel(tabId) {
        this.tab = null;
        this.fieldSetIds = [];
        if (this.workItemModel && this.workItemModel.tabs && this.workItemModel.tabs) {
            /** @type {?} */
            const tab = this.workItemModel.tabs.find(t => t.tabId == this.tabId);
            if (tab) {
                this.tab = tab;
                this.fieldSetIds = tab.fieldSetIds;
            }
            else {
                console.warn(`tabId ${this.tabId} is not in parent e5core-ui-work-tab-set`);
            }
        }
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-tab [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        if (this.tabId == null) {
            console.error('e5core-ui-work-tab [tabId] must have a number value');
            return;
        }
        this.workItem$.subscribe(wi => {
            this.workItemModel = wi;
            this.updateTabModel(this.tabId);
            this.cd.markForCheck();
        });
    }
}
E5coreUiWorkTabComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-tab',
                template: `
  <span *ngIf="workItem$ && tabId" [ngSwitch]="style.current()">
    <e5core-ui-work-tab-box *ngSwitchCase='0' [workItem$]='workItem$' [tab]='tab' [fieldSetIds]='fieldSetIds' ></e5core-ui-work-tab-box>
    <e5core-ui-work-tab-bootstrap *ngSwitchCase='1' [workItem$]='workItem$' [tab]='tab' [fieldSetIds]='fieldSetIds' ></e5core-ui-work-tab-bootstrap>
    <e5core-ui-work-tab-material *ngSwitchCase='2' [workItem$]='workItem$' [tab]='tab' [fieldSetIds]='fieldSetIds' ></e5core-ui-work-tab-material>
  </span>
  <div *ngIf="!(workItem$ && tabId)" class="e5core-component-error">&lt;e5core-ui-work-tab&gt; [tabId] must be > 0 and [workItem$] must have a BehaviorSubject&lt;WorkItemModel&gt;</div>`,
                changeDetection: ChangeDetectionStrategy.OnPush
            }] }
];
/** @nocollapse */
E5coreUiWorkTabComponent.ctorParameters = () => [
    { type: UiStyleService },
    { type: ChangeDetectorRef }
];
E5coreUiWorkTabComponent.propDecorators = {
    workItem$: [{ type: Input }],
    tabId: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkFieldSetComponent {
    /**
     * @param {?} style
     * @param {?} cd
     */
    constructor(style$$1, cd) {
        this.style = style$$1;
        this.cd = cd;
    }
    /**
     * @private
     * @param {?} fieldSetId
     * @return {?}
     */
    updateFieldSetModel(fieldSetId) {
        this.fieldSet = null;
        this.fields = [];
        if (this.workItemModel && this.workItemModel.fieldsets) {
            /** @type {?} */
            const fieldSet = this.workItemModel.fieldsets.find(fs => fs.fieldSetId == this.fieldSetId);
            if (fieldSet) {
                this.fieldSet = fieldSet;
                this.fields = fieldSet.fields;
            }
            else {
                console.error(`fieldSetId ${this.fieldSetId} not found in workItem$`);
            }
        }
        else {
            console.error(`No fieldsets in workItem$`);
        }
        this.cd.markForCheck();
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-field-set [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        if (this.fieldSetId == null) {
            console.error('e5core-ui-work-field-set [fieldSetId] must have a number value');
            return;
        }
        this.workItem$.subscribe(wi => {
            this.workItemModel = wi;
            this.updateFieldSetModel(this.fieldSetId);
            this.cd.markForCheck();
        });
    }
}
E5coreUiWorkFieldSetComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-field-set',
                template: `
  <span *ngIf="workItem$ && fieldSetId" [ngSwitch]="style.current()">
    <e5core-ui-work-field-set-box *ngSwitchCase='0' [workItem$]='workItem$' [fieldSet]='fieldSet' [fields]='fields' [readonly]='readonly'></e5core-ui-work-field-set-box>
    <e5core-ui-work-field-set-bootstrap *ngSwitchCase='1' [workItem$]='workItem$' [fieldSet]='fieldSet' [fields]='fields' [readonly]='readonly'></e5core-ui-work-field-set-bootstrap>
    <e5core-ui-work-field-set-material *ngSwitchCase='2' [workItem$]='workItem$' [fieldSet]='fieldSet' [fields]='fields' [readonly]='readonly'></e5core-ui-work-field-set-material>
  </span>
  <div *ngIf="!(workItem$ && fieldSetId)" class="e5core-component-error">&lt;e5core-ui-work-field-set&gt; [fieldSetId] must be > 0 and [workItem$] must have a BehaviorSubject&lt;WorkItemModel&gt;</div>`
            }] }
];
/** @nocollapse */
E5coreUiWorkFieldSetComponent.ctorParameters = () => [
    { type: UiStyleService },
    { type: ChangeDetectorRef }
];
E5coreUiWorkFieldSetComponent.propDecorators = {
    workItem$: [{ type: Input }],
    fieldSetId: [{ type: Input }],
    readonly: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkFieldComponent {
    /**
     * @param {?} style
     */
    constructor(style$$1) {
        this.style = style$$1;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-field [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        if (this.fieldSetId === null || this.propertyId === '') {
            console.error('e5core-ui-work-field [propertyId] and [fieldSetId] must have a value');
            return;
        }
        this.workItem$.subscribe(n => {
            this.workItemModel = n;
            this.field = null;
            this.property = null;
            if (!(this.workItemModel && this.workItemModel.fieldsets && this.workItemModel.properties)) {
                return;
            }
            /** @type {?} */
            const fieldset = this.workItemModel.fieldsets.find(fs => fs.fieldSetId == this.fieldSetId);
            if (!fieldset) {
                console.warn(`fieldSetId ${this.fieldSetId} not found in workItem$`);
                return;
            }
            /** @type {?} */
            const field = fieldset.fields.find(f => f.propertyId == this.propertyId);
            if (!field) {
                console.warn(`propertyId ${this.propertyId} from found in workItem$ fields`);
                return;
            }
            /** @type {?} */
            const property = this.workItemModel.properties.find(p => p.propertyId == this.propertyId);
            if (!property) {
                console.warn(`propertyId ${this.propertyId} from found in workItem$ properties`);
                return;
            }
            this.field = field;
            this.property = property;
        });
    }
}
E5coreUiWorkFieldComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-field',
                template: `
  <span *ngIf="workItem$ && fieldSetId && propertyId && property && field" [ngSwitch]="style.current()">
    <e5core-ui-work-field-box *ngSwitchCase='0' [workItem$]='workItem$' [field]='field' [property]='property' [readonly]='readonly' ></e5core-ui-work-field-box>
    <e5core-ui-work-field-bootstrap *ngSwitchCase='1' [workItem$]='workItem$' [field]='field' [property]='property' [readonly]='readonly' ></e5core-ui-work-field-bootstrap>
    <e5core-ui-work-field-material *ngSwitchCase='2' [workItem$]='workItem$' [field]='field' [property]='property' [readonly]='readonly' ></e5core-ui-work-field-material>
  </span>
  <div *ngIf="!(workItem$ && fieldSetId && propertyId)" class="e5core-component-error">&lt;e5core-ui-work-field-set&gt; missing [fieldSetId], [propertyId] and [workItem$] must have a BehaviorSubject&lt;WorkItemModel&gt;</div>`
            }] }
];
/** @nocollapse */
E5coreUiWorkFieldComponent.ctorParameters = () => [
    { type: UiStyleService }
];
E5coreUiWorkFieldComponent.propDecorators = {
    workItem$: [{ type: Input }],
    fieldSetId: [{ type: Input }],
    propertyId: [{ type: Input }],
    readonly: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkTabSetComponent {
    /**
     * @param {?} style
     * @param {?} cd
     */
    constructor(style$$1, cd) {
        this.style = style$$1;
        this.cd = cd;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-tab-set [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        this.workItem$.subscribe(workItem => {
            this.workItem = workItem;
            // convert tabs associative array to a standard array
            this.tabs = workItem.tabs;
            // if (this.workItem && this.workItem.tabs) {
            //   const tabList = this.workItem.tabs ;
            //   for (const tab of Object.values(tabList)) {
            //     //tab.errorCount = this.errorCount(tab.fieldSetRefs) ;
            //     this.tabs.push(tab) ;
            //   }
            // }
            this.cd.markForCheck();
        }, e => this.workItem = null);
    }
    /**
     * @param {?} fieldSetIds
     * @return {?}
     */
    errorCount(fieldSetIds) {
        if (!(this.workItem && this.workItem.fieldsets)) {
            return (0);
        }
        /** @type {?} */
        const fieldSets = this.workItem.fieldsets;
        if (!fieldSets) {
            return (0);
        }
        return (0);
    }
}
E5coreUiWorkTabSetComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-tab-set',
                template: `
    <span [ngSwitch]="style.current()">
      <e5core-ui-work-tab-set-box *ngSwitchCase='0' [workItem$]='workItem$' [tabs]='tabs'></e5core-ui-work-tab-set-box>
      <e5core-ui-work-tab-set-bootstrap *ngSwitchCase='1' [workItem$]='workItem$' [tabs]='tabs'></e5core-ui-work-tab-set-bootstrap>
      <e5core-ui-work-tab-set-material *ngSwitchCase='2' [workItem$]='workItem$' [tabs]='tabs'></e5core-ui-work-tab-set-material>
    </span>`,
                changeDetection: ChangeDetectionStrategy.OnPush
            }] }
];
/** @nocollapse */
E5coreUiWorkTabSetComponent.ctorParameters = () => [
    { type: UiStyleService },
    { type: ChangeDetectorRef }
];
E5coreUiWorkTabSetComponent.propDecorators = {
    workItem$: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkAttachmentsBaseComponent {
    /**
     * @return {?}
     */
    ngOnInit() {
    }
}
E5coreUiWorkAttachmentsBaseComponent.propDecorators = {
    workItem$: [{ type: Input }],
    readonly: [{ type: Input }],
    pagesizes: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class WorkAttachmentsFrameModel {
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class AttachmentsOdataService {
    /**
     * @param {?} http
     * @param {?} config
     */
    constructor(http, config) {
        this.http = http;
        this.config = config;
    }
    // apiServer: {
    //   baseUrl: 'http://vlane5dev2016:84',
    //   scope: 'test'
    // }
    // e.g. http://localhost:12661/site/odata/Ui/Attachments/8b50f520-cac0-11e8-a32f-00155d2a720c?$count=true&$top=2&$skip=2
    //
    // {
    //   "$id": "1",
    //   "metaData": null,
    //   "id": 1117,
    //   "attachmentId": "630",
    //   "workId": "84ef573a-d293-11e8-967f-005056ba65e4",
    //   "documentName": "20181030133835358_test.pdf",
    //   "parentId": 0,
    //   "attachmentTypeId": 0
    // },
    /**
     * @param {?} workId
     * @param {?} page
     * @param {?} pagesize
     * @param {?=} options
     * @return {?}
     */
    getWorkAttachments(workId, page, pagesize, options) {
        /** @type {?} */
        let subject$ = new BehaviorSubject(new WorkAttachmentsFrameModel());
        /** @type {?} */
        let baseUrl = this.config.settings.apiServer.baseUrl;
        /** @type {?} */
        let scope = this.config.settings.apiServer.scope;
        /** @type {?} */
        let offset = page * pagesize;
        /** @type {?} */
        let url = `${baseUrl}/${scope}/odata/Ui/Attachments/${workId.toString()}?$count=true&$top=${pagesize || 10}&$skip=${offset || 0}`;
        // Append orderby
        if (options && options.orderby && options.orderby !== "")
            url += `&$orderby=${encodeURIComponent(options.orderby)}`;
        this.http.get(url).subscribe(result => {
            /** @type {?} */
            let whf = new WorkAttachmentsFrameModel();
            whf.count = result["@odata.count"];
            whf.page = page;
            whf.pagesize = pagesize;
            whf.data = result.value;
            subject$.next(whf);
        }, error => {
            console.error(error);
            subject$.error(error);
        });
        return (subject$);
    }
}
AttachmentsOdataService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
AttachmentsOdataService.ctorParameters = () => [
    { type: HttpClient },
    { type: E5ConfigurationService }
];
/** @nocollapse */ AttachmentsOdataService.ngInjectableDef = defineInjectable({ factory: function AttachmentsOdataService_Factory() { return new AttachmentsOdataService(inject(HttpClient), inject(E5ConfigurationService)); }, token: AttachmentsOdataService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class OdataMatTableDataSource extends DataSource {
    /**
     * @param {?} workId
     * @param {?} workAttachmentsService
     */
    constructor(workId, workAttachmentsService) {
        super();
        this.workId = workId;
        this.workAttachmentsService = workAttachmentsService;
        this.subject$ = new BehaviorSubject([]);
        this.orderby = { active: "Id", direction: "desc" };
        this.loading$ = new BehaviorSubject(false);
    }
    /**
     * @param {?} paginator
     * @return {?}
     */
    set paginator(paginator) {
        this._paginator = paginator;
        this._paginator.page.subscribe(x => {
            // {"previousPageIndex":0,"pageIndex":1,"pageSize":10,"length":100}
            this.update();
        });
    }
    /**
     * @param {?} sort
     * @return {?}
     */
    set sort(sort) {
        this._sort = sort;
        this._sort.sortChange.subscribe(ob => {
            // {active: "detail", direction: ""}
            this.orderby = ob;
            this.update();
        });
    }
    /**
     * @param {?} id
     * @return {?}
     */
    setWorkId(id) {
        this.workId = id;
        this.update();
    }
    /**
     * @return {?}
     */
    get loadingEvents() {
        return this.loading$;
    }
    /**
     * @return {?}
     */
    update() {
        if (!this.workId || !Guid.isGuid(this.workId) || this.workId.toString() === Guid.EMPTY) {
            this.subject$.next([]);
            return;
        }
        /** @type {?} */
        let page = (this._paginator) ? this._paginator.pageIndex : 0;
        /** @type {?} */
        let pagesize = (this._paginator) ? this._paginator.pageSize : 10;
        /** @type {?} */
        let options = {};
        // Setup orderby option if it's available
        /** @type {?} */
        let orderby = this.orderby;
        if (orderby && orderby.direction && orderby.active) {
            options.orderby = `${orderby.active} ${orderby.direction}`;
        }
        // Go get the data
        this.loading$.next(true);
        this.workAttachmentsService.getWorkAttachments(this.workId, page, pagesize, options).subscribe(frame => {
            this._paginator.length = frame.count;
            this.subject$.next(frame.data);
            this.loading$.next(false);
        }, error => {
            console.error(error);
            this.loading$.next(false);
        });
    }
    /**
     * @return {?}
     */
    connect() {
        this.update();
        return (this.subject$);
    }
    /**
     * @return {?}
     */
    disconnect() { }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class E5coreUiWorkAttachmentsMaterialComponent extends E5coreUiWorkAttachmentsBaseComponent {
    /**
     * @param {?} workAttachments
     */
    constructor(workAttachments) {
        super();
        this.workAttachments = workAttachments;
        this.attachmentDownloadEvent = new EventEmitter();
        this.attachmentSelectEvent = new EventEmitter();
        this.displayedColumns = ['Select', 'Menu', 'Name', 'Type'];
        this.isLoading = true;
        this.length = 0;
        this.pageSize = 10;
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.pageSizeOptions = (this.pagesizes && this.pagesizes.length > 0) ? this.pagesizes : [5, 10, 25, 50];
        this.dataSource = new OdataMatTableDataSource(Guid.EMPTY, this.workAttachments); // this.history.getHistory(id, 0, 10) ;
        this.dataSource.sort = this.sort;
        this.dataSource.paginator = this.paginator;
        this.dataSource.loadingEvents.subscribe(isLoading => {
            this.isLoading = isLoading;
        });
        if (typeof this.workItem$ != 'undefined') {
            this.workItem$.subscribe(wim => {
                this.dataSource.setWorkId(wim.workId);
            });
        }
        if (typeof this.fileUpload$ != 'undefined') {
            this.fileUpload$.subscribe(fum => {
                this.dataSource.setWorkId(fum.workId);
            });
        }
    }
    /**
     * @return {?}
     */
    refresh() {
        this.dataSource.update();
    }
    /**
     * @param {?} event
     * @param {?} element
     * @return {?}
     */
    onAttachmentDownload(event, element) {
        this.attachmentDownloadEvent.emit({ event: event, element: element });
    }
    /**
     * @param {?} event
     * @param {?} element
     * @return {?}
     */
    onAttachmentSelect(event, element) {
        this.attachmentSelectEvent.emit({ workId: element.WorkId, type: "E5SharepointAttachment", attachmentId: element.Id, fullUrl: null, name: null });
    }
    /**
     * @param {?} setPageSizeOptionsInput
     * @return {?}
     */
    setPageSizeOptions(setPageSizeOptionsInput) {
        this.pageSizeOptions = setPageSizeOptionsInput.split(',').map(str => +str);
    }
}
E5coreUiWorkAttachmentsMaterialComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-attachments-material',
                template: "<div class=\"e5core-ui-work-attachments\">\n\n  <div *ngIf=\"isLoading\" class=\"mat-spinner-holder\" align=\"center\">\n      <mat-spinner></mat-spinner>\n  </div>\n\n  <table mat-table [dataSource]=\"dataSource\" matSort class=\"e5core-ui-work-attachments\">\n\n\n    <!-- Select -->\n    <ng-container matColumnDef=\"Select\">\n      <th mat-header-cell *matHeaderCellDef> </th>\n      <td mat-cell *matCellDef=\"let element\"> \n          <button (click)='onAttachmentSelect($event, element)' mat-icon-button>\n            <mat-icon>attach_file</mat-icon>\n          </button>\n      </td>\n    </ng-container>\n\n    <!-- Menu -->\n    <ng-container matColumnDef=\"Menu\">\n      <th mat-header-cell *matHeaderCellDef> </th>\n      <td mat-cell *matCellDef=\"let element\"> \n          <button mat-icon-button [matMenuTriggerFor]=\"menu\">\n            <mat-icon>more_vert</mat-icon>\n          </button>\n          <mat-menu #menu=\"matMenu\">\n            <button (click)='onAttachmentDownload($event, element)' mat-menu-item>\n              <mat-icon>cloud_download</mat-icon>\n              <span>Download</span>\n            </button>\n          </mat-menu>\n      </td>\n    </ng-container>\n\n    <!-- Name -->\n    <ng-container matColumnDef=\"Name\">\n      <th mat-header-cell *matHeaderCellDef mat-sort-header> Name </th>\n      <td mat-cell *matCellDef=\"let element\"> {{element.Name}} </td>\n    </ng-container>\n\n    <!-- Type -->\n    <ng-container matColumnDef=\"Type\">\n      <th mat-header-cell *matHeaderCellDef mat-sort-header> Type </th>\n      <td mat-cell *matCellDef=\"let element\"> {{element.Type}} </td>\n    </ng-container>\n\n    <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n  </table>\n\n  <mat-paginator [length]=\"length\" [pageSize]=\"pageSize\" [pageSizeOptions]=\"pageSizeOptions\" (page)=\"pageEvent = $event\" showFirstLastButtons></mat-paginator>\n</div>",
                styles: ["table.e5core-ui-work-attachments{width:100%}table.e5core-ui-work-attachments tr th:nth-child(1),table.e5core-ui-work-attachments tr th:nth-child(2){width:50pt}table.e5core-ui-work-attachments tr th:nth-child(3){width:220pt}.e5core-ui-work-attachments .mat-spinner-holder{width:100%;padding:20pt;position:relative;top:30px;height:1px}.e5core-ui-work-attachments .mat-paginator{margin-top:0;background:0 0}"]
            }] }
];
/** @nocollapse */
E5coreUiWorkAttachmentsMaterialComponent.ctorParameters = () => [
    { type: AttachmentsOdataService }
];
E5coreUiWorkAttachmentsMaterialComponent.propDecorators = {
    workItem$: [{ type: Input }],
    fileUpload$: [{ type: Input }],
    attachmentDownloadEvent: [{ type: Output }],
    attachmentSelectEvent: [{ type: Output }],
    sort: [{ type: ViewChild, args: [MatSort,] }],
    paginator: [{ type: ViewChild, args: [MatPaginator,] }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
// <e5core-ui-work-attachments-box *ngSwitchCase='0' [workItem$]='workItem$' [readonly]='readonly' [pagesizes]='pagesizes'></e5core-ui-work-attachments-box>
// <e5core-ui-work-attachments-bootstrap *ngSwitchCase='1' [workItem$]='workItem$' [readonly]='readonly' [pagesizes]='pagesizes'></e5core-ui-work-attachments-bootstrap>
class E5coreUiWorkAttachmentsComponent {
    /**
     * @param {?} style
     * @param {?} config
     * @param {?} changeDetectorRef
     */
    constructor(style$$1, config, changeDetectorRef) {
        this.style = style$$1;
        this.config = config;
        this.changeDetectorRef = changeDetectorRef;
        this.attachmentDownloadEvent = new EventEmitter();
        this.attachmentSelectEvent = new EventEmitter();
        this.downloadUrl = '';
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (typeof this.workItem$ == 'undefined') {
            console.error('e5core-ui-work-attachments [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        if (typeof this.workItem$ != 'undefined') {
            this.workItem$.subscribe(w => {
                this.updateData();
            });
        }
        if (typeof this.fileUpload$ != 'undefined') {
            this.fileUpload$.subscribe(w => {
                this.updateData();
            });
        }
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
    }
    /**
     * @return {?}
     */
    refresh() {
        this.workAttachmentsMaterialComponent.refresh();
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onAttachmentDownload(event) {
        /** @type {?} */
        var baseUrl = this.config.settings.apiServer.baseUrl;
        /** @type {?} */
        var scope = this.config.settings.apiServer.scope;
        /** @type {?} */
        var w = this.workItem$.getValue();
        this.downloadUrl = `${baseUrl}/${scope}/api/ui/Attachment/Download/${w.workId}/${event.element.Id}`;
        this.changeDetectorRef.detectChanges();
        setTimeout(() => { this.downloadUrl = ""; }, 200);
        this.attachmentDownloadEvent.emit(event);
    }
    /**
     * @param {?} viewerDisplayEvent
     * @return {?}
     */
    onAttachmentSelect(viewerDisplayEvent) {
        this.attachmentSelectEvent.emit(viewerDisplayEvent);
    }
    /**
     * @private
     * @return {?}
     */
    updateData() {
    }
}
E5coreUiWorkAttachmentsComponent.decorators = [
    { type: Component, args: [{
                selector: 'e5core-ui-work-attachments',
                template: `
  <span *ngIf="workItem$" [ngSwitch]="style.current()">
    <e5core-ui-work-attachments-material *ngSwitchCase='2' [workItem$]='workItem$' [readonly]='readonly' [pagesizes]='pagesizes' (attachmentDownloadEvent)='onAttachmentDownload($event)' (attachmentSelectEvent)='onAttachmentSelect($event)' ></e5core-ui-work-attachments-material>
  </span>
  <div *ngIf="!(workItem$)" class="e5core-component-error">&lt;e5core-ui-work-attachments&gt; [workItem$] must have a BehaviorSubject&lt;WorkItemModel&gt;</div>
  <iframe width="0" height="0" *ngIf="!(downloadUrl == '')" [src]="downloadUrl | safe" style="width:0;height:0;border:0; border:none; position: absolute;"></iframe>`,
                changeDetection: ChangeDetectionStrategy.OnPush
            }] }
];
/** @nocollapse */
E5coreUiWorkAttachmentsComponent.ctorParameters = () => [
    { type: UiStyleService },
    { type: E5ConfigurationService },
    { type: ChangeDetectorRef }
];
E5coreUiWorkAttachmentsComponent.propDecorators = {
    workItem$: [{ type: Input }],
    fileUpload$: [{ type: Input }],
    readonly: [{ type: Input }],
    pagesizes: [{ type: Input }],
    attachmentDownloadEvent: [{ type: Output }],
    attachmentSelectEvent: [{ type: Output }],
    workAttachmentsMaterialComponent: [{ type: ViewChild, args: [E5coreUiWorkAttachmentsMaterialComponent,] }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @abstract
 */
class E5coreUiWorkFieldTypeBase {
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.workItem$ == null) {
            console.error('e5core-ui-work-field-type-input [workItem$] must have a BehaviorSubject<WorkItemModel>');
            return;
        }
        this.workItem$.subscribe(n => {
            this.