import * as i0 from '@angular/core';
import { ElementRef, EventEmitter, ChangeDetectorRef, OnDestroy, OnInit, AfterViewInit, PipeTransform, Renderer2, DoCheck, AfterContentChecked, NgZone, OnChanges, SimpleChanges, ViewContainerRef, ComponentFactoryResolver, TemplateRef, QueryList } from '@angular/core';
import { PDFDocument } from 'pdf-lib';
import SignaturePad from 'signature_pad';
import * as i2 from '@angular/common';
import { PrintStockStickers } from '@colijnit/sharedapi/build/model/print-stock-stickers';
import { GetStockHistoryRequest } from '@colijnit/articleapi/build/model/get-stock-history-request';
import { ArticleStock as ArticleStock$1 } from '@colijnit/articleapi/build/model/article-stock.bo';
import { ArticleStock } from '@colijnit/articleapi/build/model/article-stock';
import { StockHistoryBo } from '@colijnit/articleapi/build/model/stock-history.bo';
import { ArticleDetailsBo } from '@colijnit/articleapi/build/model/article-details.bo';
import { ArticleStockManagement } from '@colijnit/articleapi/build/model/article-stock-management';
import { StockStatus } from '@colijnit/articleapi/build/model/stock-status.bo';
import { StockManagementWarehouses } from '@colijnit/articleapi/build/model/stock-management-warehouses.bo';
import { StockLocation } from '@colijnit/articleapi/build/model/stock-location.bo';
import { ArticleTransaction } from '@colijnit/articleapi/build/model/article-transaction';
import { ArticleTransaction as ArticleTransaction$1 } from '@colijnit/articleapi/build/model/article-transaction.bo';
import { Articles } from '@colijnit/articleapi/build/articles';
import { Sharedapi } from '@colijnit/sharedapi/build/sharedapi';
import { BehaviorSubject, Subject } from 'rxjs';
import { LanguageCode as LanguageCode$1 } from '@colijnit/ioneconnector/build/enum/language-code.enum';
import { MainApi } from '@colijnit/mainapi';
import { Printer } from '@colijnit/mainapi/build/model/printer.bo';
import { SendMethod as SendMethod$1 } from '@colijnit/mainapi/build/model/send-method.bo';
import { StockForecast } from '@colijnit/articleapi/build/model/stock-forecast.bo';
import { TagCategory as TagCategory$1 } from '@colijnit/mainapi/build/enum/tab-category.enum';
import { TagTreeItem as TagTreeItem$1 } from '@colijnit/mainapi/build/model/tag-tree-item.bo';
import { ArticleExtended } from '@colijnit/articleapi/build/model/article-extended.bo';
import { ArticleExtendedRequest } from '@colijnit/articleapi/build/model/article-extended-request';
import { ArticleFlat } from '@colijnit/articleapi/build/model/article-flat.bo';
import { ObjectConfiguration } from '@colijnit/ioneconnector/build/model/object-configuration';
import { RelationApi } from '@colijnit/relationapi';
import { RelationListObject } from '@colijnit/relationapi/build/model/relation-list-object.bo';
import { RelationRequest } from '@colijnit/relationapi/build/model/relation-request';
import { TaskCategory } from '@colijnit/mainapi/build/model/task-category.bo';
import { TableName as TableName$1 } from '@colijnit/mainapi/build/enum/table-name.enum';
import { WorkflowProcess } from '@colijnit/mainapi/build/model/workflow-process';
import { DomainName } from '@colijnit/mainapi/build/enum/domain-name.enum';
import { CoDomainValue } from '@colijnit/mainapi/build/model/co-domain-value.bo';
import { RoleEmailaddress } from '@colijnit/mainapi/build/model/role-email-address';
import { Activity } from '@colijnit/mainapi/build/model/activity.bo';
import { ValidationResult } from '@colijnit/ioneconnector/build/model/validation-result';
import { WorkflowProcessInfoPerStatus } from '@colijnit/mainapi/build/model/workflow-process-info-per-status';
import { RelationSmallObject } from '@colijnit/mainapi/build/model/relation-small-object.bo';
import { SelectReportTemplatesRequest } from '@colijnit/mainapi/build/model/select-report-templates-request';
import { Report } from '@colijnit/mainapi/build/model/report.bo';
import { EmailJob } from '@colijnit/mainapi/build/model/email-job';
import { Work } from '@colijnit/mainapi/build/model/work.bo';
import { Remark } from '@colijnit/mainapi/build/model/remark.bo';
import { Task } from '@colijnit/mainapi/build/model/task.bo';
import { ActivityEmailHistory } from '@colijnit/mainapi/build/model/activity-email-history.bo';
import { ActivityWorkflow } from '@colijnit/mainapi/build/model/activity-workflow';
import { EmailActivityRequest } from '@colijnit/mainapi/build/model/email-activity-request';
import { Form } from '@colijnit/mainapi/build/model/form.bo';
import { FormResponse } from '@colijnit/mainapi/build/model/form-response.bo';
import { SequenceName } from '@colijnit/mainapi/build/enum/sequence-name.enum';
import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
import * as i3 from '@colijnit/corecomponents_v12';
import { BaseModuleScreenConfigService, SimpleGridColumnTemplateType, CoreDialogService, OverlayService, ScreenConfigAdapterComponent, FormComponent, PromptService, FormMasterService, IconCacheService as IconCacheService$1, ColorSequenceService, IconListItem, ColorSequenceName, InputTextComponent } from '@colijnit/corecomponents_v12';
import { SendMethodType } from '@colijnit/mainapi/build/enum/send-method-type.enum';
import { PrintStockStickers as PrintStockStickers$1 } from '@colijnit/articleapi/build/model/print-stock-stickers';
import { PrintPriceStickers } from '@colijnit/sharedapi/build/model/print-price-stickers.bo';
import { ReportLayoutSelectionEmail } from '@colijnit/mainapi/build/model/report-layout-selection-email.bo';
import { ReportLayoutSelectionPrint } from '@colijnit/mainapi/build/model/report-layout-selection-print.bo';
import { ReportingDocumentPdfBaseRequest } from '@colijnit/mainapi/build/model/reporting-document-pdf-base-request';
import { ReportingDocumentEmailSignDocBaseRequest } from '@colijnit/mainapi/build/model/reporting-document-email-sign-doc-base-request';
import { ReportingDocumentPrintSignDocBaseRequest } from '@colijnit/mainapi/build/model/reporting-document-print-sign-doc-base-request';
import { PrintPurchaseOrderForTransactionOrderWithoutLinesRequest } from '@colijnit/mainapi/build/model/print-purchase-order-for-transaction-order-without-lines-request';
import { CoDocument } from '@colijnit/mainapi/build/model/co-document.bo';
import { ReportType } from '@colijnit/mainapi/build/enum/report-type.enum';
import { CoEmailAttachment } from '@colijnit/mainapi/build/model/co-email-attachment.bo';
import { LayoutCode } from '@colijnit/mainapi/build/enum/layout-code.enum';
import { ReportingDocumentBaseRequest } from '@colijnit/mainapi/build/model/reporting-document-base-request';
import { ProcessPrintRequest } from '@colijnit/mainapi/build/model/process-print-request';
import { ReportLayoutSelectionBase } from '@colijnit/mainapi/build/model/report-layout-selection-base.bo';
import { BusinessObject } from '@colijnit/ioneconnector/build/model/business-object';
import { FileTypeInternal } from '@colijnit/sharedapi/build/enum/refcode/file-type-internal.enum';
import * as i4 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { FileType as FileType$1 } from '@colijnit/mainapi/build/enum/file-type.enum';
import { DocumentPublication } from '@colijnit/articleapi/build/enum/refcode/document-publication.enum';
import { StoreGroup } from '@colijnit/mainapi/build/model/store-group.bo';
import { RelationKind } from '@colijnit/articleapi/build/enum/relation-kind.enum';
import { ActivityType } from '@colijnit/mainapi/build/enum/activity-type';
import { TimeUtils } from '@colijnit/mainapi/build/utils/time-utils';
import { ActivityListViewModel } from '@colijnit/mainapi/build/model/activity-list-view-model';
import { ActivityViewModel } from '@colijnit/mainapi/build/model/activity-view-model';
import { PersonalActivityTabEnum } from '@colijnit/mainapi/build/enum/personal-activity-tab.enum';
import { ActivitySortType } from '@colijnit/mainapi/build/enum/activity-sort-type.enum';
import { Workflow } from '@colijnit/mainapi/build/model/workflow.bo';
import { WorkflowTrigger } from '@colijnit/mainapi/build/model/workflow-trigger.bo';
import { ModuleNavigationLink } from '@colijnit/mainapi/build/enum/module-navigation-link';
import { WorkflowGenericTransition } from '@colijnit/mainapi/build/model/workflow-generic-transition.bo';
import { WorkflowCategoryType } from '@colijnit/mainapi/build/enum/workflow-category.enum';
import { BusinessObjectFactory } from '@colijnit/ioneconnector/build/service/business-object-factory';
import { AsyncValidatorFn } from '@angular/forms';
import { activityEmailRequestData } from '@colijnit/mainapi/build/model/activity-email-request-data';
import { FormQuestionType } from '@colijnit/mainapi/build/enum/form-question.type';
import { FormQuestion } from '@colijnit/mainapi/build/model/form-question.bo';
import { FormQuestionAnswer } from '@colijnit/mainapi/build/model/form-question-answer.bo';
import { FormQuestionResponse } from '@colijnit/mainapi/build/model/form-question-response.bo';
import { BusinessObjectIDType } from '@colijnit/ioneconnector/build/type/business-object-id-type';
import { RelationKind as RelationKind$1 } from '@colijnit/mainapi/build/enum/relation-kind';
import { ObjectConfigurationDefaultValueType } from '@colijnit/ioneconnector/build/type/object-configuration-default-value-type';
import { Relation } from '@colijnit/relationapi/build/model/relation.bo';
import { Options } from '@colijnit/ioneconnector/build/model/options';

interface TextDimension {
    x: number;
    y: number;
    width: number;
    height: number;
    page: number;
}
declare class DocsignComponent {
    private _changeDetector;
    pdfContainer: ElementRef<HTMLDivElement>;
    /**
     * Load an existing [[PDFDocument]]. The input data can be provided in
     * multiple formats:
     *
     * | Type          | Contents                                               |
     * | ------------- | ------------------------------------------------------ |
     * | `string`      | A base64 encoded string (or data URI) containing a PDF |
     * | `Uint8Array`  | The raw bytes of a PDF                                 |
     * | `ArrayBuffer` | The raw bytes of a PDF                                 |
     *
     * For example:
     * ```js
     * import { PDFDocument } from 'pdf-lib'
     *
     * // pdf=string
     * const base64 =
     *  'JVBERi0xLjcKJYGBgYEKCjUgMCBvYmoKPDwKL0ZpbHRlciAvRmxhdGVEZWNvZGUKL0xlbm' +
     *  'd0aCAxMDQKPj4Kc3RyZWFtCniccwrhMlAAwaJ0Ln2P1Jyy1JLM5ERdc0MjCwUjE4WQNC4Q' +
     *  '6cNlCFZkqGCqYGSqEJLLZWNuYGZiZmbkYuZsZmlmZGRgZmluDCQNzc3NTM2NzdzMXMxMjQ' +
     *  'ztFEKyuEK0uFxDuAAOERdVCmVuZHN0cmVhbQplbmRvYmoKCjYgMCBvYmoKPDwKL0ZpbHRl' +
     *  'ciAvRmxhdGVEZWNvZGUKL1R5cGUgL09ialN0bQovTiA0Ci9GaXJzdCAyMAovTGVuZ3RoID' +
     *  'IxNQo+PgpzdHJlYW0KeJxVj9GqwjAMhu/zFHkBzTo3nCCCiiKIHPEICuJF3cKoSCu2E8/b' +
     *  '20wPIr1p8v9/8kVhgilmGfawX2CGaVrgcAi0/bsy0lrX7IGWpvJ4iJYEN3gEmrrGBlQwGs' +
     *  'HHO9VBX1wNrxAqMX87RBD5xpJuddqwd82tjAHxzV1U5LPgy52DKXWnr1Lheg+j/c/pzGVr' +
     *  'iqV0VlwZPXGPCJjElw/ybkwUmeoWgxesDXGhHJC/D/iikp1Av80ptKU0FdBEe25pPihAM1' +
     *  'u6ytgaaWfs2Hrz35CJT1+EWmAKZW5kc3RyZWFtCmVuZG9iagoKNyAwIG9iago8PAovU2l6' +
     *  'ZSA4Ci9Sb290IDIgMCBSCi9GaWx0ZXIgL0ZsYXRlRGVjb2RlCi9UeXBlIC9YUmVmCi9MZW' +
     *  '5ndGggMzgKL1cgWyAxIDIgMiBdCi9JbmRleCBbIDAgOCBdCj4+CnN0cmVhbQp4nBXEwREA' +
     *  'EBAEsCwz3vrvRmOOyyOoGhZdutHN2MT55fIAVocD+AplbmRzdHJlYW0KZW5kb2JqCgpzdG' +
     *  'FydHhyZWYKNTEwCiUlRU9G'
     *
     * const dataUri = 'data:application/pdf;base64,' + base64
     *
     * const pdfDoc1 = await PDFDocument.load(base64)
     * const pdfDoc2 = await PDFDocument.load(dataUri)
     *
     * // pdf=Uint8Array
     * import fs from 'fs'
     * const uint8Array = fs.readFileSync('with_update_sections.pdf')
     * const pdfDoc3 = await PDFDocument.load(uint8Array)
     *
     * // pdf=ArrayBuffer
     * const url = 'https://pdf-lib.js.org/assets/with_update_sections.pdf'
     * const arrayBuffer = await fetch(url).then(res => res.arrayBuffer())
     * const pdfDoc4 = await PDFDocument.load(arrayBuffer)
     *
     * ```
     *
     * @param pdf The input data containing a PDF document.
     * @param options The options to be used when loading the document.
     * @returns Resolves with a document loaded from the input.
     */
    set pdf(value: any);
    get pdf(): any;
    firstSignatureLabel: string;
    set firstSignatureField(value: string);
    get firstSignatureField(): string;
    secondSignatureLabel: string;
    set secondSignatureField(value: string);
    get secondSignatureField(): string;
    saveButtonLabel: string;
    clearButtonLabel: string;
    signDocumentButtonLabel: string;
    cancelButtonLabel: string;
    pdfSaved: EventEmitter<string>;
    cancelClick: EventEmitter<MouseEvent>;
    showClass(): boolean;
    showSignaturePopup: boolean;
    showSigBuyer: boolean;
    sigBuyerPosition: TextDimension;
    showSigSeller: boolean;
    sigSellerPosition: TextDimension;
    showSignatures: boolean;
    pdfDoc: PDFDocument;
    private _pdf;
    private _firstSignatureField;
    private _secondSignatureField;
    constructor(_changeDetector: ChangeDetectorRef);
    saveFirstSignature(sig: string): void;
    saveSecondSignature(sig: string): void;
    private _openPDF;
    private _renderPdfPages;
    private _savePdf;
    private _checkSignatures;
    private _getPositionSignature;
    private _saveSignature;
    private _preparePDF;
    private _getPdfBytesCopy;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocsignComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DocsignComponent, "co-docsign", never, { "pdf": { "alias": "pdf"; "required": false; }; "firstSignatureLabel": { "alias": "firstSignatureLabel"; "required": false; }; "firstSignatureField": { "alias": "firstSignatureField"; "required": false; }; "secondSignatureLabel": { "alias": "secondSignatureLabel"; "required": false; }; "secondSignatureField": { "alias": "secondSignatureField"; "required": false; }; "saveButtonLabel": { "alias": "saveButtonLabel"; "required": false; }; "clearButtonLabel": { "alias": "clearButtonLabel"; "required": false; }; "signDocumentButtonLabel": { "alias": "signDocumentButtonLabel"; "required": false; }; "cancelButtonLabel": { "alias": "cancelButtonLabel"; "required": false; }; }, { "pdfSaved": "pdfSaved"; "cancelClick": "cancelClick"; }, never, never, false, never>;
}

declare class SignatureComponent {
    set content(content: ElementRef);
    title: string;
    saveButtonLabel: string;
    clearButtonLabel: string;
    save: EventEmitter<string>;
    showClass(): boolean;
    signature: SignaturePad;
    signatureCanvas: ElementRef;
    handleSave(event: MouseEvent): void;
    handleClear(event: MouseEvent): void;
    private _initCanvas;
    private _resizeSignatureCanvas;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignatureComponent, "co-signature", never, { "title": { "alias": "title"; "required": false; }; "saveButtonLabel": { "alias": "saveButtonLabel"; "required": false; }; "clearButtonLabel": { "alias": "clearButtonLabel"; "required": false; }; }, { "save": "save"; }, never, never, false, never>;
}

declare class SignaturesComponent {
    showFirstSignature: boolean;
    firstSignatureTitle: string;
    showSecondSignature: boolean;
    secondSignatureTitle: string;
    saveButtonLabel: string;
    clearButtonLabel: string;
    saveFirstSignature: EventEmitter<string>;
    saveSecondSignature: EventEmitter<string>;
    showClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignaturesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignaturesComponent, "co-signatures", never, { "showFirstSignature": { "alias": "showFirstSignature"; "required": false; }; "firstSignatureTitle": { "alias": "firstSignatureTitle"; "required": false; }; "showSecondSignature": { "alias": "showSecondSignature"; "required": false; }; "secondSignatureTitle": { "alias": "secondSignatureTitle"; "required": false; }; "saveButtonLabel": { "alias": "saveButtonLabel"; "required": false; }; "clearButtonLabel": { "alias": "clearButtonLabel"; "required": false; }; }, { "saveFirstSignature": "saveFirstSignature"; "saveSecondSignature": "saveSecondSignature"; }, never, never, false, never>;
}

declare class DocsignModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DocsignModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DocsignModule, [typeof DocsignComponent, typeof SignatureComponent, typeof SignaturesComponent], [typeof i2.CommonModule], [typeof DocsignComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DocsignModule>;
}

declare class SharedComponentsDictionaryService {
    get language(): string;
    private _dictionaryPromise;
    private _dictionaries;
    private _language;
    private readonly _placeholder;
    constructor();
    setDictionary(language: LanguageCode$1): Promise<void>;
    /**
     * Returns the localized text for the given dictionary key.
     * @param {string} key
     * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
     * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
     * @returns {string} The translated text for given dictionary key
     */
    get(key: string, upperCaseFirst?: boolean, ...replacementTexts: string[]): string;
    private _dictionaryLoaded;
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsDictionaryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SharedComponentsDictionaryService>;
}

declare class OptionsService {
    private _dictionary;
    optionsInitialized: BehaviorSubject<boolean>;
    set options(value: any);
    get options(): any;
    optionsLoaded: BehaviorSubject<boolean>;
    private _options;
    constructor(_dictionary: SharedComponentsDictionaryService);
    createSettingsFromObject(obj: any): Promise<void>;
    initialize(options: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OptionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OptionsService>;
}

declare class SharedConnectorService {
    private _optionsService;
    articleConnector: Articles;
    sharedConnector: Sharedapi;
    mainConnector: MainApi;
    relationConnector: RelationApi;
    private _boFactory;
    constructor(_optionsService: OptionsService);
    connect(): Promise<void>;
    getConfiguration(module: string, params: string[]): Promise<ObjectConfiguration[]>;
    getSequenceValue(seq: SequenceName): Promise<number>;
    getAllPrinters(): Promise<Printer[]>;
    getDefaultPrinter(reportId: number, layoutCode: string): Promise<string>;
    getSendMethods(): Promise<SendMethod$1[]>;
    getScreenConfigTree(): Promise<any>;
    getScreenConfigSubRubric(parentRubricId: number, configId: number, fixedKey: string): Promise<any>;
    getTagsFullTree(category: TagCategory$1, includeTags: boolean): Promise<TagTreeItem$1[]>;
    getComponentActivitiesWithoutRelationFiltering(table: TableName$1, key: string): Promise<Activity[]>;
    getRelationSmallObject(relationId: number): Promise<RelationSmallObject>;
    getWorkflowStatusForActivity(table: TableName$1, key: string, component: string): Promise<ActivityWorkflow>;
    insertActivity(activity: Activity): Promise<boolean>;
    insertWork(activity: Activity): Promise<Work>;
    insertRemark(activity: Activity): Promise<Remark>;
    insertTask(activity: Activity): Promise<Task>;
    updateActivity(activity: Activity): Promise<boolean>;
    deleteActivity(activity: Activity): Promise<boolean>;
    lockTask(id: number): Promise<boolean>;
    fireTrigger(workFlowProcessId: number, sequence: number, triggerId: number): Promise<ValidationResult>;
    fireGenericTrigger(workFlowProcessId: number, genericTransitionId: number, relationId: number): Promise<ValidationResult>;
    getJoinedTags(table: string, key: string): Promise<TagTreeItem$1[]>;
    getDocumentContent(id: number, thumbnail?: boolean): Promise<string>;
    getStockHistory(request: GetStockHistoryRequest): Promise<StockHistoryBo[]>;
    getStockInformation(data: ArticleStock): Promise<ArticleStock$1[]>;
    getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number>;
    getArticleFlat(sku: string): Promise<ArticleFlat>;
    searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]>;
    getStockManagementWarehouses(): Promise<StockManagementWarehouses[]>;
    getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]>;
    getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]>;
    updateArticleDetails(data: ArticleDetailsBo): Promise<boolean>;
    lockArticleDetails(data: ArticleStockManagement): Promise<boolean>;
    getStockStatus(): Promise<StockStatus[]>;
    getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransaction$1[]>;
    getStockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]>;
    getRelationListObjects(request: RelationRequest): Promise<RelationListObject[]>;
    getTaskCategories(): Promise<TaskCategory[]>;
    getActiveProcessesByTableAndKey(table: TableName$1, key: string): Promise<WorkflowProcess[]>;
    getDomainCollection(languageCode: string, domain: DomainName): Promise<CoDomainValue[]>;
    getRoleEmailAddressesByWorkflowCategoryAndKey(workflowCategory: string, key: string): Promise<RoleEmailaddress[]>;
    getEmailSenderByWorkflowCategoryAndKey(worlflowCategory: string, key: string): Promise<string>;
    getReportTemplates(reportTemplatesRequest: SelectReportTemplatesRequest): Promise<Report[]>;
    emailReport(emailJob: EmailJob): Promise<boolean>;
    emailActivity(request: EmailActivityRequest): Promise<boolean>;
    insertEmailHistoryForRemark(history: ActivityEmailHistory): Promise<boolean>;
    insertEmailHistoryForWork(history: ActivityEmailHistory): Promise<boolean>;
    insertEmailHistoryForTask(history: ActivityEmailHistory): Promise<boolean>;
    getWorkflowProcessInfoPerStatus(worlflowCategory: string): Promise<WorkflowProcessInfoPerStatus[]>;
    getHistoricActivities(table: TableName$1, key: string): Promise<Activity[]>;
    getComponentActivities(table: TableName$1, key: string): Promise<Activity[]>;
    getFormById(formId: number): Promise<Form>;
    getAllFormResponsesForTableAndKey(table: TableName$1, key: string): Promise<FormResponse[]>;
    insertFormResponse(formResponse: FormResponse): Promise<FormResponse>;
    updateFormResponse(formResponse: FormResponse): Promise<FormResponse>;
    lockFormResponse(formResponseId: number): Promise<boolean>;
    unlockFormResponse(formResponseId: number): Promise<boolean>;
    commit(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedConnectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SharedConnectorService>;
}

interface SendMethodParams {
    goodId?: number;
    warehouse?: number;
    location?: string;
    batch?: string;
    serial?: string;
    amount?: number;
    reportId?: number;
    printerName?: string;
    priceListCode?: string;
    goodIds?: number[];
    name?: string;
}

declare class StockService {
    private _sharedService;
    stockStickers: PrintStockStickers;
    printLayoutParams: SendMethodParams;
    constructor(_sharedService: SharedConnectorService);
    getStockHistory(data: GetStockHistoryRequest): Promise<StockHistoryBo[]>;
    getStockInformation(data: ArticleStock): Promise<ArticleStock$1[]>;
    getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]>;
    updateArticleDetails(data: ArticleDetailsBo): Promise<boolean>;
    getStockState(): Promise<StockStatus[]>;
    getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number>;
    getStockManagementWarehouses(): Promise<StockManagementWarehouses[]>;
    getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]>;
    getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransaction$1[]>;
    stockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]>;
    lockArticleDetails(data: ArticleStockManagement): Promise<boolean>;
    commit(): Promise<boolean>;
    getArticleFlat(sku: string): Promise<ArticleFlat>;
    searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StockService>;
}

/** AUTO GENERATED FILE. DO NOT CHANGE.. OR YOU WILL SUFFER THE CONSEQUENCES OF YOUR ACTIONS **/
declare enum Icon {
    Account = "account",
    AngleLeftSolid = "angle_left_solid",
    AngleRightSolid = "angle_right_solid",
    ArrowDown = "arrow_down",
    ArrowDownRegular = "arrow_down_regular",
    ArrowFatRight = "arrow_fat_right",
    ArrowLeftRoundOpen = "arrow_left_round_open",
    ArrowPointDown = "arrow_point_down",
    ArrowPointLeft = "arrow_point_left",
    ArrowPointRight = "arrow_point_right",
    ArrowPointUp = "arrow_point_up",
    ArrowRightArrowLeftRegular = "arrow_right_arrow_left_regular",
    AtSolid = "at_solid",
    BarcodeReadRegular = "barcode_read_regular",
    BellRegular = "bell_regular",
    BellSlashRegular = "bell_slash_regular",
    BringForwardRegular = "bring_forward_regular",
    Camera = "camera",
    CheckDuotone = "check_duotone",
    CheckRound = "check_round",
    CheckSolid = "check_solid",
    ChevronRightRegular = "chevron_right_regular",
    CircleCheckRegular = "circle_check_regular",
    ClockArrow = "clock_arrow",
    ClockRegular = "clock_regular",
    CommentRegular = "comment_regular",
    CrossSkinny = "cross_skinny",
    Cubes = "cubes",
    DeleteLeftRegular = "delete_left_regular",
    DeliveryTruck = "delivery_truck",
    DetailView = "detail_view",
    DiagramProjectRegular = "diagram_project_regular",
    Dropzone = "dropzone",
    EditPenRegular = "edit_pen_regular",
    Email = "email",
    EmailRegular = "email_regular",
    Employee = "employee",
    EnvelopeRegular = "envelope_regular",
    EyeRegular = "eye_regular",
    FileExportRegular = "file_export_regular",
    FileExportSolid = "file_export_solid",
    FileMagnifyingGlass = "file_magnifying_glass",
    FilePdfRegular = "file_pdf_regular",
    FilePdfSolid = "file_pdf_solid",
    FileSignatureRegular = "file_signature_regular",
    FoldersSharpRegular = "folders_sharp_regular",
    HouseBlankRegular = "house_blank_regular",
    IoneWorkflow = "ione_workflow",
    ListUlRegular = "list_ul_regular",
    Lock = "lock",
    MessageSmsRegular = "message_sms_regular",
    MessageSmsSolid = "message_sms_solid",
    MinusSimple = "minus_simple",
    Notification = "notification",
    PaperclipRegular = "paperclip_regular",
    PaperPlaneTopSolid = "paper_plane_top_solid",
    Pdf = "pdf",
    PersonDiggingRegular = "person_digging_regular",
    PinRoundOpen = "pin_round_open",
    PlusRegular = "plus_regular",
    PlusSimple = "plus_simple",
    Print = "print",
    PrintRegular = "print_regular",
    PrintSolid = "print_solid",
    RegularFileSignatureCirclePlus = "regular_file_signature_circle_plus",
    RemarkRoundOpen = "remark_round_open",
    ShareSolid = "share_solid",
    SignatureField = "signature_field",
    SolidBarcodeReadTag = "solid_barcode_read_tag",
    SquarePlusRegular = "square_plus_regular",
    TagRegular = "tag_regular",
    Task = "task",
    Trashbin = "trashbin",
    TrashCanRegular = "trash_can_regular",
    WorkInProgress = "work_in_progress",
    WorkInProgressRoundOpen = "work_in_progress_round_open",
    Xml = "xml",
    XSolid = "x_solid"
}

declare class IconCacheService {
    private _sanitizer;
    /**
     * All the icons as a large JSON object, from the all-icons.json file.
     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
     */
    get iconCache(): {
        [iconName: string]: SafeHtml;
    };
    private _iconCache;
    constructor(_sanitizer: DomSanitizer);
    getIcon(iconName: Icon | string): SafeHtml;
    getIconAsBase64(iconName: Icon): SafeHtml;
    getRawIcon(iconName: Icon): string;
    setIconCache(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IconCacheService>;
}

declare class StockModuleScreenConfigService extends BaseModuleScreenConfigService {
    private _sharedConnectorService;
    screenModuleName: string;
    constructor(_sharedConnectorService: SharedConnectorService);
    protected loadConfigForModule(params: string[], insertRights?: boolean): Promise<ObjectConfiguration[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockModuleScreenConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StockModuleScreenConfigService>;
}

declare class StockComponent implements OnDestroy, OnInit {
    iconCacheService: IconCacheService;
    private _stockService;
    private _optionsService;
    private _dictionary;
    private _changeDetector;
    private _connector;
    private _screenConfigService;
    readonly icons: typeof Icon;
    handleStickerClicked: EventEmitter<any>;
    set article(articleOrGoodId: ArticleExtended | number);
    articleWarehouse: any[];
    allWarehouses: any[];
    readonly okButtonClicked: EventEmitter<any>;
    readonly cancelButtonClicked: EventEmitter<any>;
    handleClick: EventEmitter<any>;
    handleTransactionClick: EventEmitter<any>;
    updateGridData: EventEmitter<ArticleDetailsBo[]>;
    showClass(): boolean;
    loaded: boolean;
    showStockInformationGrid: boolean;
    showStockTransfer: boolean;
    stockInformation: ArticleStock$1[];
    stockTransferArticle: ArticleStock$1;
    stockTransferArticleDetails: ArticleDetailsBo;
    articleExtended: ArticleExtended;
    articleDetailsInformation: ArticleStockManagement;
    articleFlat: ArticleFlat;
    stockHistory: StockHistoryBo[];
    allAvailableStock: number;
    allTechnicalStock: number;
    economicalStock: number;
    perceptibleStorage: number;
    showSendMethodDialog: boolean;
    articleStockState: number;
    warehouses: StockManagementWarehouses[];
    private _subscriptions;
    private _goodId;
    constructor(iconCacheService: IconCacheService, _stockService: StockService, _optionsService: OptionsService, _dictionary: SharedComponentsDictionaryService, _changeDetector: ChangeDetectorRef, _connector: SharedConnectorService, _screenConfigService: StockModuleScreenConfigService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    handleStockTransferClick(event: any): void;
    handleSendMethodClick(event: any): void;
    handleOkClick(data: ArticleDetailsBo): void;
    backToStock(goodId: number): void;
    getStockInformation(goodId: number): void;
    getArtStockStatus(): void;
    getStockManagementWarehouses(): void;
    private _handleSettingsLoaded;
    private _initConnection;
    loadData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockComponent, "co-stock", never, { "article": { "alias": "article"; "required": false; }; "articleWarehouse": { "alias": "articleWarehouse"; "required": false; }; "allWarehouses": { "alias": "allWarehouses"; "required": false; }; }, { "handleStickerClicked": "handleStickerClicked"; "okButtonClicked": "okButtonClicked"; "cancelButtonClicked": "cancelButtonClicked"; "handleClick": "handleClick"; "handleTransactionClick": "handleTransactionClick"; }, never, never, false, never>;
}

declare class StockInformationComponent {
    private _connectorService;
    image: string;
    set article(value: ArticleExtended);
    get article(): ArticleExtended;
    articleStockState: number;
    allAvailableStockInformation: number;
    allTechnicalStockInformation: number;
    economicalStock: number;
    perceptibleStorage: number;
    private _article;
    constructor(_connectorService: SharedConnectorService);
    private _prepareImage;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockInformationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockInformationComponent, "co-stock-information", never, { "article": { "alias": "article"; "required": false; }; "articleStockState": { "alias": "articleStockState"; "required": false; }; "allAvailableStockInformation": { "alias": "allAvailableStockInformation"; "required": false; }; "allTechnicalStockInformation": { "alias": "allTechnicalStockInformation"; "required": false; }; "economicalStock": { "alias": "economicalStock"; "required": false; }; "perceptibleStorage": { "alias": "perceptibleStorage"; "required": false; }; }, {}, never, never, false, never>;
}

interface CoDropDownListFields {
    text: string;
    value: string;
}

declare class StockInformationGridComponent {
    iconCacheService: IconCacheService;
    private _stockService;
    readonly icons: typeof Icon;
    stock: StockInformationGridComponent;
    articleStockInformation: ArticleStock$1[];
    stockLocationData: ArticleStock$1[];
    stockHistoryInformation: StockHistoryBo[];
    article: ArticleExtended;
    readonly transferIconClicked: EventEmitter<ArticleStock$1>;
    readonly historyClicked: EventEmitter<any>;
    readonly cancelButtonClicked: EventEmitter<any>;
    readonly okButtonClicked: EventEmitter<any>;
    image: string;
    show: boolean;
    hideOrShowLocationTab: boolean;
    showStockHistory: boolean;
    showSendMethodDialog: boolean;
    inOrderInformation: ArticleTransaction$1[];
    orderInformation: ArticleTransaction$1[];
    hideOrShowTabs: boolean;
    dataWareHouseCode: StockManagementWarehouses[];
    dataWareHouseFields: CoDropDownListFields;
    dataLocationFields: CoDropDownListFields;
    selectedWarehouse: any;
    selectedLocation: StockLocation;
    stockLocations: StockLocation[];
    articleStockSearchInfo: ArticleStock;
    articleDetails: ArticleDetailsBo[];
    selectedArticleDetailsData: ArticleDetailsBo;
    showChangeStockDetails: boolean;
    articleDetailsInformation: ArticleStockManagement;
    sendMethod: SendMethodType[];
    tabs: string[];
    activeTab: string;
    get activeTabText(): string;
    constructor(iconCacheService: IconCacheService, _stockService: StockService);
    handleTabClick(tabData: any): void;
    onLocationClick(data: ArticleStock$1): void;
    handleHistoryClick(): void;
    backToStockInformation(): void;
    handleStockTransferClick(event: any): void;
    handleBackToStockClick(): Promise<void>;
    openSendMethodDialog(data: any): void;
    printStockStickers(): void;
    onOkClick(): void;
    onCancelClick(): void;
    openDialogClick(data: any): void;
    getArticleDetails(data: any): void;
    getStockManagementWarehouses(data: ArticleStock$1): void;
    onSelectWarehouse(event: any): void;
    getInOrderData(): Promise<void>;
    getOrderData(): Promise<void>;
    onLocationDropdownClick(): void;
    onLocationSelected(location: any): void;
    onOkClickSendLocations(): Promise<void>;
    onCancelClickSendLocations(): void;
    amountInStockChanged(data: any): void;
    lockSelectedRow(row: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockInformationGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockInformationGridComponent, "co-stock-information-grid", never, { "articleStockInformation": { "alias": "articleStockInformation"; "required": false; }; "stockLocationData": { "alias": "stockLocationData"; "required": false; }; "stockHistoryInformation": { "alias": "stockHistoryInformation"; "required": false; }; "article": { "alias": "article"; "required": false; }; }, { "transferIconClicked": "transferIconClicked"; "historyClicked": "historyClicked"; "cancelButtonClicked": "cancelButtonClicked"; "okButtonClicked": "okButtonClicked"; }, never, never, false, never>;
}

declare class StockTransferComponent implements AfterViewInit {
    private _stockService;
    iconCacheService: IconCacheService;
    private _changeDetector;
    stockSticker: PrintStockStickers$1;
    article: ArticleStock$1;
    articleToTransfer: ArticleDetailsBo;
    allWarehouses: any[];
    showStockTransfer: boolean;
    selectedArticleDetailsData: ArticleDetailsBo;
    articleFlat: ArticleFlat;
    articleDetailsInformation: ArticleStockManagement;
    selectedWarehouse: StockManagementWarehouses;
    selectedLocationNo: string;
    articleStockInfo: ArticleDetailsBo[];
    stockLocations: StockLocation[];
    handleClick: EventEmitter<number>;
    handleStickerClicked: EventEmitter<any>;
    updateGridData: EventEmitter<ArticleDetailsBo[]>;
    showStockTransferChange: EventEmitter<boolean>;
    showSendMethodDialog: boolean;
    transferFull: boolean;
    warehouses: StockManagementWarehouses[];
    stockState: StockStatus[];
    locations: StockLocation[];
    stockStatus: StockStatus[];
    readonly icons: typeof Icon;
    constructor(_stockService: StockService, iconCacheService: IconCacheService, _changeDetector: ChangeDetectorRef);
    ngAfterViewInit(): void;
    handleOkClick(data: ArticleDetailsBo): void;
    onCloseClick(): void;
    handleSelectedWarehouse(event: StockManagementWarehouses): void;
    handleSelectedLocation(event: StockLocation): void;
    handleSelectedStockState(event: StockStatus): void;
    handleStickerClick(): void;
    getStockManagementWarehouses(): void;
    getStockManagementLocations(): void;
    getStockState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockTransferComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockTransferComponent, "co-stock-transfer", never, { "stockSticker": { "alias": "stockSticker"; "required": false; }; "article": { "alias": "article"; "required": false; }; "articleToTransfer": { "alias": "articleToTransfer"; "required": false; }; "allWarehouses": { "alias": "allWarehouses"; "required": false; }; "showStockTransfer": { "alias": "showStockTransfer"; "required": false; }; "selectedArticleDetailsData": { "alias": "selectedArticleDetailsData"; "required": false; }; "articleFlat": { "alias": "articleFlat"; "required": false; }; "articleDetailsInformation": { "alias": "articleDetailsInformation"; "required": false; }; "selectedWarehouse": { "alias": "selectedWarehouse"; "required": false; }; "selectedLocationNo": { "alias": "selectedLocationNo"; "required": false; }; "articleStockInfo": { "alias": "articleStockInfo"; "required": false; }; "stockLocations": { "alias": "stockLocations"; "required": false; }; }, { "handleClick": "handleClick"; "handleStickerClicked": "handleStickerClicked"; "updateGridData": "updateGridData"; "showStockTransferChange": "showStockTransferChange"; }, never, never, false, never>;
}

declare class StockChangeAmountComponent implements AfterViewInit {
    private _stockService;
    selectedArticleDetailsData: ArticleDetailsBo;
    readonly closeStockChangeAmount: EventEmitter<any>;
    stockState: StockStatus[];
    stockStateDropdownField: CoDropDownListFields;
    constructor(_stockService: StockService);
    ngAfterViewInit(): void;
    closeDialogClick(): void;
    handleOkClick(data: ArticleDetailsBo): Promise<void>;
    handleCancelClick(): void;
    getStockState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockChangeAmountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockChangeAmountComponent, "co-stock-change-amount", never, { "selectedArticleDetailsData": { "alias": "selectedArticleDetailsData"; "required": false; }; }, { "closeStockChangeAmount": "closeStockChangeAmount"; }, never, never, false, never>;
}

declare enum SharedCfgName {
    Overview = "overview",
    OverviewDetails = "overviewDetails",
    StockForecast = "stockForecast",
    InventoryForecast = "inventoryForecast",
    InventoryDetails = "inventoryDetails",
    InOrder = "inOrder",
    History = "history",
    HistoryStock = "historyStock",
    HistoryOrderStock = "historyOrderStock",
    HistoryOrderCommission = "historyOrderCommission",
    HistoryOrder = "historyOrder",
    HistoryAssign = "historyAssign"
}

declare class StockTabComponent {
    readonly sharedCfgName: typeof SharedCfgName;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    articleStockInformation: ArticleStock$1[];
    locationClicked: EventEmitter<string>;
    onLocationClick(data: ArticleStock$1): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockTabComponent, "co-stock-tab", never, { "articleStockInformation": { "alias": "articleStockInformation"; "required": false; }; }, { "locationClicked": "locationClicked"; }, never, never, false, never>;
}

declare abstract class BaseStockComponent implements OnInit {
    goodId: number;
    ngOnInit(): void;
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStockComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStockComponent, never, never, { "goodId": { "alias": "goodId"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OrderTabComponent extends BaseStockComponent {
    iconCacheService: IconCacheService;
    private _stockService;
    private _changeDetector;
    readonly icons: typeof Icon;
    stockLocations: StockLocation[];
    showStockTransfer: boolean;
    allWarehouses: any[];
    articleFlat: ArticleFlat;
    locationClicked: EventEmitter<ArticleStock$1>;
    readonly transferIconClicked: EventEmitter<ArticleStock$1>;
    readonly sendMethodDialogClicked: EventEmitter<PrintPriceStickers>;
    handleStickerClicked: EventEmitter<any>;
    showStockTransferChange: EventEmitter<boolean>;
    handleTransactionClick: EventEmitter<any>;
    data: ArticleTransaction$1[];
    selectedRow: ArticleTransaction$1 | null;
    articleDetails: ArticleDetailsBo;
    showSendMethodDialog: boolean;
    constructor(iconCacheService: IconCacheService, _stockService: StockService, _changeDetector: ChangeDetectorRef);
    openSendMethodDialog(data: any): void;
    handleStockTransferClick(): void;
    onRowSelected(row: ArticleTransaction$1 | {}): void;
    onShowStockTransferChange(update: boolean): void;
    protected getData(): Promise<void>;
    handleTransactionNavigationClick(event: Event, transNr: string): void;
    updateData(): void;
    handleTransactionNavigation(transNr: string): void;
    getGridData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrderTabComponent, "co-order-tab", never, { "showStockTransfer": { "alias": "showStockTransfer"; "required": false; }; "allWarehouses": { "alias": "allWarehouses"; "required": false; }; "articleFlat": { "alias": "articleFlat"; "required": false; }; }, { "locationClicked": "locationClicked"; "transferIconClicked": "transferIconClicked"; "sendMethodDialogClicked": "sendMethodDialogClicked"; "handleStickerClicked": "handleStickerClicked"; "showStockTransferChange": "showStockTransferChange"; "handleTransactionClick": "handleTransactionClick"; }, never, never, false, never>;
}

interface Tab {
    title: string;
    active: boolean;
    clickHandler?: () => void;
    cfg: SharedCfgName;
}

declare class StockTabsComponent implements OnInit {
    private _stockService;
    private _dictionaryService;
    private _changeDetector;
    private _stockScreenConfigService;
    readonly icons: typeof Icon;
    stockInformation: ArticleStock$1[];
    article: ArticleExtended;
    articleFlat: ArticleFlat;
    showStockTransfer: boolean;
    warehouses: StockManagementWarehouses[];
    readonly transferIconClicked: EventEmitter<ArticleStock$1>;
    readonly sendMethodDialogClicked: EventEmitter<PrintPriceStickers>;
    handleTransactionClick: EventEmitter<any>;
    selectedWarehouse: StockManagementWarehouses;
    tabs: Tab[];
    historyTabs: Tab[];
    constructor(_stockService: StockService, _dictionaryService: SharedComponentsDictionaryService, _changeDetector: ChangeDetectorRef, _stockScreenConfigService: StockModuleScreenConfigService);
    ngOnInit(): void;
    onShowStockTransferChange(show: boolean): void;
    handleLocationClicked(data: string): void;
    handleWarehouseSelected(event: StockManagementWarehouses): void;
    getStockData(warehouse: StockManagementWarehouses): void;
    wareHouseForCode(code: number): StockManagementWarehouses;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockTabsComponent, "co-stock-tabs", never, { "stockInformation": { "alias": "stockInformation"; "required": false; }; "article": { "alias": "article"; "required": false; }; "articleFlat": { "alias": "articleFlat"; "required": false; }; "showStockTransfer": { "alias": "showStockTransfer"; "required": false; }; "warehouses": { "alias": "warehouses"; "required": false; }; }, { "transferIconClicked": "transferIconClicked"; "sendMethodDialogClicked": "sendMethodDialogClicked"; "handleTransactionClick": "handleTransactionClick"; }, never, never, false, never>;
}

declare class StockHistoryTabsComponent {
    readonly icons: typeof Icon;
    selectedTab: number;
    stockInformation: ArticleStock$1[];
    static ɵfac: i0.ɵɵFactoryDeclaration<StockHistoryTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockHistoryTabsComponent, "co-stock-history-tabs", never, { "stockInformation": { "alias": "stockInformation"; "required": false; }; }, {}, never, never, false, never>;
}

declare class OrderStockTabComponent extends BaseStockComponent {
    iconCacheService: IconCacheService;
    private _stockService;
    readonly icons: typeof Icon;
    data: ArticleTransaction$1[];
    constructor(iconCacheService: IconCacheService, _stockService: StockService);
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderStockTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrderStockTabComponent, "co-order-stock-tab", never, {}, {}, never, never, false, never>;
}

declare class StockLocationComponent extends BaseStockComponent implements OnInit, OnDestroy {
    iconCacheService: IconCacheService;
    private _stockService;
    private _changeDetector;
    readonly icons: typeof Icon;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    set warehouseNo(value: number);
    get warehouseNo(): number;
    articleStockInformation: ArticleStock$1[];
    articleWarehouse: any[];
    allWarehouses: any[];
    showStockTransfer: boolean;
    articleFlat: ArticleFlat;
    dataWareHouseCode: StockManagementWarehouses[];
    readonly transferIconClicked: EventEmitter<ArticleStock$1>;
    readonly sendMethodDialogClicked: EventEmitter<PrintPriceStickers>;
    showStockTransferChange: EventEmitter<boolean>;
    handleStickerClicked: EventEmitter<any>;
    articleDetails: ArticleDetailsBo;
    showConfirmationDialog: boolean;
    newStockLine: boolean;
    deleteStockLine: boolean;
    cannotDelete: boolean;
    showConfirmStockRow: boolean;
    articleDetailsInformation: ArticleStockManagement;
    stockStatus: StockStatus[];
    selectedArticleDetailsData: ArticleDetailsBo;
    selectedLocationNo: string;
    data: ArticleDetailsBo[];
    selectedWarehouse: StockManagementWarehouses;
    stockLocations: StockLocation[];
    selectedRow: ArticleDetailsBo | null;
    showSendMethodDialog: boolean;
    private _warehouseNo;
    private _subs;
    constructor(iconCacheService: IconCacheService, _stockService: StockService, _changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onShowStockTransferChange(show: boolean): void;
    onLocationDropdownClick(): void;
    locationChanged(row: ArticleDetailsBo, event: StockLocation): void;
    amountInStockChanged(data: any): void;
    openSendMethodDialog(data: any): void;
    handleStockTransferClick(event: ArticleDetailsBo): void;
    onRowSelected(row: ArticleDetailsBo | {}): void;
    onOkClickSendLocations(row: ArticleDetailsBo): void;
    handleDeleteRow(row: ArticleDetailsBo): void;
    handleAddRow(): void;
    handleOkClick(): void;
    handleStockStatusChange(status: StockStatus): void;
    handleStockStatusRemarkChange(remark: string): void;
    disabled(): boolean;
    statusForId(id: number): StockStatus;
    locationForNumber(number: number): StockLocation;
    locationForDescription(locationNo: string): string;
    protected getData(): Promise<void>;
    private _getWarehouseLocations;
    handleTogglePopup(): void;
    handlePopupSave(saved: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockLocationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockLocationComponent, "co-stock-location", never, { "warehouseNo": { "alias": "warehouseNo"; "required": false; }; "articleStockInformation": { "alias": "articleStockInformation"; "required": false; }; "articleWarehouse": { "alias": "articleWarehouse"; "required": false; }; "allWarehouses": { "alias": "allWarehouses"; "required": false; }; "showStockTransfer": { "alias": "showStockTransfer"; "required": false; }; "articleFlat": { "alias": "articleFlat"; "required": false; }; "dataWareHouseCode": { "alias": "dataWareHouseCode"; "required": false; }; "selectedWarehouse": { "alias": "selectedWarehouse"; "required": false; }; }, { "transferIconClicked": "transferIconClicked"; "sendMethodDialogClicked": "sendMethodDialogClicked"; "showStockTransferChange": "showStockTransferChange"; "handleStickerClicked": "handleStickerClicked"; }, never, never, false, never>;
}

declare class StockHistoryComponent extends BaseStockComponent {
    iconCacheService: IconCacheService;
    private _stockService;
    readonly icons: typeof Icon;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    stockHistoryInformation: StockHistoryBo[];
    articleGoodId: string;
    data: StockHistoryBo[];
    constructor(iconCacheService: IconCacheService, _stockService: StockService);
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockHistoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockHistoryComponent, "co-stock-history", never, { "stockHistoryInformation": { "alias": "stockHistoryInformation"; "required": false; }; "articleGoodId": { "alias": "articleGoodId"; "required": false; }; }, {}, never, never, false, never>;
}

declare class OrderSupplyStockHistoryComponent extends BaseStockComponent {
    private _stockService;
    readonly icons: typeof Icon;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    data: StockHistoryBo[];
    constructor(_stockService: StockService);
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderSupplyStockHistoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrderSupplyStockHistoryComponent, "co-order-supply-stock-history", never, {}, {}, never, never, false, never>;
}

declare class OrderCommissionStockHistoryComponent extends BaseStockComponent {
    private _stockService;
    readonly icons: typeof Icon;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    data: StockHistoryBo[];
    constructor(_stockService: StockService);
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderCommissionStockHistoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrderCommissionStockHistoryComponent, "co-order-stock-commission-history", never, {}, {}, never, never, false, never>;
}

declare class OrderStockHistoryComponent extends BaseStockComponent {
    private _stockService;
    readonly icons: typeof Icon;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    data: StockHistoryBo[];
    constructor(_stockService: StockService);
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderStockHistoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrderStockHistoryComponent, "co-order-stock-history", never, {}, {}, never, never, false, never>;
}

declare class SharedEventService {
    readonly salesOrderNavigation: Subject<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SharedEventService>;
}

declare class AllocationStockHistoryComponent extends BaseStockComponent {
    private _stockService;
    sharedEventService: SharedEventService;
    readonly icons: typeof Icon;
    readonly SimpleGridColumnTemplateType: typeof SimpleGridColumnTemplateType;
    data: StockHistoryBo[];
    constructor(_stockService: StockService, sharedEventService: SharedEventService);
    protected getData(): Promise<void>;
    handleTransactionNavigation(docNr: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AllocationStockHistoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AllocationStockHistoryComponent, "co-allocation-stock-history", never, {}, {}, never, never, false, never>;
}

declare class StockPrognoseComponent extends BaseStockComponent {
    iconCacheService: IconCacheService;
    private _stockService;
    readonly icons: typeof Icon;
    set warehouseNo(value: number);
    get warehouseNo(): number;
    data: StockForecast[];
    private _warehouseNo;
    constructor(iconCacheService: IconCacheService, _stockService: StockService);
    protected getData(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockPrognoseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockPrognoseComponent, "co-stock-prognose", never, { "warehouseNo": { "alias": "warehouseNo"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StockLocationPopupComponent {
    iconCacheService: IconCacheService;
    private _stockService;
    private _changeDetector;
    readonly icons: typeof Icon;
    private _selectedLocationNo;
    editingRow: boolean;
    showConfirmationDialog: boolean;
    newStockLine: boolean;
    deleteStockLine: boolean;
    selectedArticleDetailsData: ArticleDetailsBo;
    articleFlat: ArticleFlat;
    articleDetailsInformation: ArticleStockManagement;
    selectedWarehouse: StockManagementWarehouses;
    set selectedLocationNo(locationNo: string);
    get selectedLocationNo(): string;
    articleStockInfo: ArticleDetailsBo[];
    togglePopupEvent: EventEmitter<void>;
    saveEvent: EventEmitter<boolean>;
    updateGridData: EventEmitter<ArticleDetailsBo[]>;
    stockLocations: StockLocation[];
    stockStatus: StockStatus[];
    stockBelow: boolean;
    validationMessage: string;
    constructor(iconCacheService: IconCacheService, _stockService: StockService, _changeDetector: ChangeDetectorRef);
    statusForId(id: number): 0 | StockStatus;
    handleStockStatusChange(status: StockStatus): void;
    handleStockStatusRemarkChange(remark: string): void;
    amountInStockChanged(data: any): void;
    disabled(): boolean;
    handleOkClick(): void;
    togglePopup(): void;
    getStockLocations(): void;
    locationForNumber(number: string): "" | StockLocation;
    locationChanged(event: StockLocation): void;
    handleStockChange(): void;
    newDate(): Date;
    private validateForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockLocationPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockLocationPopupComponent, "co-stock-location-popup", never, { "editingRow": { "alias": "editingRow"; "required": false; }; "showConfirmationDialog": { "alias": "showConfirmationDialog"; "required": false; }; "newStockLine": { "alias": "newStockLine"; "required": false; }; "deleteStockLine": { "alias": "deleteStockLine"; "required": false; }; "selectedArticleDetailsData": { "alias": "selectedArticleDetailsData"; "required": false; }; "articleFlat": { "alias": "articleFlat"; "required": false; }; "articleDetailsInformation": { "alias": "articleDetailsInformation"; "required": false; }; "selectedWarehouse": { "alias": "selectedWarehouse"; "required": false; }; "selectedLocationNo": { "alias": "selectedLocationNo"; "required": false; }; "articleStockInfo": { "alias": "articleStockInfo"; "required": false; }; "stockLocations": { "alias": "stockLocations"; "required": false; }; "stockStatus": { "alias": "stockStatus"; "required": false; }; }, { "togglePopupEvent": "togglePopupEvent"; "saveEvent": "saveEvent"; "updateGridData": "updateGridData"; }, never, never, false, never>;
}

declare class StockTransferAllocatedComponent implements AfterViewInit {
    private _stockService;
    iconCacheService: IconCacheService;
    private _changeDetector;
    dialogService: CoreDialogService;
    dict: SharedComponentsDictionaryService;
    stockSticker: PrintStockStickers$1;
    article: ArticleStock$1;
    articleToTransfer: ArticleDetailsBo;
    articleTransaction: ArticleTransaction$1;
    allWarehouses: any[];
    showStockTransfer: boolean;
    selectedArticleDetailsData: ArticleDetailsBo;
    articleFlat: ArticleFlat;
    articleDetailsInformation: ArticleStockManagement;
    selectedWarehouse: StockManagementWarehouses;
    selectedLocationNo: string;
    articleStockInfo: ArticleDetailsBo[];
    stockLocations: StockLocation[];
    handleClick: EventEmitter<number>;
    handleStickerClicked: EventEmitter<any>;
    updateGridData: EventEmitter<ArticleDetailsBo[]>;
    showStockTransferChange: EventEmitter<boolean>;
    showSendMethodDialog: boolean;
    warehouses: StockManagementWarehouses[];
    articleDetails: ArticleDetailsBo[];
    transferFull: boolean;
    stockState: StockStatus[];
    locations: StockLocation[];
    stockStatus: StockStatus[];
    readonly icons: typeof Icon;
    constructor(_stockService: StockService, iconCacheService: IconCacheService, _changeDetector: ChangeDetectorRef, dialogService: CoreDialogService, dict: SharedComponentsDictionaryService);
    ngAfterViewInit(): void;
    onCloseClick(): void;
    handleOkClick(articleToTransfer: ArticleDetailsBo): void;
    handleSelectedWarehouse(event: StockManagementWarehouses): void;
    handleSelectedLocation(event: StockLocation): void;
    handleSelectedStockState(event: StockStatus): void;
    handleStickerClick(): void;
    getStockManagementWarehouses(): void;
    getStockManagementLocations(warehouseNo: number): void;
    getStockState(): void;
    handleInputNumberChange(number: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StockTransferAllocatedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockTransferAllocatedComponent, "co-stock-transfer-allocated", never, { "stockSticker": { "alias": "stockSticker"; "required": false; }; "article": { "alias": "article"; "required": false; }; "articleToTransfer": { "alias": "articleToTransfer"; "required": false; }; "articleTransaction": { "alias": "articleTransaction"; "required": false; }; "allWarehouses": { "alias": "allWarehouses"; "required": false; }; "showStockTransfer": { "alias": "showStockTransfer"; "required": false; }; "selectedArticleDetailsData": { "alias": "selectedArticleDetailsData"; "required": false; }; "articleFlat": { "alias": "articleFlat"; "required": false; }; "articleDetailsInformation": { "alias": "articleDetailsInformation"; "required": false; }; "selectedWarehouse": { "alias": "selectedWarehouse"; "required": false; }; "selectedLocationNo": { "alias": "selectedLocationNo"; "required": false; }; "articleStockInfo": { "alias": "articleStockInfo"; "required": false; }; "stockLocations": { "alias": "stockLocations"; "required": false; }; }, { "handleClick": "handleClick"; "handleStickerClicked": "handleStickerClicked"; "updateGridData": "updateGridData"; "showStockTransferChange": "showStockTransferChange"; }, never, never, false, never>;
}

declare class SendMethodService {
    reportingDocumentPrintSignDocBaseRequestChanged: Subject<ReportingDocumentPrintSignDocBaseRequest>;
    reportingDocumentEmailSignDocBaseRequestChanged: Subject<ReportingDocumentEmailSignDocBaseRequest>;
    reportingDocumentPdfBaseRequestChanged: Subject<ReportingDocumentPdfBaseRequest>;
    reportingDocumentCombinedBaseRequestChanged: Subject<PrintPurchaseOrderForTransactionOrderWithoutLinesRequest>;
    printerNotSet: Subject<boolean>;
    set reportingDocumentPrintSignDocBaseRequest(value: ReportingDocumentPrintSignDocBaseRequest);
    get reportingDocumentPrintSignDocBaseRequest(): ReportingDocumentPrintSignDocBaseRequest;
    set reportingDocumentEmailSignDocBaseRequest(value: ReportingDocumentEmailSignDocBaseRequest);
    get reportingDocumentEmailSignDocBaseRequest(): ReportingDocumentEmailSignDocBaseRequest;
    set reportingDocumentPdfBaseRequest(value: ReportingDocumentPdfBaseRequest);
    get reportingDocumentPdfBaseRequest(): ReportingDocumentPdfBaseRequest;
    set reportingDocumentCombinedBaseRequest(value: PrintPurchaseOrderForTransactionOrderWithoutLinesRequest);
    get reportingDocumentCombinedBaseRequest(): PrintPurchaseOrderForTransactionOrderWithoutLinesRequest;
    selectedEmailAddresses: string[];
    activePrinter: string;
    private _reportingDocumentPrintSignDocBaseRequest;
    private _reportingDocumentEmailSignDocBaseRequest;
    private _reportingDocumentPdfBaseRequest;
    private _reportingDocumentCombinedRequest;
    removeEmailAddress(address: string): void;
    addEmailAddress(address: string): void;
    private _updateEmailAddresses;
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SendMethodService>;
}

declare class SendMethod {
    code: SendMethodType;
    description: string;
    icon: string;
    constructor(code: SendMethodType, description: string, icon: string);
}

declare class AdditionalFileButtonComponent {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    isActive: boolean;
    request: ReportingDocumentEmailSignDocBaseRequest | ReportingDocumentPrintSignDocBaseRequest;
    additionalFileContents: any;
    additionalFileName: string;
    additionalFileChangeEvent: EventEmitter<CoDocument>;
    openPdfProgrammatically: EventEmitter<void>;
    openForSave(): void;
    showClass(): boolean;
    show: boolean;
    constructor(iconCacheService: IconCacheService);
    handleToggleDialog(): void;
    toggleActive(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdditionalFileButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdditionalFileButtonComponent, "co-additional-file-button", never, { "request": { "alias": "request"; "required": false; }; "additionalFileContents": { "alias": "additionalFileContents"; "required": false; }; "additionalFileName": { "alias": "additionalFileName"; "required": false; }; }, { "additionalFileChangeEvent": "additionalFileChangeEvent"; "openPdfProgrammatically": "openPdfProgrammatically"; }, never, never, false, never>;
}

declare enum LanguageCode {
    Dutch = "nl-NL",
    English = "en-GB",
    German = "de-DE",
    French = "fr-FR"
}

declare class SharedService {
    protected readonly locale: LanguageCode;
    protected options: OptionsService;
    protected connector: SharedConnectorService;
    protected dictionary: SharedComponentsDictionaryService;
    constructor(locale: LanguageCode, options: OptionsService, connector: SharedConnectorService, dictionary: SharedComponentsDictionaryService);
    init(options: any): Promise<void>;
    connect(): Promise<void>;
    getSequenceValue(seq: SequenceName): Promise<number>;
    getAllPrinters(): Promise<Printer[]>;
    getDefaultPrinter(reportId: number, layoutCode: string): Promise<string>;
    getSendMethods(): Promise<SendMethod$1[]>;
    getScreenConfigTree(): Promise<any>;
    getScreenConfigSubRubric(parentRubricId: number, configId: number, fixedKey: string): Promise<any>;
    getTagsFullTree(category: TagCategory$1, includeTags?: boolean): Promise<TagTreeItem$1[]>;
    getJoinedTags(table: string, key: string): Promise<TagTreeItem$1[]>;
    getDocumentContent(docId: number, thumbnail?: boolean): Promise<string>;
    getComponentActivitiesWithoutRelationFiltering(table: TableName$1, key: string): Promise<Activity[]>;
    getRelationSmallObject(relationId: number): Promise<RelationSmallObject>;
    getWorkflowStatusForActivity(table: TableName$1, key: string, component: string): Promise<ActivityWorkflow>;
    insertActivity(activity: Activity): Promise<boolean>;
    insertWork(activity: Activity): Promise<Work>;
    insertRemark(activity: Activity): Promise<Remark>;
    insertTask(activity: Activity): Promise<Task>;
    updateActivity(activity: Activity): Promise<boolean>;
    deleteActivity(activity: Activity): Promise<boolean>;
    lockTask(id: number): Promise<boolean>;
    commit(): Promise<boolean>;
    canFireTrigger(activity: Activity, task: Task): boolean;
    fireTrigger(workFlowProcessId: number, sequence: number, triggerId: number): Promise<ValidationResult>;
    fireGenericTrigger(workFlowProcessId: number, genericTransitionId: number, relationId: number): Promise<ValidationResult>;
    getRelationListObjects(request: RelationRequest): Promise<RelationListObject[]>;
    getTaskCategories(): Promise<TaskCategory[]>;
    getActiveProcessesByTableAndKey(table: TableName$1, key: string): Promise<WorkflowProcess[]>;
    getDomainCollection(languageCode: string, domainName: DomainName): Promise<CoDomainValue[]>;
    getRoleEmailAddressesByWorkflowCategoryAndKey(workflowCategory: string, key: string): Promise<RoleEmailaddress[]>;
    getEmailSenderByWorkflowCategoryAndKey(workflowCategory: string, key: string): Promise<string>;
    getDefaultEmailReportTemplatesForBranch(branchNr: string, reportType: ReportType): Promise<Report[]>;
    emailViaTemplate(template: Report, emailTo: string, emailBcc: string, reply: string, subject?: string, message?: string, attachments?: CoEmailAttachment[], parameters?: object): Promise<boolean>;
    private _createEmailJob;
    emailActivity(emailActivityRequest: EmailActivityRequest): Promise<CoDocument | boolean>;
    insertEmailHistoryForRemark(history: ActivityEmailHistory): Promise<boolean>;
    insertEmailHistoryForWork(history: ActivityEmailHistory): Promise<boolean>;
    insertEmailHistoryForTask(history: ActivityEmailHistory): Promise<boolean>;
    getWorkflowProcessInfoPerStatus(workflowCategory: string): Promise<WorkflowProcessInfoPerStatus[]>;
    getActivities(table: TableName$1, key: string): Promise<Activity[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SharedService>;
}

declare class SendMethodPrinterComponent implements OnInit {
    sendMethodService: SendMethodService;
    iconCacheService: IconCacheService;
    private _sharedService;
    showClass(): boolean;
    additionalFileButtonRef: AdditionalFileButtonComponent;
    printerList: Printer[];
    layouts: ReportLayoutSelectionPrint[];
    isPrinterLayoutsEnabled: boolean;
    isAdditionalDocEnabled: boolean;
    hideSignatureBtn: boolean;
    additionalFileContents: any;
    additionalFileName: string;
    layoutCode: LayoutCode;
    additionalFileChangeEvent: EventEmitter<CoDocument>;
    useLocalPrint: EventEmitter<boolean>;
    copiesAmountChange: EventEmitter<number>;
    protected readonly icons: typeof Icon;
    localPrint: boolean;
    defaultPrinter: Printer;
    copiesAmount: number;
    constructor(sendMethodService: SendMethodService, iconCacheService: IconCacheService, _sharedService: SharedService);
    ngOnInit(): void;
    handleDefaultPrinterUserChange(checked: boolean): void;
    handleLocalPrintChange(checked: boolean): void;
    handleDefaultPrinterAllUsersChange(checked: boolean): void;
    openAdditionalFileDialog(): void;
    isAdditionalFileActive(): boolean;
    updatePrinter(request: ReportingDocumentBaseRequest): void;
    handleCopiesAmountChange(amount: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodPrinterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SendMethodPrinterComponent, "co-send-method-printer", never, { "printerList": { "alias": "printerList"; "required": false; }; "layouts": { "alias": "layouts"; "required": false; }; "isPrinterLayoutsEnabled": { "alias": "isPrinterLayoutsEnabled"; "required": false; }; "isAdditionalDocEnabled": { "alias": "isAdditionalDocEnabled"; "required": false; }; "hideSignatureBtn": { "alias": "hideSignatureBtn"; "required": false; }; "additionalFileContents": { "alias": "additionalFileContents"; "required": false; }; "additionalFileName": { "alias": "additionalFileName"; "required": false; }; "layoutCode": { "alias": "layoutCode"; "required": false; }; }, { "additionalFileChangeEvent": "additionalFileChangeEvent"; "useLocalPrint": "useLocalPrint"; "copiesAmountChange": "copiesAmountChange"; }, never, never, false, never>;
}

declare class EmailAddressViewmodel {
    checked: boolean;
    emailAddress: string;
    constructor(checked: boolean, emailAddress: string);
}

declare class SendMethodEmailComponent implements OnInit {
    sendMethodService: SendMethodService;
    additionalFileButtonRef: AdditionalFileButtonComponent;
    emailAddresses: string[];
    layouts: ReportLayoutSelectionEmail[];
    additionalFileContents: any;
    additionalFileName: string;
    emailUnsignedPossible: boolean;
    isAdditionalDocEnabled: boolean;
    loadDefaultPrinterName: EventEmitter<number>;
    additionalFileChangeEvent: EventEmitter<CoDocument>;
    showClass(): boolean;
    emailAddressViewmodels: EmailAddressViewmodel[];
    constructor(sendMethodService: SendMethodService);
    ngOnInit(): void;
    handleCheckedEmail(emailAddressViewmodel: EmailAddressViewmodel): void;
    openAdditionalFileDialog(): void;
    isAdditionalFileActive(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodEmailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SendMethodEmailComponent, "co-send-method-email", never, { "emailAddresses": { "alias": "emailAddresses"; "required": false; }; "layouts": { "alias": "layouts"; "required": false; }; "additionalFileContents": { "alias": "additionalFileContents"; "required": false; }; "additionalFileName": { "alias": "additionalFileName"; "required": false; }; "emailUnsignedPossible": { "alias": "emailUnsignedPossible"; "required": false; }; "isAdditionalDocEnabled": { "alias": "isAdditionalDocEnabled"; "required": false; }; }, { "loadDefaultPrinterName": "loadDefaultPrinterName"; "additionalFileChangeEvent": "additionalFileChangeEvent"; }, never, never, false, never>;
}

declare const sendMethodsWithIcon: SendMethod[];
declare class SendMethodDialogComponent implements OnInit, OnDestroy {
    iconCacheService: IconCacheService;
    private _sendMethodService;
    readonly icons: typeof Icon;
    navigationItems: ElementRef;
    faxItems: ElementRef;
    printItems: ElementRef;
    emailItems: ElementRef;
    ediItems: ElementRef;
    emailTemplateItems: ElementRef;
    smsItems: ElementRef;
    webServiceItems: ElementRef;
    pdfItems: ElementRef;
    combinePrintAndEmail: ElementRef;
    printerComponentRef: SendMethodPrinterComponent;
    emailComponentRef: SendMethodEmailComponent;
    printerList: Printer[];
    reportingDocumentPrintRequest: ReportingDocumentPrintSignDocBaseRequest;
    reportingDocumentEmailRequest: ReportingDocumentEmailSignDocBaseRequest;
    reportingDocumentPdfRequest: ReportingDocumentPdfBaseRequest;
    reportingDocumentCombinedRequest: PrintPurchaseOrderForTransactionOrderWithoutLinesRequest;
    emailLayouts: ReportLayoutSelectionEmail[];
    printLayouts: ReportLayoutSelectionPrint[];
    headerTitle: string;
    emailAddresses: string[];
    defaultSendMethod: string;
    visibleMethods: SendMethodType[] | string[];
    isDocSignEnabled: boolean;
    docSign: boolean;
    hideSignatureBtn: boolean;
    isPrinterLayoutsEnabled: boolean;
    isAdditionalDocEnabled: boolean;
    additionalFileName: string;
    additionalFileContents: any;
    pdfDoc: any;
    disablePdfPreview: boolean;
    emailUnsignedPossible: boolean;
    showPDFPreview: boolean;
    showAdditionalChecks: boolean;
    showLocalPrint: boolean;
    layoutCode: LayoutCode;
    reportingDocumentPrintRequestChange: EventEmitter<ReportingDocumentPrintSignDocBaseRequest>;
    reportingDocumentEmailRequestChange: EventEmitter<ReportingDocumentEmailSignDocBaseRequest>;
    reportingDocumentPdfRequestChange: EventEmitter<ReportingDocumentPdfBaseRequest>;
    reportingDocumentCombinedRequestChange: EventEmitter<PrintPurchaseOrderForTransactionOrderWithoutLinesRequest>;
    startSignatureClicked: EventEmitter<any>;
    closeClick: EventEmitter<MouseEvent>;
    okClick: EventEmitter<string | ProcessPrintRequest>;
    additionalFileChangeEvent: EventEmitter<CoDocument>;
    showFilePreview: EventEmitter<number>;
    loadDefaultPrinterName: EventEmitter<number>;
    showClass(): boolean;
    sendMethods: SendMethod[];
    activeSendMethod: SendMethod;
    startUp: boolean;
    showFax: boolean;
    showPrint: boolean;
    showEmail: boolean;
    showEdi: boolean;
    showSms: boolean;
    showEmailTemplate: boolean;
    showWebservice: boolean;
    showPdf: boolean;
    showCombinePrintAndEmail: boolean;
    additionalFileHasBeenSaved: boolean;
    disableOkButton: boolean;
    private _subscriptions;
    private _localPrint;
    constructor(iconCacheService: IconCacheService, _sendMethodService: SendMethodService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    handleSignatureStart(): void;
    handleAdditionalFileSaved(file: CoDocument): void;
    handleUseLocalPrint(localPrint: boolean): void;
    handleOkClick(): void;
    handleCancelClick(): void;
    private _continueHandleOkClick;
    handleSendMethodClick(sendMethod: SendMethod): void;
    createPdfPreview(): void;
    closePdfPreview(): void;
    handleCopiesAmountChange(amount: number): void;
    private _initDefaultSendMethod;
    private _selectDefaultSendMethod;
    private _prepareVisibleMethods;
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SendMethodDialogComponent, "co-send-method-dialog", never, { "printerList": { "alias": "printerList"; "required": false; }; "reportingDocumentPrintRequest": { "alias": "reportingDocumentPrintRequest"; "required": false; }; "reportingDocumentEmailRequest": { "alias": "reportingDocumentEmailRequest"; "required": false; }; "reportingDocumentPdfRequest": { "alias": "reportingDocumentPdfRequest"; "required": false; }; "reportingDocumentCombinedRequest": { "alias": "reportingDocumentCombinedRequest"; "required": false; }; "emailLayouts": { "alias": "emailLayouts"; "required": false; }; "printLayouts": { "alias": "printLayouts"; "required": false; }; "headerTitle": { "alias": "headerTitle"; "required": false; }; "emailAddresses": { "alias": "emailAddresses"; "required": false; }; "defaultSendMethod": { "alias": "defaultSendMethod"; "required": false; }; "visibleMethods": { "alias": "visibleMethods"; "required": false; }; "isDocSignEnabled": { "alias": "isDocSignEnabled"; "required": false; }; "docSign": { "alias": "docSign"; "required": false; }; "hideSignatureBtn": { "alias": "hideSignatureBtn"; "required": false; }; "isPrinterLayoutsEnabled": { "alias": "isPrinterLayoutsEnabled"; "required": false; }; "isAdditionalDocEnabled": { "alias": "isAdditionalDocEnabled"; "required": false; }; "additionalFileName": { "alias": "additionalFileName"; "required": false; }; "additionalFileContents": { "alias": "additionalFileContents"; "required": false; }; "pdfDoc": { "alias": "pdfDoc"; "required": false; }; "disablePdfPreview": { "alias": "disablePdfPreview"; "required": false; }; "emailUnsignedPossible": { "alias": "emailUnsignedPossible"; "required": false; }; "showPDFPreview": { "alias": "showPDFPreview"; "required": false; }; "showAdditionalChecks": { "alias": "showAdditionalChecks"; "required": false; }; "showLocalPrint": { "alias": "showLocalPrint"; "required": false; }; "layoutCode": { "alias": "layoutCode"; "required": false; }; }, { "reportingDocumentPrintRequestChange": "reportingDocumentPrintRequestChange"; "reportingDocumentEmailRequestChange": "reportingDocumentEmailRequestChange"; "reportingDocumentPdfRequestChange": "reportingDocumentPdfRequestChange"; "reportingDocumentCombinedRequestChange": "reportingDocumentCombinedRequestChange"; "startSignatureClicked": "startSignatureClicked"; "closeClick": "closeClick"; "okClick": "okClick"; "additionalFileChangeEvent": "additionalFileChangeEvent"; "showFilePreview": "showFilePreview"; "loadDefaultPrinterName": "loadDefaultPrinterName"; }, never, ["[extra-content]"], false, never>;
}

declare class LayoutSelectionComponent implements OnInit {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    set request(value: ReportingDocumentBaseRequest);
    useDefault: boolean;
    label: string;
    layouts: ReportLayoutSelectionBase[];
    requestChange: EventEmitter<ReportingDocumentBaseRequest>;
    showClass(): boolean;
    currentLayout: ReportLayoutSelectionBase;
    private _request;
    constructor(iconCacheService: IconCacheService);
    ngOnInit(): void;
    handleSelectLayout(reportLayout: ReportLayoutSelectionBase): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSelectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutSelectionComponent, "co-layout-selection", never, { "request": { "alias": "request"; "required": false; }; "useDefault": { "alias": "useDefault"; "required": false; }; "label": { "alias": "label"; "required": false; }; "layouts": { "alias": "layouts"; "required": false; }; }, { "requestChange": "requestChange"; }, never, never, false, never>;
}

declare class SharedLocalizePipe implements PipeTransform {
    private _dictionaryService;
    constructor(_dictionaryService: SharedComponentsDictionaryService);
    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedLocalizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SharedLocalizePipe, "sharedLocalize", false>;
}

declare class SharedComponentsTranslationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsTranslationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedComponentsTranslationModule, [typeof SharedLocalizePipe], never, [typeof SharedLocalizePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedComponentsTranslationModule>;
}

declare class LayoutSelectionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSelectionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LayoutSelectionModule, [typeof LayoutSelectionComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i3.ListOfValuesModule, typeof SharedComponentsTranslationModule], [typeof LayoutSelectionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LayoutSelectionModule>;
}

declare class SignatureButtonComponent {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    request: ReportingDocumentEmailSignDocBaseRequest | ReportingDocumentPrintSignDocBaseRequest;
    emailUnsignedPossible: boolean;
    emailUnsigned: boolean;
    showClass(): boolean;
    constructor(iconCacheService: IconCacheService);
    handleToggleSignature(): void;
    emailUnsignedChanged(checked: boolean): void;
    protected readonly ReportingDocumentEmailSignDocBaseRequest: typeof ReportingDocumentEmailSignDocBaseRequest;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignatureButtonComponent, "co-signature-button", never, { "request": { "alias": "request"; "required": false; }; "emailUnsignedPossible": { "alias": "emailUnsignedPossible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SignatureButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SignatureButtonModule, [typeof SignatureButtonComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i3.InputCheckboxModule], [typeof SignatureButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SignatureButtonModule>;
}

declare class CustomPdfDialogComponent implements OnInit, AfterViewInit {
    iconCacheService: IconCacheService;
    private _sanitizer;
    readonly icons: typeof Icon;
    showClass(): boolean;
    pdfBody: ElementRef;
    additionalFileContents: any;
    additionalFileName: string;
    closePDFDialog: EventEmitter<any>;
    additionalFileChangeEvent: EventEmitter<CoDocument>;
    canvas: HTMLCanvasElement;
    context: CanvasRenderingContext2D;
    signaturePads: {
        [key: string]: SignaturePad;
    };
    signatureCanvases: {
        [key: string]: ElementRef;
    };
    fileBody: any;
    fileStyle: string;
    showLoader: boolean;
    private enableLocalPreview;
    constructor(iconCacheService: IconCacheService, _sanitizer: DomSanitizer);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private _processAdditionalFileContents;
    extractStyleParts(html: string): string[];
    removeStyleAndScriptTags(html: string): string;
    extractBodyContents(html: string): string[];
    private _isLocalhost;
    handleSaveClicked(): Promise<void>;
    dataURItoBlob(dataURI: any): File;
    handleClear(): void;
    private _resizeSignatureCanvas;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomPdfDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomPdfDialogComponent, "co-custom-pdf-dialog", never, { "additionalFileContents": { "alias": "additionalFileContents"; "required": false; }; "additionalFileName": { "alias": "additionalFileName"; "required": false; }; }, { "closePDFDialog": "closePDFDialog"; "additionalFileChangeEvent": "additionalFileChangeEvent"; }, never, never, false, never>;
}

declare class CustomPdfDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomPdfDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CustomPdfDialogModule, [typeof CustomPdfDialogComponent], [typeof i3.IconModule, typeof i3.CoDialogModule, typeof i2.CommonModule, typeof i3.ButtonModule, typeof SharedComponentsTranslationModule, typeof i3.LoaderModule], [typeof CustomPdfDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CustomPdfDialogModule>;
}

declare class AdditionalFileButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AdditionalFileButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AdditionalFileButtonModule, [typeof AdditionalFileButtonComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof CustomPdfDialogModule], [typeof AdditionalFileButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AdditionalFileButtonModule>;
}

declare class SendMethodEmailModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodEmailModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SendMethodEmailModule, [typeof SendMethodEmailComponent], [typeof i2.CommonModule, typeof i3.InputCheckboxModule, typeof LayoutSelectionModule, typeof i3.IconModule, typeof SignatureButtonModule, typeof SharedComponentsTranslationModule, typeof AdditionalFileButtonModule], [typeof SendMethodEmailComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SendMethodEmailModule>;
}

declare class PrinterSelectionComponent {
    sendMethodService: SendMethodService;
    iconService: IconCacheService;
    readonly icons: typeof Icon;
    printers: Printer[];
    set defaultPrinter(printer: Printer);
    required: boolean;
    showClass(): boolean;
    printerModel: Printer;
    constructor(sendMethodService: SendMethodService, iconService: IconCacheService);
    handlePrinterClicked(printer: Printer): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrinterSelectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PrinterSelectionComponent, "co-printer-selection", never, { "printers": { "alias": "printers"; "required": false; }; "defaultPrinter": { "alias": "defaultPrinter"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PrinterSelectionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PrinterSelectionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PrinterSelectionModule, [typeof PrinterSelectionComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i3.ListOfValuesModule, typeof SharedComponentsTranslationModule], [typeof PrinterSelectionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PrinterSelectionModule>;
}

declare class SendMethodPrinterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodPrinterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SendMethodPrinterModule, [typeof SendMethodPrinterComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof LayoutSelectionModule, typeof PrinterSelectionModule, typeof i3.InputCheckboxModule, typeof SignatureButtonModule, typeof CustomPdfDialogModule, typeof AdditionalFileButtonModule, typeof i3.ListOfValuesModule, typeof SharedComponentsTranslationModule, typeof i3.InputNumberPickerModule], [typeof SendMethodPrinterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SendMethodPrinterModule>;
}

declare class SendMethodPdfComponent {
    sendMethodService: SendMethodService;
    layouts: ReportLayoutSelectionPrint[];
    showFilePreview: EventEmitter<number>;
    loadDefaultPrinterName: EventEmitter<number>;
    showClass(): boolean;
    constructor(sendMethodService: SendMethodService);
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodPdfComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SendMethodPdfComponent, "co-send-method-pdf", never, { "layouts": { "alias": "layouts"; "required": false; }; }, { "showFilePreview": "showFilePreview"; "loadDefaultPrinterName": "loadDefaultPrinterName"; }, never, never, false, never>;
}

declare class SendMethodPdfModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodPdfModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SendMethodPdfModule, [typeof SendMethodPdfComponent], [typeof i2.CommonModule, typeof LayoutSelectionModule, typeof SignatureButtonModule, typeof SharedComponentsTranslationModule], [typeof SendMethodPdfComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SendMethodPdfModule>;
}

interface OverruleOptions {
    code: number;
    description: string;
}
declare class SendMethodCombinePrintEmailComponent implements OnInit {
    sendMethodService: SendMethodService;
    private _sharedService;
    emailLayouts: ReportLayoutSelectionEmail[];
    printLayouts: ReportLayoutSelectionPrint[];
    printerList: Printer[];
    pdfDoc: any;
    emailUnsignedPossible: boolean;
    showAdditionalChecks: boolean;
    showLocalPrint: boolean;
    layoutCode: LayoutCode;
    showFilePreview: EventEmitter<void>;
    useLocalPrint: EventEmitter<boolean>;
    showClass(): boolean;
    localPrint: boolean;
    defaultPrinter: Printer;
    reportForPrinting: ReportingDocumentBaseRequest;
    reportForEmailing: ReportingDocumentBaseRequest;
    overruleOptions: OverruleOptions[];
    overruledEmail: OverruleOptions;
    overruledEdi: OverruleOptions;
    overruledPrint: OverruleOptions;
    constructor(sendMethodService: SendMethodService, _sharedService: SharedService);
    ngOnInit(): void;
    setDefaultPrinterFromRequest(request: PrintPurchaseOrderForTransactionOrderWithoutLinesRequest): void;
    handleLocalPrintChange(checked: boolean): void;
    handleDefaultPrinterUserChange(checked: boolean): void;
    handleDefaultPrinterAllUsersChange(checked: boolean): void;
    updateReportForPrinting(event: ReportingDocumentBaseRequest): void;
    updateReportForEmailing(event: ReportingDocumentBaseRequest): void;
    updateUseRelationSpecificReports(event: boolean): void;
    updateUseRelationSpecificSendMethods(event: boolean): void;
    updateEmailOverrule(event: OverruleOptions): void;
    updateEdiOverrule(event: OverruleOptions): void;
    updatePrintOverrule(event: OverruleOptions): void;
    private _updateRequest;
    private _updatePrinterBasedOnReportId;
    private _updatePrinterOnRequest;
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodCombinePrintEmailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SendMethodCombinePrintEmailComponent, "co-send-method-combine-print-email", never, { "emailLayouts": { "alias": "emailLayouts"; "required": false; }; "printLayouts": { "alias": "printLayouts"; "required": false; }; "printerList": { "alias": "printerList"; "required": false; }; "pdfDoc": { "alias": "pdfDoc"; "required": false; }; "emailUnsignedPossible": { "alias": "emailUnsignedPossible"; "required": false; }; "showAdditionalChecks": { "alias": "showAdditionalChecks"; "required": false; }; "showLocalPrint": { "alias": "showLocalPrint"; "required": false; }; "layoutCode": { "alias": "layoutCode"; "required": false; }; }, { "showFilePreview": "showFilePreview"; "useLocalPrint": "useLocalPrint"; }, never, ["[extra-content-pass]"], false, never>;
}

declare class SendMethodCombinePrintEmailModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodCombinePrintEmailModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SendMethodCombinePrintEmailModule, [typeof SendMethodCombinePrintEmailComponent], [typeof i2.CommonModule, typeof LayoutSelectionModule, typeof PrinterSelectionModule, typeof SharedComponentsTranslationModule, typeof i3.InputCheckboxModule, typeof i3.ListOfValuesModule], [typeof SendMethodCombinePrintEmailComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SendMethodCombinePrintEmailModule>;
}

declare class PreviewPdfDialogComponent implements OnInit {
    iconCacheService: IconCacheService;
    sanitizer: DomSanitizer;
    showClass(): boolean;
    set pdfDoc(value: string);
    get pdfDoc(): string;
    closePDFDialog: EventEmitter<any>;
    readonly icons: typeof Icon;
    pdfUrl: string;
    private _pdfDoc;
    constructor(iconCacheService: IconCacheService, sanitizer: DomSanitizer);
    ngOnInit(): void;
    private _generatePdf;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewPdfDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewPdfDialogComponent, "co-preview-pdf-dialog", never, { "pdfDoc": { "alias": "pdfDoc"; "required": false; }; }, { "closePDFDialog": "closePDFDialog"; }, never, never, false, never>;
}

declare class PreviewPdfDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewPdfDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PreviewPdfDialogModule, [typeof PreviewPdfDialogComponent], [typeof i3.IconModule, typeof i3.CoDialogModule, typeof i2.CommonModule, typeof i3.ButtonModule, typeof SharedComponentsTranslationModule], [typeof PreviewPdfDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PreviewPdfDialogModule>;
}

declare class SendMethodDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SendMethodDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SendMethodDialogModule, [typeof SendMethodDialogComponent], [typeof i2.CommonModule, typeof i3.CoDialogModule, typeof i3.IconModule, typeof SendMethodEmailModule, typeof SendMethodPrinterModule, typeof i3.ButtonModule, typeof SendMethodPdfModule, typeof SendMethodCombinePrintEmailModule, typeof SharedComponentsTranslationModule, typeof PreviewPdfDialogModule], [typeof SendMethodDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SendMethodDialogModule>;
}

declare class TabBarComponent {
    private _stockService;
    wareHouseLabel: string;
    wareHouseSearchLabel: string;
    tabs: Tab[];
    secondaryTabs: Tab[];
    ActivateSecondaryTabs: boolean;
    dataWareHouseCode: StockManagementWarehouses[];
    article: any;
    showWarehouseSelection: boolean;
    warehouseSelected: EventEmitter<StockManagementWarehouses>;
    selectedWarehouse: StockManagementWarehouses;
    constructor(_stockService: StockService);
    selectTab(tab: Tab): void;
    selectSecondaryTab(secondaryTab: Tab): void;
    onSelectWarehouse(event: StockManagementWarehouses): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarComponent, "co-tab-bar", never, { "wareHouseLabel": { "alias": "wareHouseLabel"; "required": false; }; "wareHouseSearchLabel": { "alias": "wareHouseSearchLabel"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "secondaryTabs": { "alias": "secondaryTabs"; "required": false; }; "ActivateSecondaryTabs": { "alias": "ActivateSecondaryTabs"; "required": false; }; "dataWareHouseCode": { "alias": "dataWareHouseCode"; "required": false; }; "article": { "alias": "article"; "required": false; }; "showWarehouseSelection": { "alias": "showWarehouseSelection"; "required": false; }; "selectedWarehouse": { "alias": "selectedWarehouse"; "required": false; }; }, { "warehouseSelected": "warehouseSelected"; }, never, never, false, never>;
}

declare class TabBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TabBarModule, [typeof TabBarComponent], [typeof i2.CommonModule, typeof i3.ListOfValuesModule, typeof i3.ScreenConfigurationModule, typeof i3.ButtonModule], [typeof TabBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TabBarModule>;
}

interface StatusbarData {
    label: string;
    percentage?: number;
    count?: number;
    totalCount?: number;
    category?: string;
}
declare class StatusbarComponent {
    private _elementRef;
    private _overlayService;
    set statusbarData(value: StatusbarData[]);
    get statusbarData(): StatusbarData[];
    defaultColor: '#e0e0e0';
    focusedStatusIndex: number;
    statusbarClick: EventEmitter<void>;
    statusClicked: EventEmitter<string>;
    showClass(): boolean;
    handleClick(event: MouseEvent): void;
    popupShowing: boolean;
    private _statusbarData;
    private _statusbarPopupComponentRef;
    constructor(_elementRef: ElementRef, _overlayService: OverlayService);
    handleShowPopup(event: MouseEvent): void;
    handleHidePopup(): void;
    adjustTooHighPercentages(): void;
    handleStatusClicked(label: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusbarComponent, "co-statusbar", never, { "statusbarData": { "alias": "statusbarData"; "required": false; }; "defaultColor": { "alias": "defaultColor"; "required": false; }; "focusedStatusIndex": { "alias": "focusedStatusIndex"; "required": false; }; }, { "statusbarClick": "statusbarClick"; "statusClicked": "statusClicked"; }, never, never, false, never>;
}

declare enum GaugeColor$1 {
    Disabled = "#e7e7e7",
    Lowest = "#E0E0E0",
    Low = "#fff7b8",
    MediumLow = "#ffe367",
    MediumHigh = "#ffc15b",
    High = "#F88952",
    Highest = "#5FDCB3"
}
declare class StatusbarPopupComponent implements OnInit {
    set content(content: any);
    defaultColor: '#e0e0e0';
    statusbarData: StatusbarData[];
    parentForOverlay: ElementRef;
    statusClicked: EventEmitter<string>;
    showClass: boolean;
    doughnutCharts: ElementRef[];
    ngOnInit(): void;
    private _prepareChartData;
    private _getColor;
    private _getDataForChart;
    handleStatusClicked(label: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusbarPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusbarPopupComponent, "co-statusbar-popup", never, { "defaultColor": { "alias": "defaultColor"; "required": false; }; "statusbarData": { "alias": "statusbarData"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; }, { "statusClicked": "statusClicked"; }, never, never, false, never>;
}

declare enum GaugeColor {
    Disabled = "#e7e7e7",
    Lowest = "#E0E0E0",
    Low = "#fff7b8",
    MediumLow = "#ffe367",
    MediumHigh = "#ffc15b",
    High = "#F88952",
    Highest = "#5FDCB3"
}

declare class CoLinearGaugeComponent {
    set value(value: number);
    get value(): number;
    count: number;
    showClass(): boolean;
    private _value;
    color: GaugeColor;
    getStyle(): string;
    private _setColor;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoLinearGaugeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CoLinearGaugeComponent, "co-linear-gauge", never, { "value": { "alias": "value"; "required": false; }; "count": { "alias": "count"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CoLinearGaugeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoLinearGaugeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoLinearGaugeModule, [typeof CoLinearGaugeComponent], [typeof i2.CommonModule], [typeof CoLinearGaugeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoLinearGaugeModule>;
}

declare class StatusbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StatusbarModule, [typeof StatusbarComponent, typeof StatusbarPopupComponent], [typeof i2.CommonModule, typeof CoLinearGaugeModule, typeof i3.ClickoutsideModule, typeof i3.OverlayModule], [typeof StatusbarComponent, typeof StatusbarPopupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StatusbarModule>;
}

declare class StockStatusbarComponent {
    value: number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<StockStatusbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StockStatusbarComponent, "co-stock-statusbar", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StockStatusbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StockStatusbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StockStatusbarModule, [typeof StockStatusbarComponent], [typeof i2.CommonModule], [typeof StockStatusbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StockStatusbarModule>;
}

declare class StockModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StockModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StockModule, [typeof StockComponent, typeof StockInformationComponent, typeof StockInformationGridComponent, typeof StockTransferComponent, typeof StockChangeAmountComponent, typeof StockTabComponent, typeof OrderTabComponent, typeof StockTabsComponent, typeof StockHistoryTabsComponent, typeof OrderStockTabComponent, typeof StockLocationComponent, typeof StockHistoryComponent, typeof OrderSupplyStockHistoryComponent, typeof OrderCommissionStockHistoryComponent, typeof OrderStockHistoryComponent, typeof AllocationStockHistoryComponent, typeof StockPrognoseComponent, typeof StockLocationPopupComponent, typeof StockTransferAllocatedComponent], [typeof i3.ButtonModule, typeof i2.CommonModule, typeof i3.InputRadioButtonModule, typeof i3.SimpleGridModule, typeof i3.ImageModule, typeof i3.InputTextModule, typeof SendMethodDialogModule, typeof i3.IconModule, typeof i3.InputNumberPickerModule, typeof i3.CoDialogWizardModule, typeof i3.InputTextareaModule, typeof TabBarModule, typeof i3.CoDialogModule, typeof StatusbarModule, typeof StockStatusbarModule, typeof i3.ListOfValuesModule, typeof SharedComponentsTranslationModule, typeof i3.PopupModule, typeof i3.InputDatePickerModule, typeof i3.ScreenConfigurationModule], [typeof StockComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StockModule>;
}

declare class KeyPadComponent {
    iconCacheService: IconCacheService;
    icons: typeof Icon;
    set model(value: number);
    get model(): number;
    showValue: boolean;
    resetModelOnInit: boolean;
    emitModelChangeOnEnter: boolean;
    modelChange: EventEmitter<number>;
    internalModelChange: EventEmitter<string>;
    enterClick: EventEmitter<void>;
    showClass(): boolean;
    handleKeyDown(event: KeyboardEvent): void;
    private readonly _validKeyMap;
    private _init;
    constructor(iconCacheService: IconCacheService);
    set internalModel(value: string);
    get internalModel(): string;
    isNegative: boolean;
    private _model;
    private _internalModel;
    private _maxCharacters;
    handleMinusClick(event: MouseEvent | KeyboardEvent): void;
    handleClearClick(event: MouseEvent | KeyboardEvent): void;
    handleBsClick(event: MouseEvent | KeyboardEvent): void;
    handleButtonClick(chr: string): void;
    handleEnterClick(event: MouseEvent | KeyboardEvent): void;
    private _updateModel;
    private _keyDown;
    private _isEnter;
    private _isMinus;
    private _isEscape;
    private _isBackspace;
    private _emitModelChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyPadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KeyPadComponent, "co-key-pad", never, { "model": { "alias": "model"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "resetModelOnInit": { "alias": "resetModelOnInit"; "required": false; }; "emitModelChangeOnEnter": { "alias": "emitModelChangeOnEnter"; "required": false; }; }, { "modelChange": "modelChange"; "internalModelChange": "internalModelChange"; "enterClick": "enterClick"; }, never, never, false, never>;
}

declare class KeyPadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyPadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<KeyPadModule, [typeof KeyPadComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i3.ResponsiveTextModule], [typeof KeyPadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<KeyPadModule>;
}

declare class LayoutSwitcherComponent {
    iconCacheService: IconCacheService;
    readonly icon: typeof Icon;
    showClass(): boolean;
    layoutItems: string[];
    layoutSwitchEmit: EventEmitter<string>;
    get activeIndex(): number;
    set activeIndex(index: number);
    showMaskSidebar: boolean;
    private _activeIndex;
    constructor(iconCacheService: IconCacheService);
    toggleMaskSidebar(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutSwitcherComponent, "co-layout-switcher", never, { "layoutItems": { "alias": "layoutItems"; "required": false; }; }, { "layoutSwitchEmit": "layoutSwitchEmit"; }, never, never, false, never>;
}

declare class LayoutSwitcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSwitcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LayoutSwitcherModule, [typeof LayoutSwitcherComponent], [typeof i2.CommonModule, typeof i3.IconModule], [typeof LayoutSwitcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LayoutSwitcherModule>;
}

declare enum CalendarView {
    DayView = "DAY",
    DaysAround = "DAYS_AROUND",
    ThreeDaysView = "THREE_DAYS_AROUND",
    WeekView = "WEEK",
    WeekSelectView = "WEEK_SELECT",
    WeekWorkView = "WORK_WEEK",
    WeekPlanningView = "WEEK_PLANNING",
    MonthView = "MONTH"
}

declare class TimeWindow extends BusinessObject {
    key: string;
    dateTimeFrom: Date;
    dateTimeTo: Date;
    proposedPlanDateTimeFrom: Date;
    proposedPlanDateTimeTo: Date;
    proposedDriver: any;
    impact: string;
    followUpTimeSlots: TimeWindow[];
    additionalProperties: any;
}

declare class AgendaEvent {
    id: number;
    description: string;
    checked: boolean;
    showCheckbox: boolean;
    draggable: boolean;
    from: Date;
    to: Date;
    date: Date;
    dayPartNo: number;
    fromString: string;
    toString: string;
    fromToRepresentation: string;
    timeWindow: TimeWindow;
    customObject: Object;
}

declare class AgendaEventPerDay {
    date: Date;
    events: AgendaEvent[];
}

declare class DatePlanningComponent {
    private _changeDetector;
    private renderer;
    dayStart: ElementRef;
    calendarNavigation: boolean;
    customEventObject: boolean;
    showButton: boolean;
    selectedDate: Date;
    firstAvailableDate: Date;
    buttonLabel: string;
    eventsPerDay: AgendaEventPerDay[];
    view: CalendarView;
    viewSelection: boolean;
    readonly eventChecked: EventEmitter<any>;
    readonly selectedDateChange: EventEmitter<Date>;
    readonly rangeChange: EventEmitter<Date>;
    readonly viewChange: EventEmitter<CalendarView>;
    readonly buttonClick: EventEmitter<MouseEvent>;
    showClass: boolean;
    days: Date[];
    private _selectedDate;
    constructor(_changeDetector: ChangeDetectorRef, renderer: Renderer2);
    doChangeSelectedDate(date: Date, rangeChanged?: boolean): void;
    doChangeView(view: CalendarView): void;
    scrollToDayStart(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePlanningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatePlanningComponent, "co-date-planning", never, { "calendarNavigation": { "alias": "calendarNavigation"; "required": false; }; "customEventObject": { "alias": "customEventObject"; "required": false; }; "showButton": { "alias": "showButton"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "firstAvailableDate": { "alias": "firstAvailableDate"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "eventsPerDay": { "alias": "eventsPerDay"; "required": false; }; "view": { "alias": "view"; "required": false; }; "viewSelection": { "alias": "viewSelection"; "required": false; }; }, { "eventChecked": "eventChecked"; "selectedDateChange": "selectedDateChange"; "rangeChange": "rangeChange"; "viewChange": "viewChange"; "buttonClick": "buttonClick"; }, never, never, false, never>;
}

declare class CalendarAllYearsComponent implements OnInit {
    year: number;
    readonly yearChange: EventEmitter<number>;
    years: number[];
    constructor();
    ngOnInit(): void;
    private _determineStart;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarAllYearsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarAllYearsComponent, "calendar-all-years", never, { "year": { "alias": "year"; "required": false; }; }, { "yearChange": "yearChange"; }, never, never, false, never>;
}

declare class CalendarAllMonthsComponent implements OnInit {
    month: number;
    shortDescriptions: boolean;
    monthChange: EventEmitter<number>;
    months: string[];
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarAllMonthsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarAllMonthsComponent, "calendar-all-months", never, { "month": { "alias": "month"; "required": false; }; "shortDescriptions": { "alias": "shortDescriptions"; "required": false; }; }, { "monthChange": "monthChange"; }, never, never, false, never>;
}

declare class CalendarHeaderComponent implements DoCheck {
    iconCacheService: IconCacheService;
    selectedDate: Date;
    readonly selectedDateChange: EventEmitter<Date>;
    readonly icons: typeof Icon;
    showMonthYearSelect: boolean;
    expanded: boolean;
    currentMonth: number;
    currentYear: number;
    selectedMonth: number;
    selectedYear: number;
    constructor(iconCacheService: IconCacheService);
    ngDoCheck(): void;
    subMonth(): void;
    addMonth(): void;
    hideMonthYearSelection(): void;
    setNewMonth(month: number): void;
    setNewYear(year: number): void;
    changeMonthYear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarHeaderComponent, "calendar-header", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; }, { "selectedDateChange": "selectedDateChange"; }, never, never, false, never>;
}

declare class CalendarComponent {
    view: CalendarView;
    selectedDate: Date;
    days: Date[];
    daysChange: EventEmitter<Date[]>;
    selectedDateChange: EventEmitter<Date>;
    constructor();
    changeSelectedDate(date: Date): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarComponent, "calendar", never, { "view": { "alias": "view"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "days": { "alias": "days"; "required": false; }; }, { "daysChange": "daysChange"; "selectedDateChange": "selectedDateChange"; }, never, never, false, never>;
}

type DateStamp = {
    day: number;
    inMonth: boolean;
    timestamp: number;
    week: number;
    selected: boolean;
};
declare class CalendarViewComponent {
    private readonly _locale;
    set view(value: CalendarView);
    get view(): CalendarView;
    set selectedDate(value: Date);
    get selectedDate(): Date;
    selectedDateChange: EventEmitter<Date>;
    trackByStamp: Function;
    trackByWeek: Function;
    weekDayLabel: string[];
    weeks: DateStamp[][];
    private _selectedDate;
    private _view;
    constructor(_locale: LanguageCode);
    onDateClick(date: DateStamp): void;
    private _setLabels;
    private _prepareWeeks;
    private _selectDays;
    private _resetSelection;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarViewComponent, "calendar-view", never, { "view": { "alias": "view"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; }, { "selectedDateChange": "selectedDateChange"; }, never, never, false, never>;
}

declare class Weekday {
    inView: boolean;
    weekdayDay: number;
    weekdayMonthShort: string;
    weekdayMonthLong: string;
    weekdayYear: number;
    date: Date;
    weekdayShort: string;
    weekdayLong: string;
    description: string;
    newMonth: boolean;
    weekdaySelected: boolean;
    datesByTheHour: Date[];
    events: AgendaEvent[];
}

declare class Day {
    day: number;
    date: Date;
    description: string;
    datesByTheHour: Date[];
    events: AgendaEvent[];
}

declare class AgendaHeaderComponent implements OnInit, OnDestroy, AfterContentChecked {
    private readonly _locale;
    private _elementRef;
    private _renderer;
    private _ngZone;
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    readonly viewTypes: typeof CalendarView;
    private readonly scrollbarWidth;
    today: Date;
    set selectedDate(value: Date);
    get selectedDate(): Date;
    view: CalendarView;
    set firstAvailableDate(value: Date);
    get firstAvailableDate(): Date;
    set eventsPerDay(value: AgendaEventPerDay[]);
    viewSelection: boolean;
    viewChange: EventEmitter<CalendarView>;
    selectedDateChange: EventEmitter<Date>;
    rangeChange: EventEmitter<Date>;
    weekDays: Weekday[];
    day: Day;
    showBackButton: boolean;
    private _selectedDate;
    private _firstAvailableDate;
    private _eventsPerDay;
    constructor(_locale: LanguageCode, _elementRef: ElementRef, _renderer: Renderer2, _ngZone: NgZone, iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    ngAfterContentChecked(): void;
    subUnit(): void;
    addUnit(): void;
    setUnit(weekDay: Weekday): void;
    changeTheView(view: CalendarView): void;
    private _onResize;
    /**
     * Need to resize the host component to size it's fixed positioned child through css
     */
    private _resizeHost;
    private _prepareHeaderData;
    capitalizeString(label: string): string;
    getWeekNumber(date: Date): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaHeaderComponent, "agenda-header", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "view": { "alias": "view"; "required": false; }; "firstAvailableDate": { "alias": "firstAvailableDate"; "required": false; }; "eventsPerDay": { "alias": "eventsPerDay"; "required": false; }; "viewSelection": { "alias": "viewSelection"; "required": false; }; }, { "viewChange": "viewChange"; "selectedDateChange": "selectedDateChange"; "rangeChange": "rangeChange"; }, never, never, false, never>;
}

declare class AgendaViewComponent {
    view: CalendarView;
    customEventObject: boolean;
    selectedDate: Date;
    eventsPerDay: AgendaEventPerDay[];
    readonly eventChecked: EventEmitter<AgendaEvent>;
    readonly viewTypes: typeof CalendarView;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaViewComponent, "agenda-view", never, { "view": { "alias": "view"; "required": false; }; "customEventObject": { "alias": "customEventObject"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "eventsPerDay": { "alias": "eventsPerDay"; "required": false; }; }, { "eventChecked": "eventChecked"; }, never, never, false, never>;
}

declare abstract class AgendaBaseViewComponent {
    protected readonly locale: LanguageCode;
    iconCacheService: IconCacheService;
    set selectedDate(value: Date);
    set eventsPerDay(value: AgendaEventPerDay[]);
    eventChecked: EventEmitter<AgendaEvent>;
    get selectedDate(): Date;
    get eventsPerDate(): AgendaEventPerDay[];
    private _selectedDate;
    private _eventsPerDay;
    constructor(locale: LanguageCode, iconCacheService: IconCacheService);
    protected prepareViewData(): void;
    protected getEventsFromDate(date: Date): AgendaEvent[];
    private _dateIsSet;
    private _eventsAreSet;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaBaseViewComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AgendaBaseViewComponent, never, never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "eventsPerDay": { "alias": "eventsPerDay"; "required": false; }; }, { "eventChecked": "eventChecked"; }, never, never, true, never>;
}

declare class Week {
    weekDays: Weekday[];
}

declare class Month {
    weeks: Week[];
    get firstWeek(): Week;
}

declare class AgendaMonthViewComponent extends AgendaBaseViewComponent {
    month: Month;
    firstWeekDays: Weekday[];
    weeks: Week[];
    protected prepareViewData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaMonthViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaMonthViewComponent, "agenda-month-view", never, {}, {}, never, never, false, never>;
}

declare class AgendaDayViewComponent extends AgendaBaseViewComponent {
    events: AgendaEvent[];
    customEventObject: boolean;
    protected prepareViewData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaDayViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaDayViewComponent, "agenda-day-view", never, { "customEventObject": { "alias": "customEventObject"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AgendaWeekViewComponent extends AgendaBaseViewComponent {
    view: CalendarView;
    customEventObject: boolean;
    week: Week;
    protected prepareViewData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaWeekViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaWeekViewComponent, "agenda-week-view", never, { "view": { "alias": "view"; "required": false; }; "customEventObject": { "alias": "customEventObject"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AgendaWeekSelectViewComponent extends AgendaBaseViewComponent {
    view: CalendarView;
    week: Week;
    readonly icons: typeof Icon;
    protected prepareViewData(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaWeekSelectViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaWeekSelectViewComponent, "agenda-week-select-view", never, { "view": { "alias": "view"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AgendaHourViewComponent {
    set date(value: Date);
    readonly datesByTheHour: Date[];
    get date(): Date;
    private _date;
    private _prepareViewData;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaHourViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaHourViewComponent, "agenda-hour-view", never, { "date": { "alias": "date"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class AgendaHourCellComponent {
    onlyLabels: boolean;
    noLabels: boolean;
    set date(value: Date);
    get date(): Date;
    datePlushalfHour: Date;
    private _date;
    private _setNextHalfHour;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaHourCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaHourCellComponent, "agenda-hour-cell", never, { "onlyLabels": { "alias": "onlyLabels"; "required": false; }; "noLabels": { "alias": "noLabels"; "required": false; }; "date": { "alias": "date"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AgendaHourViewLabelsComponent {
    set date(value: Date);
    noLabels: boolean;
    readonly datesByTheHour: Date[];
    get date(): Date;
    private _date;
    private _prepareViewData;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaHourViewLabelsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaHourViewLabelsComponent, "agenda-hour-view-labels", never, { "date": { "alias": "date"; "required": false; }; "noLabels": { "alias": "noLabels"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AgendaHalfHourCellComponent implements OnDestroy {
    private _renderer;
    currentTimeElement: ElementRef;
    set date(value: Date);
    get date(): Date;
    showLabel: boolean;
    showCurrentTime: boolean;
    currentTimeTop: number;
    id: string;
    private _date;
    private _id;
    constructor(_renderer: Renderer2);
    ngOnDestroy(): void;
    private _checkDate;
    private _checkWorkingDayStart;
    private _positionCurrentTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaHalfHourCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaHalfHourCellComponent, "agenda-half-hour-cell", never, { "date": { "alias": "date"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class AgendaEventsComponent {
    readonly viewTypes: typeof CalendarView;
    customEventObject: boolean;
    view: CalendarView;
    type: string;
    events: AgendaEvent[];
    halfHourHeight: number;
    readonly eventChecked: EventEmitter<AgendaEvent>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaEventsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaEventsComponent, "agenda-events", never, { "customEventObject": { "alias": "customEventObject"; "required": false; }; "view": { "alias": "view"; "required": false; }; "type": { "alias": "type"; "required": false; }; "events": { "alias": "events"; "required": false; }; "halfHourHeight": { "alias": "halfHourHeight"; "required": false; }; }, { "eventChecked": "eventChecked"; }, never, never, false, never>;
}

declare class AgendaEventComponent implements OnInit, OnDestroy {
    private _elementRef;
    private _renderer;
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    event: AgendaEvent;
    customEventObject: boolean;
    halfHourHeight: number;
    eventChecked: EventEmitter<AgendaEvent>;
    constructor(_elementRef: ElementRef, _renderer: Renderer2, iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    checkEvent(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaEventComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaEventComponent, "agenda-event", never, { "event": { "alias": "event"; "required": false; }; "customEventObject": { "alias": "customEventObject"; "required": false; }; "halfHourHeight": { "alias": "halfHourHeight"; "required": false; }; }, { "eventChecked": "eventChecked"; }, never, never, false, never>;
}

declare enum ThumbThreeWayState {
    Left = 0,
    Middle = 1,
    Right = 2
}

declare class ViewSelectComponent {
    private readonly _viewsToThumb;
    selectedView: CalendarView;
    selectedViewChange: EventEmitter<CalendarView>;
    readonly CalendarView: typeof CalendarView;
    get modelAsThumbState(): ThumbThreeWayState;
    constructor();
    selectView(view: CalendarView): void;
    onThumbStateChange(thumbState: ThumbThreeWayState): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ViewSelectComponent, "view-select", never, { "selectedView": { "alias": "selectedView"; "required": false; }; }, { "selectedViewChange": "selectedViewChange"; }, never, never, false, never>;
}

declare class AgendaSelectEventComponent {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    event: AgendaEvent;
    eventChecked: EventEmitter<AgendaEvent>;
    constructor(iconCacheService: IconCacheService);
    checkEvent(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgendaSelectEventComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgendaSelectEventComponent, "agenda-select-event", never, { "event": { "alias": "event"; "required": false; }; }, { "eventChecked": "eventChecked"; }, never, never, false, never>;
}

declare class ArrayNumberPipe implements PipeTransform {
    transform(length: number, offset?: number): number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayNumberPipe, "arrayNumber", false>;
}

declare class UCfirstPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UCfirstPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UCfirstPipe, "ucfirst", false>;
}

declare class FileTypeImagePipe implements PipeTransform {
    private static readonly _PATH_TO_IMAGE_FOLDER;
    constructor();
    /**
     * @param {FileTypeInternal} value
     * @param {boolean} [smallImage = false] Every mime type image has a smaller and a larger image available.
     * @returns {string} The data URI of the required mime type image
     */
    transform(value: FileTypeInternal, smallImage?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileTypeImagePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileTypeImagePipe, "fileTypeImage", false>;
}

declare class DatePlanningModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePlanningModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DatePlanningModule, [typeof DatePlanningComponent, typeof CalendarAllYearsComponent, typeof CalendarAllMonthsComponent, typeof CalendarHeaderComponent, typeof CalendarComponent, typeof CalendarViewComponent, typeof AgendaHeaderComponent, typeof AgendaViewComponent, typeof AgendaMonthViewComponent, typeof AgendaDayViewComponent, typeof AgendaWeekViewComponent, typeof AgendaWeekSelectViewComponent, typeof AgendaHourViewComponent, typeof AgendaHourCellComponent, typeof AgendaHourViewLabelsComponent, typeof AgendaHalfHourCellComponent, typeof AgendaEventsComponent, typeof AgendaEventComponent, typeof ViewSelectComponent, typeof AgendaSelectEventComponent, typeof ArrayNumberPipe, typeof UCfirstPipe, typeof FileTypeImagePipe], [typeof i2.CommonModule, typeof i3.InputDatePickerModule, typeof i3.IconModule, typeof i3.ButtonModule, typeof SharedComponentsTranslationModule], [typeof DatePlanningComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DatePlanningModule>;
}

declare class SimpleTagsComponent {
    iconCacheService: IconCacheService;
    sharedService: SharedService;
    readonly icon: typeof Icon;
    set tags(tags: TagTreeItem$1[]);
    get tags(): TagTreeItem$1[];
    set linkedTags(tags: TagTreeItem$1[]);
    get linkedTags(): TagTreeItem$1[];
    closeClick: EventEmitter<void>;
    saveClick: EventEmitter<TagTreeItem$1[]>;
    breadCrumbs: TagTreeItem$1[];
    displayTags: TagTreeItem$1[];
    searchString: string;
    private _tags;
    private _linkedTags;
    showClass(): boolean;
    constructor(iconCacheService: IconCacheService, sharedService: SharedService);
    handleSaveTags(): void;
    handleAddRecentTag(tag: TagTreeItem$1): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTagsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleTagsComponent, "co-simple-tags", never, { "tags": { "alias": "tags"; "required": false; }; "linkedTags": { "alias": "linkedTags"; "required": false; }; }, { "closeClick": "closeClick"; "saveClick": "saveClick"; }, never, never, false, never>;
}

declare class SimpleTagsFormComponent {
    iconCacheService: IconCacheService;
    sharedService: SharedService;
    readonly icon: typeof Icon;
    set tags(tags: TagTreeItem$1[]);
    set linkedTags(tags: TagTreeItem$1[]);
    get linkedTags(): TagTreeItem$1[];
    readonly linkedTagsChange: EventEmitter<TagTreeItem$1[]>;
    breadCrumbs: TagTreeItem$1[];
    displayTags: TagTreeItem$1[];
    searchString: string;
    private _tags;
    private _linkedTags;
    showClass(): boolean;
    constructor(iconCacheService: IconCacheService, sharedService: SharedService);
    setRootDisplayTags(): void;
    handleTagSelected(selectedTag: TagTreeItem$1): void;
    handleCrumbClicked(tag: TagTreeItem$1, index: number): void;
    handleAddTag(event: CdkDragDrop<TagTreeItem$1[], any>): void;
    deleteLinkedTag(tag: TagTreeItem$1): void;
    searchCollection(): void;
    private _loadThumbnail;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTagsFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleTagsFormComponent, "co-simple-tags-form", never, { "tags": { "alias": "tags"; "required": false; }; "linkedTags": { "alias": "linkedTags"; "required": false; }; }, { "linkedTagsChange": "linkedTagsChange"; }, never, never, false, never>;
}

declare class SimpleTagsFormModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTagsFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SimpleTagsFormModule, [typeof SimpleTagsFormComponent], [typeof i2.CommonModule, typeof i3.CoDialogModule, typeof i3.InputSearchModule, typeof i3.IconModule, typeof i4.DragDropModule, typeof i3.ButtonModule], [typeof SimpleTagsFormComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SimpleTagsFormModule>;
}

declare class SimpleTagsRecentComponent implements OnInit, OnChanges {
    iconCacheService: IconCacheService;
    sharedService: SharedService;
    readonly icon: typeof Icon;
    private readonly _storageKey;
    private _prevLinkedIds;
    set tags(tags: TagTreeItem$1[]);
    set linkedTags(tags: TagTreeItem$1[]);
    get linkedTags(): TagTreeItem$1[];
    addTagClick: EventEmitter<TagTreeItem$1>;
    recentTags: TagTreeItem$1[];
    private _tags;
    private _linkedTags;
    showClass(): boolean;
    constructor(iconCacheService: IconCacheService, sharedService: SharedService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    handleRecentTagClick(tag: TagTreeItem$1): void;
    isAlreadyLinked(tag: TagTreeItem$1): boolean;
    private _addToRecent;
    private _rehydrateFromStorage;
    private _toStorageItem;
    private _readStorage;
    private _writeStorage;
    private _loadThumbnail;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTagsRecentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleTagsRecentComponent, "co-simple-tags-recent", never, { "tags": { "alias": "tags"; "required": false; }; "linkedTags": { "alias": "linkedTags"; "required": false; }; }, { "addTagClick": "addTagClick"; }, never, never, false, never>;
}

declare class SimpleTagsRecentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTagsRecentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SimpleTagsRecentModule, [typeof SimpleTagsRecentComponent], [typeof i2.CommonModule, typeof i3.CoDialogModule, typeof i3.InputSearchModule, typeof i3.IconModule, typeof i4.DragDropModule, typeof i3.ButtonModule, typeof SharedComponentsTranslationModule], [typeof SimpleTagsRecentComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SimpleTagsRecentModule>;
}

declare class SimpleTagsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTagsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SimpleTagsModule, [typeof SimpleTagsComponent], [typeof i2.CommonModule, typeof i3.CoDialogModule, typeof i3.InputSearchModule, typeof i3.IconModule, typeof i4.DragDropModule, typeof i3.ButtonModule, typeof SimpleTagsFormModule, typeof SimpleTagsRecentModule], [typeof SimpleTagsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SimpleTagsModule>;
}

declare enum TableName {
    Absence = "ABSENCE",
    AbsenceEvent = "ABSENCE_EVENT",
    AbsenceFile = "ABSENCE_FILE",
    AbsenceForm = "ABSENCE_FORM",
    AccountingPeriod = "PERIODES",
    Address = "ADRESSEN",
    Administration = "ADMINISTRATIES",
    AnamnesisForm = "ANAMNESIS_FORM",
    ArticleGroup = "ARTIKEL_GROEP",
    Articles = "ARTIKELEN",
    Branch = "FILIALEN",
    BusinessRule = "BRE_RULE",
    Booking = "BOEKINGSREGELS",
    Category = "CATEGORIE",
    Characteristic = "KENMERKEN",
    CharacteristicTypes = "KENMERK_SOORTEN",
    CharacteristicLines = "KENMERK_REGELS",
    Company = "BEDRIJVEN",
    Concept = "CONCEPTEN",
    Connections = "ASS_VERBINDING",
    ContactPerson = "CONTACTPERSONEN",
    CostCenter = "KOSTENPLAATS_DRAGER",
    Country = "LANDCODE",
    CurrencyInfo = "VALUTA",
    CurrentIndication = "CURRENT_INDICATION",
    Customer = "KLANTEN",
    DeclarationMedicalOfficer = "DECLARATION_MEDICAL_OFFICER",
    DeliveryMethod = "LEVERMETHODES",
    Department = "AFDELING",
    DiagnosisForm = "DIAGNOSIS_FORM",
    Documents = "DOCUMENTATIE",
    EmployabilityProfile = "EMPLOYABILITY_PROFILE",
    EmployeeContract = "EMPLOYEE_CONTRACT",
    EmployeeContractType = "EMPLOYEE_CONTRACT_TYPE",
    Employee = "PERSONEEL",
    EndEvaluation = "END_EVALUATION",
    ExternalSource = "EXTERNE_BRONNEN",
    FirstYearEvaluation = "FIRST_YEAR_EVALUATION",
    FmlDocument = "FML_DOCUMENT",
    Goods = "GOEDEREN",
    Hardware = "ASS_HARDWARE",
    Identification = "IDENTIFICATION",
    JobCategory = "JOB_CATEGORY",
    JobType = "JOB_TYPE",
    LedgerAccount = "GROOTBOEKEN",
    LedgerClassification = "VERDICHTINGEN",
    LedgerJournal = "DAGBOEKEN",
    LedgerMainClassification = "HOOFDVERDICHTINGEN",
    LedgerMutation = "GROOTBOEK_MUTATIES",
    Location = "LOCATIES",
    MainArticle = "HOOFDARTIKELEN",
    MedicalConsultFeedback = "MEDICAL_CONSULT_FEEDBACK",
    MedicalFile = "MEDICAL_FILE",
    MedicalForm = "MEDICAL_FORM",
    MedicalInformationForm = "MEDICAL_INFORMATION_FORM",
    Note = "NOTITIE",
    NotificationFullyRecovered = "NOTIFICATION_FULLY_RECOVERED",
    NotificationLongTermIllness = "NOTIFICATION_LONG_TERM_ILLNESS",
    PaymentCondition = "BETALINGSCONDITIES",
    PaymentMethod = "BETAALWIJZE",
    PlanOfApproach = "PLAN_OF_APPROACH",
    PriceList = "PRIJSLIJSTEN",
    ProblemAnalysis = "PROBLEM_ANALYSIS",
    ProblemAnalysisAdjustment = "PROBLEM_ANALYSIS_ADJUSTMENT",
    Relations = "RELATIES",
    RelationAddress = "ADRES_RELATIES",
    RelationCommunication = "COMM_RELATIES",
    Remarks = "OPMERKINGEN",
    Salary = "SALARY",
    ServiceProvision = "ASS_DIENSTVERLENING",
    ShortReintegrationReport = "SHORT_REINTEGRATION_REPORT",
    Software = "ASS_SOFTWARE",
    Supplier = "LEVERANCIERS",
    TagValues = "TAG_VALUES",
    Tasks = "TAKEN",
    Transactions = "TRANSACTIES",
    TransactionLines = "TRANSACTIE_REGELS",
    TurnoverGroup = "OMZETGROEPEN",
    Unit = "EENHEDEN",
    User = "GEBRUIKERS",
    Vat = "BTW",
    Warehouse = "MAGAZIJNEN"
}

type OperationCallbackSimpleFunction = {
    (object: any): Promise<boolean>;
};

declare enum InternalParam {
    EnableMobField = "ENABLE_MOBFIELD",
    EnableOrderConfirmationAnalyze = "ENABLE_ORDERCNFRM_ANALYZE",
    ImportStorageLocations = "IMP_STG_LOC",
    InHouseDeploy = "IN_HOUSE_DEPLOY",
    Hrm = "HRM",
    WmsFillAmount = "WMS_VUL_AANTAL",
    WmsStorage = "WMS_OPSLAGMID",
    WmsPickOrderSticker = "WMS_PICK_ORD_ST",
    WmsAutoPickFullStorage = "WMS_OPSLAG_GT",
    WmsLocationScanNotMandatory = "MC_LOC_VERPL_SC",
    Workability = "WORKABILITY",
    TriageExpert = "TRIAGE_EXPERT",
    BusinessToBusiness = "PRIJS_BTW",
    ASS = "ASS",
    SlaConnectionsAvailable = "SYSTEEM_BEHEER",
    ServiceRfcUrl = "SERVICE_RFC_URL",
    JsStatistics = "JS_STATISTICS",
    JsExports = "JS_EXPORTS",
    ReportFullPurchaseOrderOnLocation = "MC_CHK_ALLE_LOC",
    PurchaseOrderChoiceVisible = "MC_BINNEN_INK",
    AlwaysShowTransactionLinePopup = "MAG_CC_POPUP",
    UseArticleNumberSequence = "USE_ART_SEQUENCE",
    MaxDocumentSizeInBytes = "MAX_DOC_SIZE_BYTES",
    MaxImageSizeInBytes = "MAX_IMG_SIZE_BYTES",
    MaxModelSizeInBytes = "MAX_MOD_SIZE_BYTES",
    MaxCollectSalarySizeInBytes = "MAX_VZM_LOONST_SIZE_BYTES",
    GoogleMapsAPIKey = "GOOGLE_API_KEY",
    PlanNotFinal = "PLAN_NOT_FINAL",
    DeliveryOrder = "AFLEVERBON",
    Valuta = "VALUTA",
    Country = "LAND",
    FinancialCostCenter = "FIN_KPKD"
}

interface TagsComponentConfigNames {
    TagsTabHeader?: string;
    TagsAddButton?: string;
}

interface ReadWriteAccessConfigNames {
    readWriteAccessReadWriteUserGroup?: string;
    readWriteAccessReadUserGroup?: string;
}

interface FilesUploadConfigObjects {
    TextDocumentTitle?: string;
    TextDocumentFileSize?: string;
    TextDocumentAddTagsButton?: string;
    TextDocumentDownloadable?: string;
    TextDocumentPublishTo?: string;
    TextDocumentDescription?: string;
    ImageDocumentFileSize?: string;
    ImageDocumentAddTagsButton?: string;
    ImageDocumentStoreGroups?: string;
    ImageDocumentAttachNotification?: string;
    ImageDocumentDisplayType?: string;
    ImageDocumentPublishTo?: string;
    ImageDocumentDescription?: string;
    ImageDocumentTitle?: string;
    ImageDocumentDimensions?: string;
    TagsImageConfigNames?: TagsComponentConfigNames;
    TagsTextConfigNames?: TagsComponentConfigNames;
    readWriteAccess?: ReadWriteAccessConfigNames;
}

declare enum TagCategory {
    articles = 1,
    articleConfiguration = 2,
    sales = 4,
    quotation = 8,
    pointOfSale = 16,
    purchase = 32,
    customers = 64,
    suppliers = 128,
    employees = 256,
    companies = 512,
    branches = 1024,
    stock = 2048,
    logistics = 4096,
    service = 8192,
    tasks = 16384,
    businessrules = 32768,
    AbsenceFile = 65536
}

declare abstract class BaseFileUploadComponent implements ScreenConfigAdapterComponent, OnDestroy {
    protected _dictionaryService: SharedComponentsDictionaryService;
    protected _container: ViewContainerRef;
    protected _factory: ComponentFactoryResolver;
    decimals: number;
    forceReadonly: boolean;
    maxLength: number;
    objectConfigName: string;
    redErrorBackground: boolean;
    required: boolean;
    set fileType(value: FileType$1);
    get fileType(): FileType$1;
    documents: CoDocument[];
    documentTable: TableName;
    set documentKey(value: string);
    get documentKey(): string;
    fullPageDrop: boolean;
    canAdd: boolean;
    dropMessage: string;
    addWithButton: boolean;
    canDelete: boolean;
    noDragDropOrdering: boolean;
    set readonly(value: boolean);
    get readonly(): boolean;
    askBeforeDelete: boolean;
    resizeImages: boolean;
    lockOperation: OperationCallbackSimpleFunction;
    unlockOperation: OperationCallbackSimpleFunction;
    beforeDeleteOperation: OperationCallbackSimpleFunction;
    afterDeleteOperation: OperationCallbackSimpleFunction;
    beforeCreateOperation: OperationCallbackSimpleFunction;
    afterCreateOperation: OperationCallbackSimpleFunction;
    beforeEditOperation: OperationCallbackSimpleFunction;
    dontAskBeforeDelete: boolean;
    noOwnDeleteOperation: boolean;
    private _fileType;
    set maxUploadSizeParam(value: InternalParam);
    useWithoutSettingProps: boolean;
    filesUploadConfigObjects: FilesUploadConfigObjects;
    medicalUserGroups: boolean;
    tagCategory: TagCategory;
    tagReferenceTable: TableName;
    displayReadWriteAccess: boolean;
    useCustomFileDropEvent: boolean;
    customFileDropEvent: EventEmitter<FileList>;
    readonly documentsAdded: EventEmitter<CoDocument[]>;
    readonly documentDeleted: EventEmitter<CoDocument>;
    readonly sortableListChanged: EventEmitter<CoDocument[]>;
    documentChangeEvent: EventEmitter<CoDocument>;
    popupOpenedStateChange: EventEmitter<boolean>;
    hidden: boolean;
    documentUnderEdit: CoDocument;
    acceptedUploadFormats: string;
    uploadFeedbackMessage: string;
    uploadFeedbackVisible: boolean;
    showResizeDialog: boolean;
    resizeDialogMessage: string;
    resizeDialogCanSave: boolean;
    protected _maxUploadFileSize: number;
    protected readonly _resizeTargetBytes: number;
    private _dragEnterTarget;
    private _documentKey;
    private _dropZone;
    private _popup;
    private _docChangeSub;
    private _popupCloseSub;
    private _readonly;
    private _uploadFeedbackTimeout;
    private _pendingResizeResolver;
    constructor(_dictionaryService: SharedComponentsDictionaryService, _container: ViewContainerRef, _factory: ComponentFactoryResolver);
    ngOnDestroy(): void;
    onDrop(event: DragEvent): Promise<void>;
    onDragEnd(event: DragEvent): void;
    onDragOver(event: DragEvent): void;
    onDragEnter(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    private _showDropzone;
    private _clearDropzone;
    handleDelete(file: CoDocument): Promise<boolean>;
    private _delete;
    handleSortingChange(docs: CoDocument[]): void;
    handleFileChange(event: any): Promise<void>;
    filesPicked(files: FileList): Promise<void>;
    private _processIncomingFiles;
    protected _prepareFilesForUpload(files: File[]): Promise<File[]>;
    handleEditDocumentClick(docToEdit: CoDocument): Promise<void>;
    openPopup(): Promise<void>;
    openPopupToAddDocumentByUrl(): void;
    private _createDocumentToAddByUrl;
    private _createAndFillPopupInstance;
    protected convertFilesIntoCoDocuments(files: FileList): Promise<CoDocument[]>;
    protected convertFileArrayIntoCoDocuments(files: File[]): Promise<CoDocument[]>;
    handleAcceptedFileTypesLoaded(value: FileType$1): void;
    protected showUploadFeedback(message: string): void;
    protected clearUploadFeedback(): void;
    protected getTooLargeMessage(file: File): string;
    protected getUnsupportedExtensionMessage(file: File, allowedExtensions?: string[]): string | null;
    protected getMaxUploadSizeInMb(): string;
    protected askResizeForImage(file: File): Promise<boolean>;
    handleResizeDialogSave(): void;
    handleResizeDialogClose(): void;
    private closeResizeDialog;
    protected resizeImageToUploadLimit(file: File): Promise<File>;
    protected resizeImage(file: File, maxWidth: number, maxHeight: number, quality: number): Promise<File>;
    protected readFileAsDataUrl(file: File): Promise<string>;
    protected loadImage(src: string): Promise<HTMLImageElement>;
    protected getResizedFileName(originalName: string, mimeType: string): string;
    private _getFileAsDocument;
    private _setInternalParamObj;
    private _lockDocument;
    private _unlockDocument;
    private _prepareFileRights;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFileUploadComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFileUploadComponent, never, never, { "fileType": { "alias": "fileType"; "required": false; }; "documents": { "alias": "documents"; "required": false; }; "documentTable": { "alias": "documentTable"; "required": false; }; "documentKey": { "alias": "documentKey"; "required": false; }; "fullPageDrop": { "alias": "fullPageDrop"; "required": false; }; "canAdd": { "alias": "canAdd"; "required": false; }; "dropMessage": { "alias": "dropMessage"; "required": false; }; "addWithButton": { "alias": "addWithButton"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "noDragDropOrdering": { "alias": "noDragDropOrdering"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "askBeforeDelete": { "alias": "askBeforeDelete"; "required": false; }; "resizeImages": { "alias": "resizeImages"; "required": false; }; "lockOperation": { "alias": "lockOperation"; "required": false; }; "unlockOperation": { "alias": "unlockOperation"; "required": false; }; "beforeDeleteOperation": { "alias": "beforeDeleteOperation"; "required": false; }; "afterDeleteOperation": { "alias": "afterDeleteOperation"; "required": false; }; "beforeCreateOperation": { "alias": "beforeCreateOperation"; "required": false; }; "afterCreateOperation": { "alias": "afterCreateOperation"; "required": false; }; "beforeEditOperation": { "alias": "beforeEditOperation"; "required": false; }; "dontAskBeforeDelete": { "alias": "dontAskBeforeDelete"; "required": false; }; "noOwnDeleteOperation": { "alias": "noOwnDeleteOperation"; "required": false; }; "maxUploadSizeParam": { "alias": "maxUploadSizeParam"; "required": false; }; "useWithoutSettingProps": { "alias": "useWithoutSettingProps"; "required": false; }; "filesUploadConfigObjects": { "alias": "filesUploadConfigObjects"; "required": false; }; "medicalUserGroups": { "alias": "medicalUserGroups"; "required": false; }; "tagCategory": { "alias": "tagCategory"; "required": false; }; "tagReferenceTable": { "alias": "tagReferenceTable"; "required": false; }; "displayReadWriteAccess": { "alias": "displayReadWriteAccess"; "required": false; }; "useCustomFileDropEvent": { "alias": "useCustomFileDropEvent"; "required": false; }; }, { "customFileDropEvent": "customFileDropEvent"; "documentsAdded": "documentsAdded"; "documentDeleted": "documentDeleted"; "sortableListChanged": "sortableListChanged"; "documentChangeEvent": "documentChangeEvent"; "popupOpenedStateChange": "popupOpenedStateChange"; }, never, never, true, never>;
}

declare class FilesUploadComponent extends BaseFileUploadComponent implements OnDestroy {
    protected _container: ViewContainerRef;
    protected _factory: ComponentFactoryResolver;
    iconCacheService: IconCacheService;
    icon: typeof Icon;
    set dropzone(value: boolean);
    slideoutTemplate: TemplateRef<any>;
    input: ElementRef;
    label: string;
    cfgNames: any;
    customImageClick: boolean;
    isEditable: boolean;
    hideAvatars: boolean;
    fileSavesOnPopupOkClick: boolean;
    selected: string;
    readonly editSlideoutSubmit: EventEmitter<void>;
    tagsChangeEvent: EventEmitter<TagTreeItem$1[]>;
    imageClick: EventEmitter<CoDocument>;
    showClass(): boolean;
    get editable(): boolean;
    get empty(): boolean;
    mouseOverAdd: boolean;
    slideoutShown: boolean;
    isDropzone: boolean;
    constructor(dictionaryService: SharedComponentsDictionaryService, _container: ViewContainerRef, _factory: ComponentFactoryResolver, iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    openFileBrowser(): Promise<void>;
    handleAddClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilesUploadComponent, "co-files-upload", never, { "dropzone": { "alias": "dropzone"; "required": false; }; "label": { "alias": "label"; "required": false; }; "cfgNames": { "alias": "cfgNames"; "required": false; }; "customImageClick": { "alias": "customImageClick"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "hideAvatars": { "alias": "hideAvatars"; "required": false; }; "fileSavesOnPopupOkClick": { "alias": "fileSavesOnPopupOkClick"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "editSlideoutSubmit": "editSlideoutSubmit"; "tagsChangeEvent": "tagsChangeEvent"; "imageClick": "imageClick"; }, ["slideoutTemplate"], never, false, never>;
}

declare class ImageDisplayComponent implements ScreenConfigAdapterComponent {
    model: string;
    label: string;
    showClass(): boolean;
    objectConfigName: string;
    hidden: boolean;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    decimals: number;
    redErrorBackground: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageDisplayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageDisplayComponent, "co-image-display", never, { "model": { "alias": "model"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ImageDisplayModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageDisplayModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageDisplayModule, [typeof ImageDisplayComponent], [typeof i3.CoreComponentsTranslationModule, typeof i2.CommonModule, typeof SharedComponentsTranslationModule], [typeof ImageDisplayComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ImageDisplayModule>;
}

declare class FileUploadComponent implements OnDestroy {
    private _promptService;
    private _fileTypeImgPipe;
    iconService: IconCacheService;
    private _sharedService;
    readonly icons: typeof Icon;
    form: FormComponent;
    set file(document: CoDocument);
    get file(): CoDocument;
    icon: Icon;
    link: boolean;
    dropzone: boolean;
    readonly: boolean;
    isAddingTile: boolean;
    fileSavesOnPopupOkClick: boolean;
    isEditable: boolean;
    set label(value: string);
    get label(): string;
    showTrashCan: boolean;
    showImage: boolean;
    customImageClick: boolean;
    creationDate: Date;
    creationUser: string;
    modifiedDate: Date;
    modifiedUser: string;
    deleteClick: EventEmitter<any>;
    editClick: EventEmitter<CoDocument>;
    imageClick: EventEmitter<CoDocument>;
    showClass(): boolean;
    get isLink(): boolean;
    previewImage: string;
    private _file;
    private _docBodyChangeSub;
    private _label;
    constructor(_promptService: PromptService, _fileTypeImgPipe: FileTypeImagePipe, iconService: IconCacheService, _sharedService: SharedService);
    ngOnDestroy(): void;
    onDeleteClick(): void;
    onImageClick(): Promise<void>;
    onPencilClick(): Promise<void>;
    private _listenForDocumentBodyChanges;
    private _updatePreviewImage;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadComponent, "co-file-upload", never, { "file": { "alias": "file"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "link": { "alias": "link"; "required": false; }; "dropzone": { "alias": "dropzone"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "isAddingTile": { "alias": "isAddingTile"; "required": false; }; "fileSavesOnPopupOkClick": { "alias": "fileSavesOnPopupOkClick"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "label": { "alias": "label"; "required": false; }; "showTrashCan": { "alias": "showTrashCan"; "required": false; }; "showImage": { "alias": "showImage"; "required": false; }; "customImageClick": { "alias": "customImageClick"; "required": false; }; "creationDate": { "alias": "creationDate"; "required": false; }; "creationUser": { "alias": "creationUser"; "required": false; }; "modifiedDate": { "alias": "modifiedDate"; "required": false; }; "modifiedUser": { "alias": "modifiedUser"; "required": false; }; }, { "deleteClick": "deleteClick"; "editClick": "editClick"; "imageClick": "imageClick"; }, never, never, false, never>;
}

declare enum TileSizeType {
    Small = 0,
    Large = 1
}

declare class TileRenderComponent implements OnDestroy {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    infoTemplate: TemplateRef<any>;
    imageDataUri: string;
    tagDescription: string;
    label: string;
    description: string;
    tileSize: TileSizeType;
    price: number;
    hidePrice: boolean;
    iconWhenSelected: string;
    /**
     * By default, this component shows a special icon and missing-image text for the image when it's empty. Set this to true
     * to hide the whole image-display instead, when there was no image given.
     */
    hideImageDisplayWhenNoImage: boolean;
    creationDate: Date;
    creationUser: string;
    modifiedDate: Date;
    modifiedUser: string;
    selected: boolean;
    imageClick: EventEmitter<any>;
    infoClick: EventEmitter<any>;
    get inSmallTileMode(): boolean;
    showClass(): boolean;
    get inLargeTileMode(): boolean;
    constructor(iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    protected readonly Icon: typeof Icon;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileRenderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TileRenderComponent, "co-tile-render", never, { "imageDataUri": { "alias": "imageDataUri"; "required": false; }; "tagDescription": { "alias": "tagDescription"; "required": false; }; "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "tileSize": { "alias": "tileSize"; "required": false; }; "price": { "alias": "price"; "required": false; }; "hidePrice": { "alias": "hidePrice"; "required": false; }; "iconWhenSelected": { "alias": "iconWhenSelected"; "required": false; }; "hideImageDisplayWhenNoImage": { "alias": "hideImageDisplayWhenNoImage"; "required": false; }; "creationDate": { "alias": "creationDate"; "required": false; }; "creationUser": { "alias": "creationUser"; "required": false; }; "modifiedDate": { "alias": "modifiedDate"; "required": false; }; "modifiedUser": { "alias": "modifiedUser"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "imageClick": "imageClick"; "infoClick": "infoClick"; }, ["infoTemplate"], ["[tile-render-image-content]", "*"], false, never>;
}

declare class TileRenderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileRenderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TileRenderModule, [typeof TileRenderComponent], [typeof ImageDisplayModule, typeof i2.CommonModule, typeof i3.IconModule, typeof i3.ImageModule, typeof i3.TemplateWrapperModule], [typeof TileRenderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TileRenderModule>;
}

declare class FileUploadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploadModule, [typeof FileUploadComponent], [typeof i3.IconModule, typeof TileRenderModule, typeof i2.CommonModule, typeof i3.ButtonModule, typeof SharedComponentsTranslationModule], [typeof FileUploadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadModule>;
}

declare enum FileType {
    Document = "DOC",
    Image = "IMG",
    DigitalSignature = "SDWEB",
    CollectiveSalaryInfo = "LOONSTAAT",
    ThreeDFile = "UNITYWEB"
}

declare enum DocumentEmailReport {
    Orderbevestiging = 1,
    Afleverbon = 2,
    Factuur = 4,
    Bestelbon = 8,
    Atelierbon = 16,
    Werkbon = 32,
    Vrachtbrief = 64,
    Leverindicatie = 128,
    Uitlopende_levering = 256,
    Goederen_binnen = 512,
    Afspraakbevestiging = 1024,
    Herinneringsbestelbon = 2048,
    Aanmaninglevertijd = 4096
}

declare enum DomainMultipleName {
    ArticlePublication = "ART_PUBLICATIE",
    ArticlePublicationSales = "ART_PUBLICATIE_VERK",
    ArticleSyncField = "DOM_SYNC_VELDEN",
    DocumentPublication = "DOC_PUBLICATIE",
    TextType = "TEKST_PUBLICATIE",
    TextPublication = "TEKSTSOORT",
    RotationOption = "ART_ROTATION_ALLOWED",
    WeekDays = "WEEKDAGEN"
}

declare class TreeObject extends BusinessObject {
    parentId?: number | string;
    treeLevel?: number;
    nodeOpen?: boolean;
    parentNodeOpen?: boolean;
    hasChildren?: boolean;
}

declare class TagTreeItem extends TreeObject {
    description: string;
    tagType: string;
    rubricId: number;
    groupId: number;
    tagId: number;
    creationDate: Date;
    selected: boolean;
    numberOfCoupledTags: number;
    coupled: boolean;
    color: string;
    image: CoDocument;
    parentDescription: string;
    constructor();
    getId(): number;
}

declare class FileUploadPopupComponent implements OnInit {
    private _promptService;
    private _fileTypeImgPipe;
    iconCacheService: IconCacheService;
    readonly icon: typeof Icon;
    form: FormComponent;
    useWithoutSettingProps: boolean;
    hasPublicAccessVisible: boolean;
    showDocumentReportPicker: boolean;
    set documentUnderEdit(doc: CoDocument);
    get documentUnderEdit(): CoDocument;
    set readonly(value: boolean);
    set filesUploadConfigObjects(value: FilesUploadConfigObjects);
    tagCategory: TagCategory;
    medicalUserGroups: boolean;
    displayReadWriteAccess: boolean;
    tagReferenceTable: TableName;
    documentKey: string;
    documentTable: string;
    fileType: FileType;
    addDocumentByUrl: boolean;
    readonly documentChangeEvent: EventEmitter<CoDocument>;
    readonly popupCloseEvent: EventEmitter<void>;
    showClass(): boolean;
    readonly documentPublication: typeof DocumentPublication;
    readonly documentEmailReports: typeof DocumentEmailReport;
    get showReadWriteAccess(): boolean;
    get filesUploadConfigObjects(): FilesUploadConfigObjects;
    get isWorkability(): boolean;
    get docUnderEditIsReadOnly(): boolean;
    get thumbnail(): string;
    get popupHeader(): string;
    get publicationConfigName(): string;
    get tagsConfigName(): TagsComponentConfigNames;
    readonly domain: typeof DomainMultipleName;
    readonly fileTypes: typeof FileType;
    _documentUnderEdit: CoDocument;
    hideCancel: boolean;
    storeGroups: StoreGroup[];
    publicationIds: number[];
    storeGroupIds: string[];
    userGroupsForWrite: number[];
    userGroupsForRead: number[];
    documentTags: TagTreeItem[];
    private _filesUploadConfigObjects;
    private _boFactory;
    private _readonly;
    private _publicationNumber;
    private _reportsNumber;
    private _thumbnail;
    constructor(_promptService: PromptService, _fileTypeImgPipe: FileTypeImagePipe, iconCacheService: IconCacheService);
    ngOnInit(): void;
    loadCollection(): Promise<void>;
    onPreviewClick(): void;
    saveDocumentUnderEditRights(): void;
    onPopupOkClick(): void;
    handlePropertyChange(refSumOfEnabledItems: number): any;
    handleReportsPropertyChange(refSumOfEnabledItems: number): any;
    onValidSubmit(): Promise<void>;
    onPopupCancelClick(): Promise<void>;
    onPopupClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadPopupComponent, "co-file-upload-popup", never, { "useWithoutSettingProps": { "alias": "useWithoutSettingProps"; "required": false; }; "hasPublicAccessVisible": { "alias": "hasPublicAccessVisible"; "required": false; }; "showDocumentReportPicker": { "alias": "showDocumentReportPicker"; "required": false; }; "documentUnderEdit": { "alias": "documentUnderEdit"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "filesUploadConfigObjects": { "alias": "filesUploadConfigObjects"; "required": false; }; "tagCategory": { "alias": "tagCategory"; "required": false; }; "medicalUserGroups": { "alias": "medicalUserGroups"; "required": false; }; "displayReadWriteAccess": { "alias": "displayReadWriteAccess"; "required": false; }; "tagReferenceTable": { "alias": "tagReferenceTable"; "required": false; }; "documentKey": { "alias": "documentKey"; "required": false; }; "documentTable": { "alias": "documentTable"; "required": false; }; "fileType": { "alias": "fileType"; "required": false; }; "addDocumentByUrl": { "alias": "addDocumentByUrl"; "required": false; }; }, { "documentChangeEvent": "documentChangeEvent"; "popupCloseEvent": "popupCloseEvent"; }, never, never, false, never>;
}

interface KeyValuePair {
    key: any;
    value: any;
}

/**
 * Custom component for enabling and disabling multiple items based on an input enum
 * For the component to work, an enum is required and a list of enabled items so that
 * the component knows which items from the enum are already enabled
 *
 * Note: can be improved by not only accepting a string array of enabledItemProperties but also a full cgref number because that will save one conversion step as
 * BO's already contain these numbers.
 */

declare class MultiplePropertyTogglerComponent implements AfterViewInit {
    label: string;
    propertyNamesToToggle: any;
    readonly: boolean;
    enableditems: number;
    enableditemsChange: EventEmitter<number>;
    readonly onPropertyItemChange: EventEmitter<number>;
    showClass(): boolean;
    readonly Icons: typeof Icon;
    objectifiedEnum: KeyValuePair[];
    enabledItemNumberList: number[];
    ngAfterViewInit(): void;
    isValueActive(propertyToCheck: any): boolean;
    clickToToggleProperty(target: any): void;
    makeNumberArrayFromCgRefCodeSum(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiplePropertyTogglerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiplePropertyTogglerComponent, "co-multiple-property-toggler", never, { "label": { "alias": "label"; "required": false; }; "propertyNamesToToggle": { "alias": "propertyNamesToToggle"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "enableditems": { "alias": "enableditems"; "required": false; }; }, { "enableditemsChange": "enableditemsChange"; "onPropertyItemChange": "onPropertyItemChange"; }, never, never, false, never>;
}

declare class MultiplePropertyTogglerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiplePropertyTogglerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiplePropertyTogglerModule, [typeof MultiplePropertyTogglerComponent], [typeof i3.InputCheckboxModule, typeof i2.CommonModule], [typeof MultiplePropertyTogglerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MultiplePropertyTogglerModule>;
}

declare class FileUploadPopupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadPopupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploadPopupModule, [typeof FileUploadPopupComponent], [typeof i3.CoDialogModule, typeof i3.FormModule, typeof SharedComponentsTranslationModule, typeof i3.InputTextModule, typeof i3.ButtonModule, typeof i2.CommonModule, typeof i3.ScreenConfigurationModule, typeof MultiplePropertyTogglerModule, typeof i3.IconModule], [typeof FileUploadPopupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadPopupModule>;
}

declare class AppFileDropzoneComponent {
    protected dictionary: SharedComponentsDictionaryService;
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    customDropActionMessage: string;
    showClass(): boolean;
    readonly Icons: typeof Icon;
    private readonly _defaultDropActionMessage;
    constructor(dictionary: SharedComponentsDictionaryService, iconCacheService: IconCacheService);
    getDropActionMessage(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppFileDropzoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppFileDropzoneComponent, "co-app-file-dropzone", never, { "customDropActionMessage": { "alias": "customDropActionMessage"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AppFileDropzoneModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AppFileDropzoneModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AppFileDropzoneModule, [typeof AppFileDropzoneComponent], [typeof i3.IconModule], [typeof AppFileDropzoneComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AppFileDropzoneModule>;
}

declare class FilesUploadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesUploadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FilesUploadModule, [typeof FilesUploadComponent], [typeof i3.CoDialogModule, typeof i3.FormModule, typeof i3.InputTextModule, typeof i3.ScreenConfigurationModule, typeof i3.ButtonModule, typeof SharedComponentsTranslationModule, typeof i3.IconModule, typeof ImageDisplayModule, typeof i2.CommonModule, typeof i3.InputCheckboxModule, typeof FileUploadModule, typeof FileUploadPopupModule, typeof AppFileDropzoneModule, typeof i3.DragDropModule, typeof SimpleTagsFormModule, typeof SimpleTagsRecentModule], [typeof FilesUploadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FilesUploadModule>;
}

declare class ActivityListComponent implements OnInit, ScreenConfigAdapterComponent {
    iconCacheService: IconCacheService;
    private _dictionaryService;
    readonly Icon: typeof Icon;
    readonly RelationKind: typeof RelationKind;
    readonly ActivityType: typeof ActivityType;
    readonly TimeUtils: typeof TimeUtils;
    showClass(): boolean;
    set activities(value: Activity[]);
    get activities(): Activity[];
    remarkIcon: Icon;
    workIcon: Icon;
    statusIcon: Icon;
    taskIcon: Icon;
    objectConfigName: string;
    hidden: boolean;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    decimals: number;
    redErrorBackground: boolean;
    showActivityPopup: Boolean;
    currentActivityDocuments: CoDocument[];
    private _activities;
    private activityColorMap;
    constructor(iconCacheService: IconCacheService, _dictionaryService: SharedComponentsDictionaryService);
    ngOnInit(): Promise<void>;
    getRelationKind(author: RelationSmallObject): RelationKind;
    getDateString(date: Date): string;
    getActivityIcon(activity: Activity): Icon;
    getActivityClass(activity: Activity): string;
    showTriggers(activity: Activity): boolean;
    showAttachments(activity: Activity): boolean;
    showEmailHistory(activity: Activity): boolean;
    showWorkedTime(activity: Activity): boolean;
    getWorkedTime(activity: Activity): number;
    openActivityPopup(activity: Activity): void;
    getRandomColor(): string;
    getColorForActivity(activity: Activity): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityListComponent, "co-activity-list", never, { "activities": { "alias": "activities"; "required": false; }; "remarkIcon": { "alias": "remarkIcon"; "required": false; }; "workIcon": { "alias": "workIcon"; "required": false; }; "statusIcon": { "alias": "statusIcon"; "required": false; }; "taskIcon": { "alias": "taskIcon"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ActivityListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActivityListModule, [typeof ActivityListComponent], [typeof i3.IconModule, typeof i2.CommonModule, typeof i3.CoDialogModule, typeof FilesUploadModule], [typeof ActivityListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActivityListModule>;
}

declare abstract class BaseActivityListComponent implements OnDestroy {
    protected reloadTimer: number;
    handleOpenLinkSidebar: boolean;
    set activities(value: Activity[]);
    get activities(): Activity[];
    set delegatedActivities(value: Activity[]);
    get delegatedActivities(): Activity[];
    filterFrom: Date;
    filterTo: Date;
    searchText: string;
    filteredActivities: Activity[];
    filteredDelegatedActivities: Activity[];
    privateActivityListViewModels: ActivityListViewModel[];
    privateDelegatedActivityListViewModels: ActivityListViewModel[];
    filteredActivityListViewModels: ActivityListViewModel[];
    filteredDelegatedActivityListViewModels: ActivityListViewModel[];
    private _showUsergroupActivities;
    get showUsergroupActivities(): boolean;
    set showUsergroupActivities(value: boolean);
    private _activities;
    private _delegatedActivities;
    private _updateInterval;
    constructor();
    ngOnDestroy(): void;
    abstract getActivities(): any;
    abstract getDelegatedActivities(): any;
    reset(): void;
    applyFilter(): void;
    protected afterFilterApplied(): void;
    protected getTheActivities(): void;
    private _removeNotShowing;
    protected updatePrivateListsWithFilteredLists(): void;
    private _applyFilter;
    private _searchText;
    private _updatePrivateListWithFilteredList;
    private _refreshActivities;
    private _prepareViewModels;
    private _setAmountListViewModels;
    private _sortByPosition;
    private _addToActivityListViewModel;
    private _getActivityViewModel;
    private _getActivityListViewModel;
    private _startInterval;
    private _updateViewModelContent;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseActivityListComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseActivityListComponent, never, never, { "handleOpenLinkSidebar": { "alias": "handleOpenLinkSidebar"; "required": false; }; }, {}, never, never, true, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseActivityListComponent>;
}

type OperationCallbackFunctionWithValidation = {
    (object: any, object2: any, object3: any): Promise<ValidationResult>;
};

declare enum ActivityCfgName {
    TaskForms = "TaskForms",
    NewTaskFormHeader = "NewTaskFormHeader",
    NewTaskTitle = "NewTaskTitle",
    ActivitiesHeader = "activitiesHeader",
    NewTaskGlobalButton = "newTaskGlobalButton",
    AddActivityTaskButton = "addActivityTaskButton",
    DeleteActivityTaskButton = "deleteActivityTaskButton",
    AddActivityRemarkButton = "addActivityRemarkButton",
    AddActivityWorkButton = "addActivityWorkButton",
    TimeRegistrationMandatory = "timeRegistrationMandatory",
    StatusSummaryHeader = "statusSummaryHeader",
    CreationSummaryHeader = "creationSummaryHeader",
    ExecutiveSummaryHeader = "executiveSummaryHeader",
    PlanningSummaryHeader = "planningSummaryHeader",
    AttachmentsHeader = "attachmentsHeader",
    NotificationsSummaryHeader = "notificationsSummaryHeader",
    TagsHeader = "tagsHeader",
    WorkHeader = "workHeader",
    WorkExecutive = "workExecutive",
    WorkCalculationKey = "calculationKey",
    WorkDescription = "workDescription",
    WorkFile = "workFile",
    EstimationStandardTime = "estimate",
    TaskInvoice = "taskInvoice",
    WorkedTime = "workedTime"
}

interface ActivitiesTaskConfigNames {
    timeRegistrationMandatory?: string;
    deleteActivityTaskButton?: string;
    statusSummaryHeader?: string;
    creationSummaryHeader?: string;
    executiveSummaryHeader?: string;
    planningSummaryHeader?: string;
    attachmentsHeader?: string;
    notificationsSummaryHeader?: string;
    tagsHeader?: string;
    taskInvoice?: string;
}

type OperationCallbackActivity = {
    (object: any): Promise<Activity>;
};

declare abstract class BaseActivitySummaryComponent implements ScreenConfigAdapterComponent {
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    private _sharedService;
    decimals: number;
    forceReadonly: boolean;
    maxLength: number;
    objectConfigName: string;
    redErrorBackground: boolean;
    required: boolean;
    set activity(value: Activity);
    get activity(): Activity;
    set workFlow(value: ActivityWorkflow);
    get workFlow(): ActivityWorkflow;
    set task(value: Task);
    get task(): Task;
    table: TableName$1;
    key: string;
    expanded: boolean;
    noBorder: boolean;
    readonly: boolean;
    loadTaskOperation: OperationCallbackSimpleFunction;
    set triggerToFireOnSave(value: WorkflowTrigger);
    get triggerToFireOnSave(): WorkflowTrigger;
    readonly activityChange: EventEmitter<Activity>;
    readonly showWorkLog: EventEmitter<void>;
    readonly triggerFired: EventEmitter<ActivityWorkflow>;
    hidden: boolean;
    editActivity: Activity;
    private _workFlow;
    private _task;
    private _triggerToFireOnSave;
    constructor(dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, _sharedService: SharedService);
    handleSave(event: MouseEvent): void;
    handleCancel(event: MouseEvent): void;
    handleTriggerClick(trigger: WorkflowTrigger): Promise<void>;
    handleExpandClick(value: boolean): void;
    protected prepareWorkflow(): Promise<void>;
    private _saveClone;
    private updateActivityTask;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseActivitySummaryComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseActivitySummaryComponent, never, never, { "activity": { "alias": "activity"; "required": false; }; "workFlow": { "alias": "workFlow"; "required": false; }; "task": { "alias": "task"; "required": false; }; "table": { "alias": "table"; "required": false; }; "key": { "alias": "key"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "noBorder": { "alias": "noBorder"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "loadTaskOperation": { "alias": "loadTaskOperation"; "required": false; }; "triggerToFireOnSave": { "alias": "triggerToFireOnSave"; "required": false; }; }, { "activityChange": "activityChange"; "showWorkLog": "showWorkLog"; "triggerFired": "triggerFired"; }, never, never, true, never>;
}

declare class ActivitySummaryBlockComponent implements OnDestroy {
    private _formMaster;
    elementRef: ElementRef;
    readonly Icon: typeof Icon;
    mainForm: FormComponent;
    cssId: string;
    noBorder: boolean;
    icon: Icon;
    editIcon: Icon;
    image: string;
    editTitle: string;
    editTemplate: TemplateRef<any>;
    extraButtonsTemplate: TemplateRef<any>;
    readonly: boolean;
    showButtons: boolean;
    hideCancel: boolean;
    actionIcon: boolean;
    expandable: boolean;
    saveClick: EventEmitter<any>;
    cancelClick: EventEmitter<MouseEvent>;
    showClass(): boolean;
    get summaryElement(): ElementRef;
    constructor(_formMaster: FormMasterService, elementRef: ElementRef);
    ngOnDestroy(): void;
    handleOkClick(event: MouseEvent): void;
    handleCancelClick(event: MouseEvent): void;
    onValid(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivitySummaryBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivitySummaryBlockComponent, "co-activity-summary-block", never, { "cssId": { "alias": "cssId"; "required": false; }; "noBorder": { "alias": "noBorder"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "editIcon": { "alias": "editIcon"; "required": false; }; "image": { "alias": "image"; "required": false; }; "editTitle": { "alias": "editTitle"; "required": false; }; "editTemplate": { "alias": "editTemplate"; "required": false; }; "extraButtonsTemplate": { "alias": "extraButtonsTemplate"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showButtons": { "alias": "showButtons"; "required": false; }; "hideCancel": { "alias": "hideCancel"; "required": false; }; "actionIcon": { "alias": "actionIcon"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; }, { "saveClick": "saveClick"; "cancelClick": "cancelClick"; }, never, never, false, never>;
}

declare class NotificationSummaryBlockComponent extends BaseActivitySummaryComponent implements OnInit {
    protected boFactory: BusinessObjectFactory;
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    protected sharedService: SharedService;
    readonly Icon: typeof Icon;
    readonly WorkflowCategoryType: typeof WorkflowCategoryType;
    summaryBlock: ActivitySummaryBlockComponent;
    showClass(): boolean;
    branchNo: string;
    listItems: RoleEmailaddress[];
    emailAddresses: string[];
    constructor(boFactory: BusinessObjectFactory, dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, sharedService: SharedService);
    ngOnInit(): Promise<void>;
    handleEmailChange(emailAddresses: string[]): void;
    handleSendEmail(event: MouseEvent): Promise<void>;
    private createEmailAddressString;
    private createEmailSubject;
    private sendEmailIfNeccesary;
    private startEmailing;
    private _createEmailParams;
    private findDefault;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationSummaryBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationSummaryBlockComponent, "co-notification-summary-block", never, { "branchNo": { "alias": "branchNo"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ModifyTaskFormComponent implements OnInit, ScreenConfigAdapterComponent {
    private _boFactory;
    private sharedService;
    iconCacheService: IconCacheService$1;
    readonly TableNames: typeof TableName$1;
    notificationBlock: NotificationSummaryBlockComponent;
    set activity(value: Activity);
    showClass(): boolean;
    get activity(): Activity;
    get hasDocuments(): boolean;
    activityTaskConfigNames: ActivitiesTaskConfigNames;
    readonly: boolean;
    popupContext: boolean;
    branchNo: string;
    set forceReadonly(value: boolean);
    hidden: boolean;
    activityChange: EventEmitter<Activity>;
    statusChange: EventEmitter<boolean>;
    showWorkLog: EventEmitter<void>;
    triggerFired: EventEmitter<void>;
    selectedMenu: string;
    activities: Activity[];
    table: TableName$1;
    key: string;
    expandActivities: boolean;
    objectConfigName: string;
    required: boolean;
    maxLength: number;
    decimals: number;
    redErrorBackground: boolean;
    showTagPopup: boolean;
    allTags: TagTreeItem$1[];
    private _activity;
    handleAddDocuments(docs: CoDocument[]): void;
    handleAddDocument(doc: CoDocument): void;
    constructor(_boFactory: BusinessObjectFactory, sharedService: SharedService, iconCacheService: IconCacheService$1);
    ngOnInit(): void;
    showContent(menu: string): void;
    handleRegisterWork(): void;
    handleSaveActivity(activity: Activity): void;
    handleDeleteActivity(activity: Activity): void;
    handleShowWorkLow(): void;
    handleEditTags(): void;
    handleSaveTags(tags: TagTreeItem$1[]): void;
    handleTriggerFired(): void;
    private _updateTaskObject;
    private _getActivities;
    private _getTags;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModifyTaskFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModifyTaskFormComponent, "co-modify-task-form", never, { "activity": { "alias": "activity"; "required": false; }; "activityTaskConfigNames": { "alias": "activityTaskConfigNames"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "popupContext": { "alias": "popupContext"; "required": false; }; "branchNo": { "alias": "branchNo"; "required": false; }; "forceReadonly": { "alias": "forceReadonly"; "required": false; }; }, { "activityChange": "activityChange"; "statusChange": "statusChange"; "showWorkLog": "showWorkLog"; "triggerFired": "triggerFired"; }, never, never, false, never>;
}

declare class TaskModifierComponent implements OnDestroy {
    private _dialogService;
    private _boFactory;
    private readonly _dictionary;
    iconService: IconCacheService;
    protected sharedService: SharedService;
    readonly icons: typeof Icon;
    mainForm: FormComponent;
    modifyTaskForm: ModifyTaskFormComponent;
    notificationBlock: NotificationSummaryBlockComponent;
    get readonly(): boolean;
    taskCfgNames: ActivitiesTaskConfigNames;
    workflowCategory: WorkflowCategoryType;
    reference: string;
    referenceId: string;
    userGroupId: number;
    relationId: number;
    branchNo: string;
    createTaskOperation: OperationCallbackActivity;
    forceReadonly: boolean;
    readonly editingComplete: EventEmitter<Activity>;
    readonly activitySaved: EventEmitter<Activity>;
    readonly activityDeleted: EventEmitter<Activity>;
    readonly closedWithoutComplete: EventEmitter<boolean>;
    readonly showWorkLog: EventEmitter<void>;
    readonly taskCreated: EventEmitter<Task>;
    readonly taskModified: EventEmitter<Task>;
    readonly triggerFired: EventEmitter<void>;
    showClass(): boolean;
    get showForm(): boolean;
    get header(): string;
    get subHeader(): string;
    get subSubHeader(): string;
    get subHeaderLink(): string;
    get userIsTaskReporter(): boolean;
    private _sendEmailOnNextSave;
    showAfterInsert: boolean;
    showNewForm: boolean;
    showModificationForm: boolean;
    currentActivity: Activity;
    editActivity: Activity;
    taskEditting: boolean;
    protected readonly Icon: typeof Icon;
    constructor(_dialogService: CoreDialogService, _boFactory: BusinessObjectFactory, _dictionary: SharedComponentsDictionaryService, iconService: IconCacheService, sharedService: SharedService);
    ngOnDestroy(): void;
    handleSaveForm(): void;
    onValid(): Promise<void>;
    trySendEmailFromNotificationBlock(): Promise<void>;
    handleCancelForm(): void;
    onPopupClose(): void;
    hide(): void;
    deleteTask(): Promise<void>;
    createNewTask(standalone?: boolean): Promise<void>;
    startModifyingTask(activity: Activity): Promise<void>;
    startModifyingTaskAndWorkLog(activity: Activity): Promise<void>;
    _createClone(): void;
    doHandleStatusChange(editting: boolean): void;
    updateEditActivity(activity: Activity): void;
    handleTriggerFired(): void;
    enableEmailOnNextSave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskModifierComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaskModifierComponent, "co-task-modifier", never, { "taskCfgNames": { "alias": "taskCfgNames"; "required": false; }; "workflowCategory": { "alias": "workflowCategory"; "required": false; }; "reference": { "alias": "reference"; "required": false; }; "referenceId": { "alias": "referenceId"; "required": false; }; "userGroupId": { "alias": "userGroupId"; "required": false; }; "relationId": { "alias": "relationId"; "required": false; }; "branchNo": { "alias": "branchNo"; "required": false; }; "createTaskOperation": { "alias": "createTaskOperation"; "required": false; }; "forceReadonly": { "alias": "forceReadonly"; "required": false; }; }, { "editingComplete": "editingComplete"; "activitySaved": "activitySaved"; "activityDeleted": "activityDeleted"; "closedWithoutComplete": "closedWithoutComplete"; "showWorkLog": "showWorkLog"; "taskCreated": "taskCreated"; "taskModified": "taskModified"; "triggerFired": "triggerFired"; }, never, never, false, never>;
}

declare abstract class BaseActivityOverviewComponent {
    private _dialogService;
    private _dictionaryService;
    private _sharedService;
    readonly icon: typeof Icon;
    readonly cfgNames: typeof ActivityCfgName;
    readonly taskCfgNames: ActivitiesTaskConfigNames;
    taskModifier: TaskModifierComponent;
    set viewModel(value: ActivityViewModel);
    set triggerToFireOnSave(value: WorkflowTrigger);
    get triggerToFireOnSave(): WorkflowTrigger;
    prepareWorkflowOperation: OperationCallbackSimpleFunction;
    userRelationId: number;
    userGroupId: number;
    handleOpenLinkSidebar: boolean;
    activityChange: EventEmitter<Activity>;
    readonly activityDeleted: EventEmitter<Activity>;
    triggerFired: EventEmitter<Activity>;
    genericTriggerFired: EventEmitter<Activity>;
    formCreated: EventEmitter<void>;
    formTriggerFired: EventEmitter<void>;
    openLink: EventEmitter<Activity>;
    linkClicked: EventEmitter<{
        module: string;
        id: string;
    }>;
    set activity(value: Activity);
    get activity(): Activity;
    workFlow: Workflow;
    targetDate: Date;
    deadlineDate: Date;
    activityName: string;
    activityDescription: string;
    activityTitle: string;
    activityContextTitle: string;
    openButtonLabel: string;
    overDue: boolean;
    userIsSupervisor: boolean;
    table: string;
    key: string;
    urls: string[];
    firstTriggerToCloseWF: WorkflowTrigger;
    isTask: boolean;
    hasTriggers: boolean;
    link: ModuleNavigationLink;
    linkDescription: string;
    sameDates: boolean;
    private _activity;
    private _viewModel;
    private _triggerToFireOnSave;
    constructor(_dialogService: CoreDialogService, _dictionaryService: SharedComponentsDictionaryService, _sharedService: SharedService);
    handleButtonEndClick(): void;
    handleGenericTriggerClick(event: WorkflowGenericTransition): Promise<void>;
    handleTriggerClick(eventTrigger: WorkflowTrigger): Promise<void>;
    handleOpenLink(event: MouseEvent, url?: string): void;
    handleOpenLinkOrUrl(event: MouseEvent): void;
    startModifyingTask(): void;
    showTaskFormAndWorkLog(): void;
    handleFormTriggerFired(): void;
    onSaveActivity(activity: Activity): void;
    onDeleteActivity(activity: Activity): void;
    private _prepareData;
    private _setFirstTriggerToCloseWF;
    private _openUrl;
    private _stopEventPropagation;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseActivityOverviewComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseActivityOverviewComponent, never, never, { "viewModel": { "alias": "viewModel"; "required": false; }; "triggerToFireOnSave": { "alias": "triggerToFireOnSave"; "required": false; }; "prepareWorkflowOperation": { "alias": "prepareWorkflowOperation"; "required": false; }; "userRelationId": { "alias": "userRelationId"; "required": false; }; "userGroupId": { "alias": "userGroupId"; "required": false; }; "handleOpenLinkSidebar": { "alias": "handleOpenLinkSidebar"; "required": false; }; }, { "activityChange": "activityChange"; "activityDeleted": "activityDeleted"; "triggerFired": "triggerFired"; "genericTriggerFired": "genericTriggerFired"; "formCreated": "formCreated"; "formTriggerFired": "formTriggerFired"; "openLink": "openLink"; "linkClicked": "linkClicked"; }, never, never, true, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseActivityOverviewComponent>;
}

declare class ComponentActivityOverviewComponent extends BaseActivityOverviewComponent {
    iconCacheService: IconCacheService;
    dialogService: CoreDialogService;
    dictionaryService: SharedComponentsDictionaryService;
    protected sharedService: SharedService;
    readonly Icon: typeof Icon;
    remarkIcon: Icon;
    workIcon: Icon;
    statusIcon: Icon;
    taskIcon: Icon;
    branchNo: string;
    showClass(): boolean;
    handleDocumentClick(): void;
    taskBoxActive: boolean;
    private activityColorMap;
    constructor(iconCacheService: IconCacheService, dialogService: CoreDialogService, dictionaryService: SharedComponentsDictionaryService, sharedService: SharedService);
    getActivityIcon(activity: Activity): Icon;
    getRandomColor(): string;
    getColorForActivity(activity: Activity): string;
    handleOpenTasks(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentActivityOverviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComponentActivityOverviewComponent, "co-component-activity-overview", never, { "remarkIcon": { "alias": "remarkIcon"; "required": false; }; "workIcon": { "alias": "workIcon"; "required": false; }; "statusIcon": { "alias": "statusIcon"; "required": false; }; "taskIcon": { "alias": "taskIcon"; "required": false; }; "branchNo": { "alias": "branchNo"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ComponentActivityListComponent extends BaseActivityListComponent implements OnDestroy, ScreenConfigAdapterComponent {
    protected sharedService: SharedService;
    readonly tabs: typeof PersonalActivityTabEnum;
    readonly icons: typeof Icon;
    readonly activityClass: typeof Activity;
    readonly activitySortType: typeof ActivitySortType;
    activityOverviewList: QueryList<ComponentActivityOverviewComponent>;
    showClass(): boolean;
    set table(value: TableName$1);
    get table(): TableName$1;
    set key(value: string);
    get key(): string;
    showActivityHeader: boolean;
    hideTitle: boolean;
    noFreeTasks: boolean;
    customTitle: string;
    userGroupId: number;
    relationId: number;
    branchNo: string;
    draggableActivities: boolean;
    taskView: boolean;
    hideInitialWorkflowTasks: boolean;
    componentActivitiesMethod: OperationCallbackSimpleFunction;
    setHasPausedNotificationsForWorkflowProcessOperation: OperationCallbackFunctionWithValidation;
    openLinkClick: EventEmitter<Activity>;
    amountActivityChanged: EventEmitter<number>;
    linkClicked: EventEmitter<{
        module: string;
        id: string;
    }>;
    formCreated: EventEmitter<void>;
    refreshRequested: EventEmitter<void>;
    showUsergroupActivitiesChanged: EventEmitter<void>;
    activityDragStarted: EventEmitter<ActivityViewModel>;
    activeTab: PersonalActivityTabEnum;
    activityList: ActivityViewModel[];
    trackByFn(index: number, vm: ActivityViewModel): any;
    objectConfigName: string;
    hidden: boolean;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    decimals: number;
    redErrorBackground: boolean;
    private _table;
    private _key;
    private _subs;
    private _activitiesList;
    constructor(sharedService: SharedService);
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    refreshActivities(): Promise<void>;
    getActivities(): Promise<void>;
    set activitiesList(allActivities: Activity[]);
    get activitiesList(): Activity[];
    getDelegatedActivities(): Promise<void>;
    showUsergroupActivitiesChange(): void;
    handleTriggerFired(activity: Activity): Promise<void>;
    handleGenericTriggerFired(activity: Activity): Promise<void>;
    handleFormTriggerFired(): Promise<void>;
    handleFormCreation(): void;
    handleChangedActivity(idx: number, activity: Activity): void;
    deleteActivity(activity: Activity): void;
    reset(): void;
    doFilterClicked(filter: {
        from: Date;
        to: Date;
    }): void;
    openFirstTask(): void;
    tryOpenTaskByTaskId(taskId: number): boolean;
    hasTaskActivity(activities: any[]): boolean;
    handleDragStart(dragEvent: DragEvent, activity: ActivityViewModel): void;
    private shouldHideActivity;
    private filterActivities;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentActivityListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComponentActivityListComponent, "co-component-activity-list", never, { "table": { "alias": "table"; "required": false; }; "key": { "alias": "key"; "required": false; }; "showActivityHeader": { "alias": "showActivityHeader"; "required": false; }; "hideTitle": { "alias": "hideTitle"; "required": false; }; "noFreeTasks": { "alias": "noFreeTasks"; "required": false; }; "customTitle": { "alias": "customTitle"; "required": false; }; "userGroupId": { "alias": "userGroupId"; "required": false; }; "relationId": { "alias": "relationId"; "required": false; }; "branchNo": { "alias": "branchNo"; "required": false; }; "draggableActivities": { "alias": "draggableActivities"; "required": false; }; "taskView": { "alias": "taskView"; "required": false; }; "hideInitialWorkflowTasks": { "alias": "hideInitialWorkflowTasks"; "required": false; }; "componentActivitiesMethod": { "alias": "componentActivitiesMethod"; "required": false; }; "setHasPausedNotificationsForWorkflowProcessOperation": { "alias": "setHasPausedNotificationsForWorkflowProcessOperation"; "required": false; }; "activitiesList": { "alias": "activitiesList"; "required": false; }; }, { "openLinkClick": "openLinkClick"; "amountActivityChanged": "amountActivityChanged"; "linkClicked": "linkClicked"; "formCreated": "formCreated"; "refreshRequested": "refreshRequested"; "showUsergroupActivitiesChanged": "showUsergroupActivitiesChanged"; "activityDragStarted": "activityDragStarted"; }, never, never, false, never>;
}

declare class PersonalActivityOverviewComponent extends BaseActivityOverviewComponent {
    showClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalActivityOverviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalActivityOverviewComponent, "co-personal-activity-overview", never, {}, {}, never, never, false, never>;
}

declare class PersonalActivityOverviewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalActivityOverviewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PersonalActivityOverviewModule, [typeof PersonalActivityOverviewComponent], [typeof i2.CommonModule], [typeof PersonalActivityOverviewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PersonalActivityOverviewModule>;
}

declare class TaskDetailsComponent extends BaseActivitySummaryComponent {
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    iconCacheService: IconCacheService;
    protected sharedService: SharedService;
    readonly Icon: typeof Icon;
    readonly blackListValidatorsArray: AsyncValidatorFn[];
    showStatusDropdown: boolean;
    set activity(value: Activity);
    showClass(): boolean;
    get activity(): Activity;
    constructor(dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, iconCacheService: IconCacheService, sharedService: SharedService);
    toggleStatusDropdown(): void;
    handleTriggerClickAndClose(trigger: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaskDetailsComponent, "co-task-details", never, { "activity": { "alias": "activity"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TaskDetailsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskDetailsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TaskDetailsModule, [typeof TaskDetailsComponent], [typeof SharedComponentsTranslationModule, typeof i3.InputTextModule, typeof i3.InputTextareaModule, typeof i3.IconModule, typeof i2.CommonModule], [typeof TaskDetailsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TaskDetailsModule>;
}

declare enum RelationType {
    Executive = "executive",
    Reporter = "reporter",
    Supervisor = "supervisor"
}
declare class ExecutiveSummaryBlockComponent extends BaseActivitySummaryComponent implements OnInit {
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    protected sharedService: SharedService;
    readonly RelationType: typeof RelationType;
    readonly Icon: typeof Icon;
    showClass(): boolean;
    private _textSearchParams;
    personnel: RelationListObject[];
    constructor(dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, sharedService: SharedService);
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExecutiveSummaryBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExecutiveSummaryBlockComponent, "co-executive-summary-block", never, {}, {}, never, never, false, never>;
}

declare class ActivitySummaryBlockModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivitySummaryBlockModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActivitySummaryBlockModule, [typeof ActivitySummaryBlockComponent], [typeof i3.FormModule, typeof i3.ButtonModule, typeof i2.CommonModule, typeof SharedComponentsTranslationModule, typeof i3.TemplateWrapperModule], [typeof ActivitySummaryBlockComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActivitySummaryBlockModule>;
}

declare class ExecutiveSummaryBlockModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ExecutiveSummaryBlockModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ExecutiveSummaryBlockModule, [typeof ExecutiveSummaryBlockComponent], [typeof SharedComponentsTranslationModule, typeof i3.ListOfValuesModule, typeof i3.InputDatePickerModule, typeof ActivitySummaryBlockModule], [typeof ExecutiveSummaryBlockComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ExecutiveSummaryBlockModule>;
}

declare class StatusSummaryBlockComponent extends BaseActivitySummaryComponent implements OnInit {
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    iconService: IconCacheService;
    protected sharedService: SharedService;
    showClass(): boolean;
    readonly Icon: typeof Icon;
    constructor(dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, iconService: IconCacheService, sharedService: SharedService);
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusSummaryBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusSummaryBlockComponent, "co-status-summary-block", never, {}, {}, never, never, false, never>;
}

declare class StatusSummaryBlockModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusSummaryBlockModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StatusSummaryBlockModule, [typeof StatusSummaryBlockComponent], [typeof ActivitySummaryBlockModule, typeof i3.InputDateRangePickerModule, typeof i3.InputDatePickerModule, typeof SharedComponentsTranslationModule, typeof i3.InputTextModule], [typeof StatusSummaryBlockComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StatusSummaryBlockModule>;
}

declare class CreationSummaryBlockComponent extends BaseActivitySummaryComponent implements OnInit, OnDestroy {
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    protected sharedService: SharedService;
    protected readonly locale: LanguageCode;
    readonly Icon: typeof Icon;
    taskCategories: TaskCategory[];
    chosenTaskCategory: TaskCategory;
    priorityDomainColl: CoDomainValue[];
    chosenPriority: CoDomainValue;
    editTemplate: TemplateRef<any>;
    showClass(): boolean;
    constructor(dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, sharedService: SharedService, locale: LanguageCode);
    ngOnDestroy(): void;
    ngOnInit(): void;
    handleTaskCategoryChange(taskCategory: TaskCategory): void;
    handlePriorityChange(domainValue: CoDomainValue): void;
    private _findDomainValueOfPriorityType;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreationSummaryBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CreationSummaryBlockComponent, "co-creation-summary-block", never, {}, {}, never, never, false, never>;
}

declare class CreationSummaryBlockModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CreationSummaryBlockModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CreationSummaryBlockModule, [typeof CreationSummaryBlockComponent], [typeof ActivitySummaryBlockModule, typeof i3.InputDatePickerModule, typeof i3.InputTextModule, typeof SharedComponentsTranslationModule, typeof i2.CommonModule, typeof i3.ListOfValuesModule], [typeof CreationSummaryBlockComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CreationSummaryBlockModule>;
}

declare class RoleEmailSelectorComponent implements OnInit, AfterViewInit {
    iconService: IconCacheService;
    sharedService: SharedService;
    private renderer;
    readonly icons: typeof Icon;
    recipientLabel: string;
    fieldLabel: string;
    extraLabel: string;
    set model(value: string[]);
    get model(): string[];
    set key(value: string);
    get key(): string;
    set workflowCategoryType(value: WorkflowCategoryType);
    get workflowCategoryType(): WorkflowCategoryType;
    readonly modelChange: EventEmitter<string[]>;
    emailAddressesAvailableForDropdown: RoleEmailaddress[];
    chosenEmailAddressesInDropDown: RoleEmailaddress[];
    emailModel: string;
    private _roleEmailAddresses;
    private _customEmailAddresses;
    private _model;
    private _key;
    private _workflowCategoryType;
    chipsWrapperWidth: number;
    showClass(): boolean;
    chipsWrapper: ElementRef;
    inputText: ElementRef;
    constructor(iconService: IconCacheService, sharedService: SharedService, renderer: Renderer2);
    ngOnInit(): Promise<void>;
    ngAfterViewInit(): void;
    fetchRoleEmailAddresses(): Promise<void>;
    roleChosen(roles: RoleEmailaddress[]): void;
    handleKeyPressed(event: KeyboardEvent): void;
    addEmail(): void;
    updateModel(): void;
    removeOptionFromModel(email: string): void;
    private updateChipsWrapperWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoleEmailSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RoleEmailSelectorComponent, "co-role-email-selector", never, { "recipientLabel": { "alias": "recipientLabel"; "required": false; }; "fieldLabel": { "alias": "fieldLabel"; "required": false; }; "extraLabel": { "alias": "extraLabel"; "required": false; }; "model": { "alias": "model"; "required": false; }; "key": { "alias": "key"; "required": false; }; "workflowCategoryType": { "alias": "workflowCategoryType"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, false, never>;
}

declare class RoleEmailSelectorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RoleEmailSelectorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RoleEmailSelectorModule, [typeof RoleEmailSelectorComponent], [typeof i3.ListOfValuesModule, typeof i3.InputTextModule, typeof SharedComponentsTranslationModule, typeof i3.IconModule, typeof i2.CommonModule], [typeof RoleEmailSelectorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RoleEmailSelectorModule>;
}

declare class EmailSelectorComponent implements OnInit {
    iconService: IconCacheService;
    sharedService: SharedService;
    readonly icons: typeof Icon;
    set key(value: string);
    get key(): string;
    set workflowCategoryType(value: WorkflowCategoryType);
    get workflowCategoryType(): WorkflowCategoryType;
    set emailAddresses(value: string[]);
    get emailAddresses(): string[];
    set bccEmailAddresses(value: string[]);
    get bccEmailAddresses(): string[];
    showBCC: boolean;
    buttonIcon: SafeHtml;
    readonly emailAddressesChange: EventEmitter<any>;
    readonly bccEmailAddressesChange: EventEmitter<any>;
    private _key;
    private _workflowCategoryType;
    private _emailAddresses;
    private _bccEmailAddresses;
    showClass(): boolean;
    constructor(iconService: IconCacheService, sharedService: SharedService);
    ngOnInit(): Promise<void>;
    toggleBCC(): void;
    handleEmailAddressesChanged(): void;
    handleBccEmailAddressesChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmailSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmailSelectorComponent, "co-email-selector", never, { "key": { "alias": "key"; "required": false; }; "workflowCategoryType": { "alias": "workflowCategoryType"; "required": false; }; "emailAddresses": { "alias": "emailAddresses"; "required": false; }; "bccEmailAddresses": { "alias": "bccEmailAddresses"; "required": false; }; }, { "emailAddressesChange": "emailAddressesChange"; "bccEmailAddressesChange": "bccEmailAddressesChange"; }, never, never, false, never>;
}

declare class EmailSelectorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EmailSelectorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EmailSelectorModule, [typeof EmailSelectorComponent], [typeof i3.ListOfValuesModule, typeof i3.InputTextModule, typeof SharedComponentsTranslationModule, typeof i3.IconModule, typeof i2.CommonModule, typeof RoleEmailSelectorModule, typeof i3.ButtonModule], [typeof EmailSelectorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EmailSelectorModule>;
}

declare class NotificationSummaryBlockModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationSummaryBlockModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationSummaryBlockModule, [typeof NotificationSummaryBlockComponent], [typeof ActivitySummaryBlockModule, typeof i3.ListOfValuesModule, typeof i3.ButtonModule, typeof i2.CommonModule, typeof RoleEmailSelectorModule, typeof EmailSelectorModule, typeof SharedComponentsTranslationModule], [typeof NotificationSummaryBlockComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationSummaryBlockModule>;
}

declare class ModifyTaskFormModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModifyTaskFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ModifyTaskFormModule, [typeof ModifyTaskFormComponent], [typeof SharedComponentsTranslationModule, typeof TaskDetailsModule, typeof i3.InputCheckboxModule, typeof ExecutiveSummaryBlockModule, typeof StatusSummaryBlockModule, typeof CreationSummaryBlockModule, typeof NotificationSummaryBlockModule, typeof ActivityListModule, typeof SimpleTagsModule, typeof i3.ButtonModule, typeof i2.CommonModule, typeof SimpleTagsFormModule], [typeof ModifyTaskFormComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ModifyTaskFormModule>;
}

declare class TaskModifyerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskModifyerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TaskModifyerModule, [typeof TaskModifierComponent], [typeof i3.FormModule, typeof i3.CoDialogModule, typeof SharedComponentsTranslationModule, typeof i2.CommonModule, typeof i3.ButtonModule, typeof ModifyTaskFormModule, typeof i3.IconModule], [typeof TaskModifierComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TaskModifyerModule>;
}

declare class ComponentActivityOverviewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentActivityOverviewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ComponentActivityOverviewModule, [typeof ComponentActivityOverviewComponent], [typeof i3.ButtonModule, typeof i2.CommonModule, typeof SharedComponentsTranslationModule, typeof i3.IconModule, typeof TaskModifyerModule], [typeof ComponentActivityOverviewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ComponentActivityOverviewModule>;
}

declare class ActivityListHeaderComponent {
    iconService: IconCacheService;
    readonly icons: typeof Icon;
    readonly activitySortType: typeof ActivitySortType;
    title: string;
    searchText: string;
    showUsergroupActivities: boolean;
    table: string;
    key: string;
    setHasPausedNotificationsForWorkflowProcessOperation: OperationCallbackFunctionWithValidation;
    searchTextChange: EventEmitter<string>;
    periodFilterClicked: EventEmitter<{
        from: Date;
        to: Date;
    }>;
    showUsergroupActivitiesChange: EventEmitter<boolean>;
    showClass(): boolean;
    constructor(iconService: IconCacheService);
    onToggleClicked(toggled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityListHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityListHeaderComponent, "co-activity-list-header", never, { "title": { "alias": "title"; "required": false; }; "searchText": { "alias": "searchText"; "required": false; }; "showUsergroupActivities": { "alias": "showUsergroupActivities"; "required": false; }; "table": { "alias": "table"; "required": false; }; "key": { "alias": "key"; "required": false; }; "setHasPausedNotificationsForWorkflowProcessOperation": { "alias": "setHasPausedNotificationsForWorkflowProcessOperation"; "required": false; }; }, { "searchTextChange": "searchTextChange"; "periodFilterClicked": "periodFilterClicked"; "showUsergroupActivitiesChange": "showUsergroupActivitiesChange"; }, never, never, false, never>;
}

declare class WorkflowNotificationToggleComponent implements OnInit {
    element: ElementRef;
    iconService: IconCacheService;
    sharedService: SharedService;
    private _overlayService;
    readonly icons: typeof Icon;
    table: string;
    key: string;
    setHasPausedNotificationsForWorkflowProcessOperation: OperationCallbackFunctionWithValidation;
    showClass(): boolean;
    workflowProcesses: WorkflowProcess[];
    showPopup: boolean;
    private _workflowPopupRef;
    constructor(element: ElementRef, iconService: IconCacheService, sharedService: SharedService, _overlayService: OverlayService);
    ngOnInit(): void;
    private _loadWorkflowProcesses;
    buttonClicked(): void;
    openPopup(): void;
    closePopup(): void;
    handleWorkflowToggle(workflow: WorkflowProcess): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowNotificationToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowNotificationToggleComponent, "co-workflow-notification-toggle", never, { "table": { "alias": "table"; "required": false; }; "key": { "alias": "key"; "required": false; }; "setHasPausedNotificationsForWorkflowProcessOperation": { "alias": "setHasPausedNotificationsForWorkflowProcessOperation"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WorkflowNotificationTogglePopupComponent implements OnDestroy {
    element: ElementRef;
    iconService: IconCacheService;
    readonly icons: typeof Icon;
    workflowProcesses: WorkflowProcess[];
    parentForOverlay: ElementRef;
    closePopupClicked: EventEmitter<any>;
    workflowProcessClicked: EventEmitter<WorkflowProcess>;
    constructor(element: ElementRef, iconService: IconCacheService);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowNotificationTogglePopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowNotificationTogglePopupComponent, "co-workflow-notification-toggle-popup", never, { "workflowProcesses": { "alias": "workflowProcesses"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; }, { "closePopupClicked": "closePopupClicked"; "workflowProcessClicked": "workflowProcessClicked"; }, never, never, false, never>;
}

declare class WorkflowNotificationToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowNotificationToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<WorkflowNotificationToggleModule, [typeof WorkflowNotificationToggleComponent, typeof WorkflowNotificationTogglePopupComponent], [typeof i3.ButtonModule, typeof i3.ClickoutsideModule, typeof SharedComponentsTranslationModule, typeof i3.IconModule, typeof i2.CommonModule, typeof i3.OverlayModule, typeof i3.AlignWithModule], [typeof WorkflowNotificationToggleComponent, typeof WorkflowNotificationTogglePopupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<WorkflowNotificationToggleModule>;
}

declare class PeriodFilterComponent implements OnDestroy {
    element: ElementRef;
    iconService: IconCacheService;
    private _overlayService;
    readonly icon: typeof Icon;
    readonly possibleFilters: string[];
    showPopup: boolean;
    showClass(): boolean;
    handleClick(): void;
    filterClicked: EventEmitter<{
        from: Date;
        to: Date;
    }>;
    currentFilter: string;
    private _periodPopupRef;
    constructor(element: ElementRef, iconService: IconCacheService, _overlayService: OverlayService);
    ngOnDestroy(): void;
    showFilterItems(): void;
    closePopup(): void;
    onFilterClick(filter: string): void;
    private _emitFilterClicked;
    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PeriodFilterComponent, "co-period-filter", never, {}, { "filterClicked": "filterClicked"; }, never, never, false, never>;
}

declare class PeriodFilterPopupComponent implements OnDestroy {
    element: ElementRef;
    showClass(): boolean;
    possibleFilters: string[];
    parentForOverlay: ElementRef;
    closePopup: EventEmitter<any>;
    filterClicked: EventEmitter<string>;
    constructor(element: ElementRef);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodFilterPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PeriodFilterPopupComponent, "co-period-filter-popup", never, { "possibleFilters": { "alias": "possibleFilters"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; }, { "closePopup": "closePopup"; "filterClicked": "filterClicked"; }, never, never, false, never>;
}

declare class PeriodFilterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PeriodFilterModule, [typeof PeriodFilterComponent, typeof PeriodFilterPopupComponent], [typeof SharedComponentsTranslationModule, typeof i3.IconModule, typeof i2.CommonModule, typeof i3.ClickoutsideModule, typeof i3.OverlayModule, typeof i3.AlignWithModule], [typeof PeriodFilterComponent, typeof PeriodFilterPopupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PeriodFilterModule>;
}

declare class ActivityListHeaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityListHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActivityListHeaderModule, [typeof ActivityListHeaderComponent], [typeof SharedComponentsTranslationModule, typeof i3.InputTextModule, typeof i3.ButtonModule, typeof WorkflowNotificationToggleModule, typeof PeriodFilterModule, typeof i2.CommonModule], [typeof ActivityListHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActivityListHeaderModule>;
}

declare class ComponentActivityListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentActivityListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ComponentActivityListModule, [typeof ComponentActivityListComponent], [typeof SharedComponentsTranslationModule, typeof i2.CommonModule, typeof i3.ButtonModule, typeof i3.CollapsibleModule, typeof PersonalActivityOverviewModule, typeof ComponentActivityOverviewModule, typeof ActivityListHeaderModule], [typeof ComponentActivityListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ComponentActivityListModule>;
}

declare class WorkflowInfoTilesComponent implements OnInit {
    iconCacheService: IconCacheService;
    sharedService: SharedService;
    protected readonly Icon: typeof Icon;
    readonly icons: typeof Icon;
    set workflowCategory(value: WorkflowCategoryType);
    workflowProcessInfoPerStatusClicked: EventEmitter<string>;
    WorkflowProcessInfoPerStatusCollection: WorkflowProcessInfoPerStatus[];
    activeStatus: string | null;
    private _workflowCategory;
    showClass(): boolean;
    constructor(iconCacheService: IconCacheService, sharedService: SharedService);
    ngOnInit(): void;
    workflowProcessInfoPerStatusClickedHandler(status: WorkflowProcessInfoPerStatus): void;
    private getWorkflowProcessInfoPerStatusCollection;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowInfoTilesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowInfoTilesComponent, "co-workflow-info-tiles", never, { "workflowCategory": { "alias": "workflowCategory"; "required": false; }; }, { "workflowProcessInfoPerStatusClicked": "workflowProcessInfoPerStatusClicked"; }, never, never, false, never>;
}

declare class WorkflowInfoTileComponent implements OnInit {
    iconCacheService: IconCacheService;
    colorService: ColorSequenceService;
    readonly Icon: typeof Icon;
    workflowProcessInfoPerStatus: WorkflowProcessInfoPerStatus;
    isActive: boolean;
    showClass(): boolean;
    get activeClass(): boolean;
    backgroundColor: string;
    constructor(iconCacheService: IconCacheService, colorService: ColorSequenceService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowInfoTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowInfoTileComponent, "co-workflow-info-tile", never, { "workflowProcessInfoPerStatus": { "alias": "workflowProcessInfoPerStatus"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WorkflowInfoTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowInfoTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<WorkflowInfoTileModule, [typeof WorkflowInfoTileComponent], [typeof SharedComponentsTranslationModule, typeof i3.IconModule], [typeof WorkflowInfoTileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<WorkflowInfoTileModule>;
}

declare class WorkflowInfoTilesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowInfoTilesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<WorkflowInfoTilesModule, [typeof WorkflowInfoTilesComponent], [typeof WorkflowInfoTileModule, typeof i2.CommonModule], [typeof WorkflowInfoTilesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<WorkflowInfoTilesModule>;
}

declare class TaskCreatorComponent implements OnInit, ScreenConfigAdapterComponent {
    iconService: IconCacheService;
    dictionaryService: SharedComponentsDictionaryService;
    sharedService: SharedService;
    private _dialogService;
    private _formMasterService;
    private _elementRef;
    readonly icons: typeof Icon;
    onDocumentMouseDown(event: MouseEvent): void;
    createForm: FormComponent;
    author: RelationSmallObject;
    branchNo: string;
    table: TableName$1;
    remarkAndWorkKey: string;
    taskKey: string;
    workflowCategoryType: WorkflowCategoryType;
    set allowRemarkCreation(allow: boolean);
    set allowWorkCreation(allow: boolean);
    set allowTaskCreation(allow: boolean);
    allowEmailing: boolean;
    activityCreated: EventEmitter<void>;
    taskCreated: EventEmitter<number>;
    showClass(): boolean;
    objectConfigName: string;
    hidden: boolean;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    decimals: number;
    redErrorBackground: boolean;
    optionCollection: IconListItem[];
    remarkListItem: IconListItem;
    workListItem: IconListItem;
    taskListItem: IconListItem;
    showFilesDialog: boolean;
    headerVisible: boolean;
    documents: CoDocument[];
    oldDocuments: CoDocument[];
    showEmailDialog: boolean;
    senderAddress: string;
    emailAddresses: string[];
    bccEmailAddresses: string[];
    emailRequest: activityEmailRequestData;
    createdTask: Task;
    createdRemark: Remark;
    createdWork: Work;
    chosenActivityType: IconListItem;
    remarkText: string;
    workDescription: string;
    taskName: string;
    taskDescription: string;
    private _allowRemarkCreation;
    private _allowWorkCreation;
    private _allowTaskCreation;
    constructor(iconService: IconCacheService, dictionaryService: SharedComponentsDictionaryService, sharedService: SharedService, _dialogService: CoreDialogService, _formMasterService: FormMasterService, _elementRef: ElementRef);
    ngOnInit(): Promise<void>;
    setupOptionCollection(): void;
    itemSelected(item: IconListItem): void;
    openAttachmentDialog(): void;
    attachmentDialogClosed(): void;
    attachmentDialogCancelled(): void;
    showHeader(): void;
    addedDocument(docs: CoDocument[]): Promise<void>;
    deletedDocument(doc: CoDocument): Promise<void>;
    createRemarkClicked(): Promise<void>;
    createWorkClicked(): Promise<void>;
    createTaskClicked(): Promise<void>;
    createTaskNoEmailClicked(): Promise<void>;
    private handleAfterTaskCreation;
    private createRemark;
    private createWork;
    private createTask;
    private handleAfterCreation;
    private sendEmailIfNeccesary;
    private findReportType;
    private findDefault;
    private startEmailing;
    private _createEmailParams;
    private _createEmailAddressString;
    private _createEmailSubject;
    private _clearFields;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskCreatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaskCreatorComponent, "co-task-creator", never, { "author": { "alias": "author"; "required": false; }; "branchNo": { "alias": "branchNo"; "required": false; }; "table": { "alias": "table"; "required": false; }; "remarkAndWorkKey": { "alias": "remarkAndWorkKey"; "required": false; }; "taskKey": { "alias": "taskKey"; "required": false; }; "workflowCategoryType": { "alias": "workflowCategoryType"; "required": false; }; "allowRemarkCreation": { "alias": "allowRemarkCreation"; "required": false; }; "allowWorkCreation": { "alias": "allowWorkCreation"; "required": false; }; "allowTaskCreation": { "alias": "allowTaskCreation"; "required": false; }; "allowEmailing": { "alias": "allowEmailing"; "required": false; }; }, { "activityCreated": "activityCreated"; "taskCreated": "taskCreated"; }, never, never, false, never>;
}

declare class TaskCreatorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskCreatorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TaskCreatorModule, [typeof TaskCreatorComponent], [typeof i3.ListOfValuesModule, typeof i3.InputTextModule, typeof i3.ButtonModule, typeof i2.CommonModule, typeof i3.CoDialogModule, typeof FilesUploadModule, typeof SharedComponentsTranslationModule, typeof i3.ListOfIconsModule, typeof i3.FormModule, typeof i3.IconModule, typeof RoleEmailSelectorModule, typeof EmailSelectorModule, typeof i3.InputTextareaModule], [typeof TaskCreatorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TaskCreatorModule>;
}

declare class PreferredPlanningComponent implements OnInit {
    locale: string;
    iconCacheService: IconCacheService;
    private _changeDetector;
    dayStart: ElementRef;
    readonly icons: typeof Icon;
    firstAvailableDate: Date;
    buttonLabel: string;
    headerText: string;
    headerDescription: string;
    disclaimerHeader: string;
    disclaimerDescription: string;
    loadMoreButtonText: string;
    eventsPerDay: AgendaEventPerDay[];
    selectedDate: Date;
    readonly buttonClick: EventEmitter<MouseEvent>;
    selected: EventEmitter<AgendaEventPerDay>;
    showClass: boolean;
    days: Date[];
    events: AgendaEventPerDay[];
    limit: number;
    selectedOption: AgendaEvent;
    moreLoadable: boolean;
    checkDisabled: boolean;
    constructor(locale: string, iconCacheService: IconCacheService, _changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    handleOptionSelect(event: boolean, selectedOption: AgendaEvent, date: Date, index: number): void;
    loadMore(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreferredPlanningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreferredPlanningComponent, "co-preferred-planning", never, { "firstAvailableDate": { "alias": "firstAvailableDate"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "headerText": { "alias": "headerText"; "required": false; }; "headerDescription": { "alias": "headerDescription"; "required": false; }; "disclaimerHeader": { "alias": "disclaimerHeader"; "required": false; }; "disclaimerDescription": { "alias": "disclaimerDescription"; "required": false; }; "loadMoreButtonText": { "alias": "loadMoreButtonText"; "required": false; }; "eventsPerDay": { "alias": "eventsPerDay"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; }, { "buttonClick": "buttonClick"; "selected": "selected"; }, never, never, false, never>;
}

declare class PreferredPlanningModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PreferredPlanningModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PreferredPlanningModule, [typeof PreferredPlanningComponent], [typeof i2.CommonModule, typeof i3.InputDatePickerModule, typeof i3.IconModule, typeof i3.ButtonModule, typeof i3.InputCheckboxModule, typeof i3.InputRadioButtonModule], [typeof PreferredPlanningComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PreferredPlanningModule>;
}

declare enum UserFormMode {
    Create = "Create",
    Edit = "Edit"
}

declare class FormBuilderUserFormComponent implements OnDestroy {
    private _detectorRef;
    private _boFactory;
    private _changeDetectorRef;
    private _sharedConnectorService;
    iconCacheService: IconCacheService;
    readonly formQuestionType: typeof FormQuestionType;
    readonly TableName: typeof TableName$1;
    readonly icons: typeof Icon;
    mode: UserFormMode;
    documents: CoDocument[];
    private _form;
    filesUploadComponent: FilesUploadComponent;
    showPopup: boolean;
    set form(form: Form);
    get form(): Form;
    userForm: FormResponse;
    table: TableName$1;
    key: string;
    readonly: boolean;
    enableQuestions: boolean;
    lineUUID: string;
    readonly cancelForm: EventEmitter<void>;
    readonly saveForm: EventEmitter<FormResponse>;
    readonly definitiveChange: EventEmitter<{
        value: boolean;
        lineUUID: string;
    }>;
    readonly createNewFormResponse: EventEmitter<FormResponse>;
    readonly errorMessage: EventEmitter<string>;
    cloneForm: Form;
    formResponse: FormResponse;
    activeQuestion: FormQuestion;
    gotoQuestion: number;
    showClass(): boolean;
    constructor(_detectorRef: ChangeDetectorRef, _boFactory: BusinessObjectFactory, _changeDetectorRef: ChangeDetectorRef, _sharedConnectorService: SharedConnectorService, iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    enabledNextQuestion(question: FormQuestion, answer?: FormQuestionAnswer | number): void;
    onValid(): void;
    handleCancelForm(): Promise<void>;
    handleDocumentDeleted(doc: CoDocument): void;
    handleDocumentChanged(doc: CoDocument): void;
    handleDocumentsAdded(event: any): void;
    private _prepareNewForm;
    private _prepareExistingForm;
    private _enableQuestions;
    private _loadDocs;
    handleDefinitiveChange(definitive: boolean): void;
    commitUserForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderUserFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormBuilderUserFormComponent, "co-form-builder-user-form", never, { "showPopup": { "alias": "showPopup"; "required": false; }; "form": { "alias": "form"; "required": false; }; "userForm": { "alias": "userForm"; "required": false; }; "table": { "alias": "table"; "required": false; }; "key": { "alias": "key"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "enableQuestions": { "alias": "enableQuestions"; "required": false; }; "lineUUID": { "alias": "lineUUID"; "required": false; }; }, { "cancelForm": "cancelForm"; "saveForm": "saveForm"; "definitiveChange": "definitiveChange"; "createNewFormResponse": "createNewFormResponse"; "errorMessage": "errorMessage"; }, never, never, false, never>;
}

declare class FormBuilderQuestionComponent implements OnInit {
    readonly formQuestionType: typeof FormQuestionType;
    readonly TableName: typeof TableName$1;
    readonly icons: typeof Icon;
    readonly modes: typeof UserFormMode;
    readonly formQuestionTypes: typeof FormQuestionType;
    mode: UserFormMode;
    question: FormQuestion;
    formResponse: FormQuestionResponse[];
    questionIndex: number;
    active: boolean;
    readonly: boolean;
    updateQuestion: EventEmitter<{
        question: any;
        answer?: any;
    }>;
    formResponseChange: EventEmitter<FormQuestionResponse[]>;
    dropDownModel: FormQuestionAnswer;
    ngOnInit(): void;
    changeLovOption(formQuestionResponse: FormQuestionResponse, value: FormQuestionAnswer): void;
    changeFormResponse(questionResponse: FormQuestionResponse): void;
    handleChangeQuestionResponse(response: string | BusinessObject): void;
    changeMultipleOption(id: string, formResponse: FormQuestionResponse, add: boolean): void;
    changeTime(formResponse: FormQuestionResponse, time: Date): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderQuestionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormBuilderQuestionComponent, "co-form-builder-question", never, { "mode": { "alias": "mode"; "required": false; }; "question": { "alias": "question"; "required": false; }; "formResponse": { "alias": "formResponse"; "required": false; }; "questionIndex": { "alias": "questionIndex"; "required": false; }; "active": { "alias": "active"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "updateQuestion": "updateQuestion"; "formResponseChange": "formResponseChange"; }, never, never, false, never>;
}

declare class UserFormInputScaleComponent implements OnInit {
    changeDetector: ChangeDetectorRef;
    label: string;
    readonly: boolean;
    required: boolean;
    disabled: boolean;
    scaleModel: string[] | BusinessObject[];
    idField: string;
    descriptionField: string;
    selected: string | BusinessObject;
    readonly selectionChange: EventEmitter<string | BusinessObject>;
    firstItem: string;
    lastItem: string;
    showClass(): boolean;
    constructor(changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    getModelItem(item: string | BusinessObject): string | BusinessObject;
    getTitle(modelItem: any): string;
    handleRadioButtonClick(active: boolean, item: string | BusinessObject): void;
    private _emitSelectionChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserFormInputScaleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserFormInputScaleComponent, "co-user-form-input-scale", never, { "label": { "alias": "label"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "scaleModel": { "alias": "scaleModel"; "required": false; }; "idField": { "alias": "idField"; "required": false; }; "descriptionField": { "alias": "descriptionField"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, false, never>;
}

declare class UserFormInputScaleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserFormInputScaleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UserFormInputScaleModule, [typeof UserFormInputScaleComponent], [typeof i2.CommonModule, typeof i3.InputRadioButtonModule, typeof SharedComponentsTranslationModule], [typeof UserFormInputScaleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UserFormInputScaleModule>;
}

declare class FormBuilderUserFormModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderUserFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormBuilderUserFormModule, [typeof FormBuilderUserFormComponent, typeof FormBuilderQuestionComponent], [typeof i2.CommonModule, typeof i3.FormModule, typeof i3.InputTextModule, typeof i3.InputTextareaModule, typeof i3.InputRadioButtonModule, typeof i3.InputCheckboxModule, typeof i3.ListOfValuesModule, typeof UserFormInputScaleModule, typeof i3.InputDatePickerModule, typeof i3.InputTimeModule, typeof SharedComponentsTranslationModule, typeof i3.CoDialogModule, typeof i3.ButtonModule, typeof i3.IconModule, typeof FilesUploadModule, typeof FileUploadPopupModule, typeof FileUploadModule], [typeof FormBuilderUserFormComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormBuilderUserFormModule>;
}

declare class CategoryViewObject {
    readonly identifier: any;
    readonly label: string;
    readonly items: any[];
    active: boolean;
    colorCss?: string;
    icon?: Icon;
    letter: string;
    itemCount: number;
    constructor(identifier: any, label: string, items: any[], active?: boolean, colorCss?: string, icon?: Icon);
    containsItem(item: any): boolean;
}

declare class CategoryViewObjectsWrappedObject<T> extends BusinessObject {
    dataObject: T;
    categoryViewObjects: CategoryViewObject[];
    get categoryLetters(): string;
    constructor(dataObject: T);
    firstCategoryColorCss(): string;
    firstCategoryLetter(): string;
    firstCategoryIcon(): Icon;
    getId(): BusinessObjectIDType;
    private _getFirstCatViewObj;
}

declare class TimelineComponent implements OnDestroy, DoCheck {
    private _changeRef;
    iconCacheService: IconCacheService;
    timelineDateItem: TemplateRef<any>;
    timelineBulletItem: TemplateRef<any>;
    timelineItem: TemplateRef<any>;
    timelineNewItem: TemplateRef<any>;
    set collection(collection: CategoryViewObjectsWrappedObject<any>[]);
    get collection(): CategoryViewObjectsWrappedObject<any>[];
    set inverted(value: boolean);
    get inverted(): boolean;
    showAddButton: boolean;
    addButtonDisabled: boolean;
    showAddButtonBottom: boolean;
    noAlternating: boolean;
    showTimestamp: boolean;
    showYear: boolean;
    readonly: boolean;
    bulletField: string;
    dateField: string;
    addLabel: string;
    remarkIcon: Icon;
    workIcon: Icon;
    statusIcon: Icon;
    taskIcon: Icon;
    hideInitialWorkflowTasks: boolean;
    addClick: EventEmitter<MouseEvent>;
    showClass: boolean;
    readonly Icon: typeof Icon;
    collectionCount: number;
    parsedCollection: {
        year: number;
        items: CategoryViewObjectsWrappedObject<any>[];
    }[];
    selectedItem: CategoryViewObjectsWrappedObject<any>;
    private _collectionCountLocal;
    private _collection;
    private _inverted;
    protected readonly ActivityType: typeof ActivityType;
    protected readonly icons: typeof Icon;
    constructor(_changeRef: ChangeDetectorRef, iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    ngDoCheck(): void;
    trackById(index: number, wrapper: {
        year: number;
        items: CategoryViewObjectsWrappedObject<any>[];
    }): BusinessObjectIDType;
    update(): void;
    onTimeLineItemClick(item: CategoryViewObjectsWrappedObject<any>): void;
    handleAddButtonClick(event: MouseEvent): void;
    addYearWhenCollectionEmpty(): void;
    getTimelineTrackId(item: any, index: number): string;
    getActivityClass(activity: Activity): string;
    getActivityIcon(activity: Activity): Icon;
    private _shouldHideActivity;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineComponent, "co-timeline", never, { "collection": { "alias": "collection"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "addButtonDisabled": { "alias": "addButtonDisabled"; "required": false; }; "showAddButtonBottom": { "alias": "showAddButtonBottom"; "required": false; }; "noAlternating": { "alias": "noAlternating"; "required": false; }; "showTimestamp": { "alias": "showTimestamp"; "required": false; }; "showYear": { "alias": "showYear"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "bulletField": { "alias": "bulletField"; "required": false; }; "dateField": { "alias": "dateField"; "required": false; }; "addLabel": { "alias": "addLabel"; "required": false; }; "remarkIcon": { "alias": "remarkIcon"; "required": false; }; "workIcon": { "alias": "workIcon"; "required": false; }; "statusIcon": { "alias": "statusIcon"; "required": false; }; "taskIcon": { "alias": "taskIcon"; "required": false; }; "hideInitialWorkflowTasks": { "alias": "hideInitialWorkflowTasks"; "required": false; }; }, { "addClick": "addClick"; }, ["timelineDateItem", "timelineBulletItem", "timelineItem", "timelineNewItem"], never, true, never>;
}

interface ActivitiesTimeLineAddButtonsConfigNames {
    addActivityTaskButton?: string;
    addActivityRemarkButton?: string;
    addActivityWorkButton?: string;
}

interface ActivitiesWorkConfigNames {
    workHeader?: string;
    workExecutive?: string;
    workCalculationKey?: string;
    workDescription?: string;
    workFile?: string;
    workedTime?: string;
}

interface ActivitiesTimeLineConfigNames {
    header?: string;
    buttons?: ActivitiesTimeLineAddButtonsConfigNames;
    task?: ActivitiesTaskConfigNames;
    work?: ActivitiesWorkConfigNames;
}

declare class MakeCategoryViewObjectsResult<T> {
    private _categories;
    private _wrappedCollectionItems;
    get categories(): CategoryViewObject[];
    get wrappedCollectionItems(): CategoryViewObjectsWrappedObject<T>[];
    constructor(_categories: CategoryViewObject[], _wrappedCollectionItems: CategoryViewObjectsWrappedObject<T>[]);
}

declare class ActivityTimelineService {
    private _sharedService;
    private _colorService;
    user: RelationSmallObject;
    private _activityTypeIconMap;
    constructor(_sharedService: SharedService, _colorService: ColorSequenceService);
    getActivities(table: TableName$1, key: string): Promise<Activity[]>;
    makeCategoryViewObjects<T>(collection: T[], groupByProp: string, domainName?: DomainName, masterDataClass?: typeof BusinessObject, enumClass?: any, colorSequence?: ColorSequenceName, customMasterDataClassDescriptionField?: string): Promise<MakeCategoryViewObjectsResult<T>>;
    getIconFromActivityType(activityType: ActivityType): Icon;
    createNewRemark(table: TableName$1, key: string): Promise<Activity>;
    createNewWork(table: TableName$1, key: string): Promise<Activity>;
    upsertActivity(activity: Activity): Promise<boolean>;
    private _getNextRemarkSequenceNumber;
    private _getNextWorkSequenceNumber;
    private _performGroupBy;
    private _generateWrappedCollectionItems;
    private _createColorSequenceMap;
    private _addColorsAndIconsToCategories;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityTimelineService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityTimelineService>;
}

declare class ActivityTimelineComponent implements OnInit {
    private _activityTimelineService;
    timeline: TimelineComponent;
    taskModifier: TaskModifierComponent;
    formBuilderForm: FormBuilderUserFormComponent;
    workLeaf: ElementRef;
    cfgNames: ActivitiesTimeLineConfigNames;
    collection: CategoryViewObjectsWrappedObject<Activity>[];
    readonly: boolean;
    key: string;
    table: TableName$1;
    workflowCategory: WorkflowCategoryType;
    reference: string;
    hideNew: boolean;
    showPlusButton: boolean;
    showOnTop: boolean;
    canEditTask: boolean;
    canDeleteTask: boolean;
    allowNewTask: boolean;
    autoSave: boolean;
    loggedInUser: RelationSmallObject;
    inverted: boolean;
    editActivities: boolean;
    showYear: boolean;
    hideInitialWorkflowTasks: boolean;
    saveActivity: EventEmitter<Activity>;
    onDeleteActivity: EventEmitter<Activity>;
    statusChange: EventEmitter<boolean>;
    activitiesLoaded: EventEmitter<void>;
    refreshRequested: EventEmitter<void>;
    showClass(): boolean;
    set activity(value: Activity);
    get activity(): Activity;
    activitySelectionShown: boolean;
    plusButtonElementClicked: any;
    showNewActivityLeaf: boolean;
    selectedActivity: Activity;
    addingOrEditingActivity: boolean;
    showFormBuilder: boolean;
    private _boFactory;
    private _activity;
    constructor(_activityTimelineService: ActivityTimelineService);
    ngOnInit(): void;
    createActivity(type: ActivityType): void;
    addNewActivity(event: MouseEvent): void;
    viewOrEditClick(event: MouseEvent, item: any): void;
    deleteActivity(event: MouseEvent, item: Activity): any;
    onDeleteTask(item: Activity): void;
    cancelEdit(): void;
    handleSaveActivity(activity: Activity): Promise<void>;
    reloadActivities(): Promise<void>;
    handleTriggerFired(): Promise<void>;
    handleClosedWithoutSave(bool: boolean): void;
    doSaveForm(form: FormResponse): Promise<void>;
    getRelationKind(author: RelationSmallObject): RelationKind$1;
    doCancelForm(): void;
    private _prepareCollection;
    private _prepareNewActivity;
    private _showNewActivityLeaf;
    private _hideNewActivityLeaf;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityTimelineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityTimelineComponent, "co-activity-timeline", never, { "cfgNames": { "alias": "cfgNames"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "key": { "alias": "key"; "required": false; }; "table": { "alias": "table"; "required": false; }; "workflowCategory": { "alias": "workflowCategory"; "required": false; }; "reference": { "alias": "reference"; "required": false; }; "hideNew": { "alias": "hideNew"; "required": false; }; "showPlusButton": { "alias": "showPlusButton"; "required": false; }; "showOnTop": { "alias": "showOnTop"; "required": false; }; "canEditTask": { "alias": "canEditTask"; "required": false; }; "canDeleteTask": { "alias": "canDeleteTask"; "required": false; }; "allowNewTask": { "alias": "allowNewTask"; "required": false; }; "autoSave": { "alias": "autoSave"; "required": false; }; "loggedInUser": { "alias": "loggedInUser"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; "editActivities": { "alias": "editActivities"; "required": false; }; "showYear": { "alias": "showYear"; "required": false; }; "hideInitialWorkflowTasks": { "alias": "hideInitialWorkflowTasks"; "required": false; }; }, { "saveActivity": "saveActivity"; "onDeleteActivity": "onDeleteActivity"; "statusChange": "statusChange"; "activitiesLoaded": "activitiesLoaded"; "refreshRequested": "refreshRequested"; }, never, never, false, never>;
}

declare class ActivityLeafComponent {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    readonly ActivityType: typeof ActivityType;
    form: FormComponent;
    set model(value: Activity);
    get model(): Activity;
    myCfgNames: ActivitiesTimeLineConfigNames;
    key: string;
    readonly: boolean;
    noEdit: boolean;
    noDelete: boolean;
    canEditTask: boolean;
    editActivities: boolean;
    okClick: EventEmitter<Activity>;
    cancelClick: EventEmitter<Activity>;
    viewOrEditClick: EventEmitter<MouseEvent>;
    deleteClick: EventEmitter<MouseEvent>;
    triggerFired: EventEmitter<void>;
    showClass: boolean;
    readonly trackByIndex: Function;
    clone: Activity;
    private _model;
    private _boFactory;
    constructor(iconCacheService: IconCacheService);
    handleOkClick(event: MouseEvent): void;
    handleValidSubmit(): void;
    handleCancelClick(event: MouseEvent): void;
    handleViewOrEditClick(event: MouseEvent): void;
    changeActivityDescription(text: string): void;
    private _getActivityFromModel;
    private _cloneModelToUse;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityLeafComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityLeafComponent, "co-activity-leaf", never, { "model": { "alias": "model"; "required": false; }; "myCfgNames": { "alias": "myCfgNames"; "required": false; }; "key": { "alias": "key"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "noEdit": { "alias": "noEdit"; "required": false; }; "noDelete": { "alias": "noDelete"; "required": false; }; "canEditTask": { "alias": "canEditTask"; "required": false; }; "editActivities": { "alias": "editActivities"; "required": false; }; }, { "okClick": "okClick"; "cancelClick": "cancelClick"; "viewOrEditClick": "viewOrEditClick"; "deleteClick": "deleteClick"; "triggerFired": "triggerFired"; }, never, never, false, never>;
}

declare class NewActivityLeafComponent {
    iconCacheService: IconCacheService;
    private _elementRef;
    private _activityService;
    set activity(value: Activity);
    get activity(): Activity;
    myCfgNames: ActivitiesTimeLineConfigNames;
    okClick: EventEmitter<Activity>;
    cancelClick: EventEmitter<void>;
    showClass: boolean;
    key: string;
    icon: Icon;
    private _activity;
    constructor(iconCacheService: IconCacheService, _elementRef: ElementRef, _activityService: ActivityTimelineService);
    scrollLeafIntoView(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NewActivityLeafComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NewActivityLeafComponent, "co-new-activity-leaf", never, { "activity": { "alias": "activity"; "required": false; }; "myCfgNames": { "alias": "myCfgNames"; "required": false; }; }, { "okClick": "okClick"; "cancelClick": "cancelClick"; }, never, never, false, never>;
}

declare class BaseActivityLeafComponent implements ScreenConfigAdapterComponent {
    private _fileTypeImgPipe;
    decimals: number;
    forceReadonly: boolean;
    maxLength: number;
    objectConfigName: string;
    redErrorBackground: boolean;
    required: boolean;
    readonly fileTypeImage: FileTypeInternal;
    readonly blackListValidatorsArray: AsyncValidatorFn[];
    readonly trackByIndex: Function;
    activity: Activity;
    key: string;
    readonly: boolean;
    noEdit: boolean;
    noDelete: boolean;
    canEditTask: boolean;
    activityChange: EventEmitter<Activity>;
    hidden: boolean;
    constructor(_fileTypeImgPipe: FileTypeImagePipe);
    imageDataUri(document: CoDocument): string;
    onDocClick(document: CoDocument): void;
    changeActivityDescription(text: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseActivityLeafComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseActivityLeafComponent, never, never, { "activity": { "alias": "activity"; "required": false; }; "key": { "alias": "key"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "noEdit": { "alias": "noEdit"; "required": false; }; "noDelete": { "alias": "noDelete"; "required": false; }; "canEditTask": { "alias": "canEditTask"; "required": false; }; }, { "activityChange": "activityChange"; }, never, never, true, never>;
}

declare class FormActivityLeafComponent extends BaseActivityLeafComponent {
    showClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormActivityLeafComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormActivityLeafComponent, "co-form-activity-leaf", never, {}, {}, never, never, false, never>;
}

declare class RemarkActivityLeafComponent extends BaseActivityLeafComponent implements OnInit {
    private _sharedService;
    private _cfgService;
    myCfgNames: ActivitiesWorkConfigNames;
    showClass: boolean;
    constructor(fileTypeImgPipe: FileTypeImagePipe, _sharedService: SharedService, _cfgService: BaseModuleScreenConfigService);
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemarkActivityLeafComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RemarkActivityLeafComponent, "co-remark-activity-leaf", never, { "myCfgNames": { "alias": "myCfgNames"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TaskActivityLeafComponent extends BaseActivityLeafComponent implements OnInit {
    iconCacheService: IconCacheService;
    protected dictionaryService: SharedComponentsDictionaryService;
    protected dialogService: CoreDialogService;
    private _sharedService;
    showClass: boolean;
    myCfgNames: ActivitiesWorkConfigNames;
    readonly triggerFired: EventEmitter<ActivityWorkflow>;
    viewOrEditClick: EventEmitter<MouseEvent>;
    protected readonly icons: typeof Icon;
    private _workFlow;
    constructor(fileTypeImgPipe: FileTypeImagePipe, iconCacheService: IconCacheService, dictionaryService: SharedComponentsDictionaryService, dialogService: CoreDialogService, _sharedService: SharedService);
    ngOnInit(): Promise<void>;
    handleManualTriggerClick(trigger: WorkflowTrigger): Promise<void>;
    handleViewOrEditClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskActivityLeafComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaskActivityLeafComponent, "co-task-activity-leaf", never, { "myCfgNames": { "alias": "myCfgNames"; "required": false; }; }, { "triggerFired": "triggerFired"; "viewOrEditClick": "viewOrEditClick"; }, never, never, false, never>;
}

declare class WorkActivityLeafComponent extends BaseActivityLeafComponent implements OnInit {
    private _sharedService;
    private _cfgService;
    myCfgNames: ActivitiesWorkConfigNames;
    showClass: boolean;
    calculationDescription: string;
    calculationKeys: CoDomainValue[];
    showCalculationKey: boolean;
    showDocuments: boolean;
    showDescription: boolean;
    showWorkedTime: boolean;
    constructor(fileTypeImgPipe: FileTypeImagePipe, _sharedService: SharedService, _cfgService: BaseModuleScreenConfigService);
    ngOnInit(): Promise<void>;
    getCalculationDescription(): string;
    handleCalculationKeyChange(code: string): void;
    handleExecutiveChange(id: number): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkActivityLeafComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkActivityLeafComponent, "co-work-activity-leaf", never, { "myCfgNames": { "alias": "myCfgNames"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ActivityLinkComponent implements ScreenConfigAdapterComponent {
    iconCacheService: IconCacheService;
    readonly icons: typeof Icon;
    objectConfigName: string;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    decimals: number;
    redErrorBackground: boolean;
    hidden: boolean;
    icon: Icon;
    linkTxt: string;
    showClass: boolean;
    constructor(iconCacheService: IconCacheService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityLinkComponent, "co-activity-link", never, { "icon": { "alias": "icon"; "required": false; }; "linkTxt": { "alias": "linkTxt"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ActivityTypeSelectComponent {
    readonly icon: typeof Icon;
    readonly activityType: typeof ActivityType;
    cfgNames: ActivitiesTimeLineAddButtonsConfigNames;
    allowNewTask: boolean;
    activitySelect: EventEmitter<ActivityType>;
    showClass: boolean;
    handleActivitySelect(type: ActivityType): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityTypeSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityTypeSelectComponent, "co-activity-type-select", never, { "cfgNames": { "alias": "cfgNames"; "required": false; }; "allowNewTask": { "alias": "allowNewTask"; "required": false; }; }, { "activitySelect": "activitySelect"; }, never, never, false, never>;
}

declare class InputDurationComponent implements ScreenConfigAdapterComponent {
    iconCacheService: IconCacheService;
    readonly icon: typeof Icon;
    readonly regex: string;
    inputTextComp: InputTextComponent;
    inputTextRef: ElementRef;
    placeholder: string;
    disabled: boolean;
    customWidth: boolean;
    set model(model: number);
    get model(): number;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    hoursPerDay: number;
    labelSuffix: string;
    readonly modelChange: EventEmitter<number>;
    readonly blur: EventEmitter<string>;
    showClass(): boolean;
    objectConfigName: string;
    hidden: boolean;
    defaultValue?: ObjectConfigurationDefaultValueType;
    decimals: number;
    redErrorBackground: boolean;
    configObject?: ObjectConfiguration;
    private _modelFromSetter;
    private _minutes;
    constructor(iconCacheService: IconCacheService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    setModel(model: number): void;
    private _emitModelChange;
    private _setInputTextText;
    private _convertToMinutes;
    private _convertToDuration;
    requestFocus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputDurationComponent, "co-input-duration", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "customWidth": { "alias": "customWidth"; "required": false; }; "model": { "alias": "model"; "required": false; }; "required": { "alias": "required"; "required": false; }; "forceReadonly": { "alias": "forceReadonly"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "hoursPerDay": { "alias": "hoursPerDay"; "required": false; }; "labelSuffix": { "alias": "labelSuffix"; "required": false; }; }, { "modelChange": "modelChange"; "blur": "blur"; }, never, never, false, never>;
}

declare class InputDurationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDurationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InputDurationModule, [typeof InputDurationComponent], [typeof i2.CommonModule, typeof i3.InputTextModule], [typeof InputDurationComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InputDurationModule>;
}

declare class InputSearchEmployeeComponent implements ScreenConfigAdapterComponent, OnInit {
    private _sharedService;
    model: number;
    placeholder: string;
    disabled: boolean;
    customWidth: boolean;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    modelChange: EventEmitter<number>;
    showClass(): boolean;
    objectConfigName: string;
    hidden: boolean;
    defaultValue?: ObjectConfigurationDefaultValueType;
    decimals: number;
    redErrorBackground: boolean;
    configObject?: ObjectConfiguration;
    modelForLov: RelationListObject;
    constructor(_sharedService: SharedService);
    ngOnInit(): Promise<void>;
    getCollection: (search: string) => Promise<RelationListObject[]>;
    handleModelChange(model: RelationListObject): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputSearchEmployeeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputSearchEmployeeComponent, "co-input-search-employee", never, { "model": { "alias": "model"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "customWidth": { "alias": "customWidth"; "required": false; }; "required": { "alias": "required"; "required": false; }; "forceReadonly": { "alias": "forceReadonly"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, false, never>;
}

declare class InputSearchEmployeeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputSearchEmployeeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InputSearchEmployeeModule, [typeof InputSearchEmployeeComponent], [typeof i2.CommonModule, typeof i3.ListOfValuesModule, typeof SharedComponentsTranslationModule], [typeof InputSearchEmployeeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InputSearchEmployeeModule>;
}

declare class InputCalculationKeyComponent implements ScreenConfigAdapterComponent {
    private _sharedService;
    model: string;
    placeholder: string;
    disabled: boolean;
    customWidth: boolean;
    required: boolean;
    forceReadonly: boolean;
    readonly: boolean;
    maxLength: number;
    modelChange: EventEmitter<string>;
    showClass: boolean;
    objectConfigName: string;
    hidden: boolean;
    defaultValue?: ObjectConfigurationDefaultValueType;
    decimals: number;
    redErrorBackground: boolean;
    configObject?: ObjectConfiguration;
    modelForLov: CoDomainValue;
    collection: CoDomainValue[];
    constructor(_sharedService: SharedService);
    ngOnInit(): Promise<void>;
    handleModelChange(model: CoDomainValue): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCalculationKeyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputCalculationKeyComponent, "co-input-calculation-key", never, { "model": { "alias": "model"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "customWidth": { "alias": "customWidth"; "required": false; }; "required": { "alias": "required"; "required": false; }; "forceReadonly": { "alias": "forceReadonly"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, false, never>;
}

declare class InputCalculationKeyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCalculationKeyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InputCalculationKeyModule, [typeof InputCalculationKeyComponent], [typeof i2.CommonModule, typeof i3.ListOfValuesModule, typeof SharedComponentsTranslationModule], [typeof InputCalculationKeyComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InputCalculationKeyModule>;
}

declare class AvatarService {
    private readonly _sharedService;
    private readonly _colorSequenceService;
    readonly relationDataUpdated: EventEmitter<number>;
    private _relationColorMap;
    private _relationAvatarsMap;
    private _relationRelationMap;
    constructor(_sharedService: SharedService, _colorSequenceService: ColorSequenceService);
    getRelationColor(relation: Relation | RelationSmallObject, sequenceName?: ColorSequenceName): string;
    getRelationColorById(relationId: number, sequenceName?: ColorSequenceName): string;
    getRelationAvatar(relation: Relation | RelationSmallObject): Promise<string>;
    setAvatarForRelationId(relationId: number, thumbnail: string): void;
    updateRelationData(relation: Relation | RelationSmallObject): void;
    private updateRelationAvatar;
    getRelation(relationId: number, relation: Relation | RelationSmallObject): Relation | RelationSmallObject;
    setRelation(relationId: number, relation: Relation): void;
    updateRelation(relationId: number, relation: Relation): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AvatarService>;
}

declare class AvatarComponent {
    iconCacheService: IconCacheService;
    private _promptService;
    private _avatarService;
    private _colorSequenceService;
    private _sharedService;
    private _changeDetector;
    readonly icons: typeof Icon;
    input: ElementRef;
    canChangeAvatar: boolean;
    checkOwnership: boolean;
    colorSequence: ColorSequenceName;
    sequence: number;
    tooltipText: string;
    set icon(value: Icon);
    set staticImageUri(imageData: string);
    set staticInitials(initials: string);
    set relation(relation: Relation);
    set relationId(relationId: number);
    loggedInRelation: {
        relationId: number;
        userName: string;
    };
    avatarDocChange: EventEmitter<CoDocument>;
    showClass: boolean;
    backgroundColor: string;
    displayName: string;
    handleMouseEnter(): void;
    handleMouseLeave(): void;
    onClick(): void;
    ownAvatar: boolean;
    imageData: string;
    staticIcon: Icon;
    initials: string;
    hoverTimer: any;
    private _hoverTimeout;
    private _relation;
    private _relationId;
    private _staticImageData;
    private _staticInitials;
    private _destroyed;
    private _subs;
    private _maxAvatarSize;
    constructor(iconCacheService: IconCacheService, _promptService: PromptService, _avatarService: AvatarService, _colorSequenceService: ColorSequenceService, _sharedService: SharedService, _changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onFileChangeEvent(event: any, input?: HTMLInputElement): void;
    updateAvatar(): Promise<void>;
    uploadTheAvatar(): void;
    private _staticSet;
    private _setAvatarDataByRelation;
    private _setInitials;
    private _isOwnAvatar;
    private _changeDisplayName;
    private _setFileAsAvatarToCurrentRelation;
    private setDocProperties;
    private _detectChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "co-avatar", never, { "canChangeAvatar": { "alias": "canChangeAvatar"; "required": false; }; "checkOwnership": { "alias": "checkOwnership"; "required": false; }; "colorSequence": { "alias": "colorSequence"; "required": false; }; "sequence": { "alias": "sequence"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "staticImageUri": { "alias": "staticImageUri"; "required": false; }; "staticInitials": { "alias": "staticInitials"; "required": false; }; "relation": { "alias": "relation"; "required": false; }; "relationId": { "alias": "relationId"; "required": false; }; "loggedInRelation": { "alias": "loggedInRelation"; "required": false; }; }, { "avatarDocChange": "avatarDocChange"; }, never, never, false, never>;
}

declare class AvatarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarModule, [typeof AvatarComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof ImageDisplayModule], [typeof AvatarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AvatarModule>;
}

declare class ActivityTimelineModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityTimelineModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActivityTimelineModule, [typeof ActivityTimelineComponent, typeof ActivityLeafComponent, typeof NewActivityLeafComponent, typeof FormActivityLeafComponent, typeof RemarkActivityLeafComponent, typeof TaskActivityLeafComponent, typeof WorkActivityLeafComponent, typeof ActivityLinkComponent, typeof ActivityTypeSelectComponent], [typeof i2.CommonModule, typeof TimelineComponent, typeof i3.IconModule, typeof TaskModifyerModule, typeof FormBuilderUserFormModule, typeof i3.FormModule, typeof SharedComponentsTranslationModule, typeof i3.ButtonModule, typeof i3.ScreenConfigurationModule, typeof i3.AlignWithModule, typeof i3.ClickoutsideModule, typeof i3.OverlayModule, typeof InputDurationModule, typeof InputSearchEmployeeModule, typeof i3.InputTextareaModule, typeof FilesUploadModule, typeof ImageDisplayModule, typeof i3.ImageModule, typeof InputCalculationKeyModule, typeof AvatarModule], [typeof ActivityTimelineComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActivityTimelineModule>;
}

interface FingerPrintResult {
    fingerPrint?: string;
    deviceLabel?: string;
}

declare class FingerPrintService {
    private readonly _options;
    private _fingerPrint;
    constructor();
    getFingerPrint(): Promise<FingerPrintResult>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FingerPrintService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FingerPrintService>;
}

declare const NULL_AGENDA_EVENT: AgendaEvent;
declare const NULL_AGENDA_EVENT_PER_DAY: AgendaEventPerDay;
declare const NULL_MONTH: Month;
declare const NULL_WEEK: Week;
declare const NULL_DAY: Day;

declare enum TimePeriod {
    LastSevenDays = "LW",
    LastMonth = "LM",
    LastYear = "LY",
    LastCalendarYear = "LCY",
    CurrentCalendarYear = "CCY",
    Custom = "C"
}

declare class DateRange {
    startDate: Date;
    endDate: Date;
    selectedTimePeriod: TimePeriod;
    constructor();
}

declare class SharedSettings extends Options {
}

interface TreeViewNodeModel {
    /**
     * Identifier of the node.
     * @returns {number}
     */
    getId(): any;
    /**
     * Set the identifier of the node.
     * @param value
     * @returns {TreeViewNodeModel}
     */
    setId(value: any): TreeViewNodeModel;
    /**
     * Children of the node.
     * @returns {TreeViewNode[]}
     */
    getChildren(): TreeViewNodeModel[];
    /**
     * Set the children of the node.
     * @returns {TreeViewNode[]}
     */
    setChildren(children: TreeViewNodeModel[]): TreeViewNodeModel;
    /**
     * Size of the tree with root this.
     * @returns {number}
     */
    getSize(): number;
    /**
     * The hierarchical level.
     * @returns {number}
     */
    getLevel(): number;
    /**
     * Set the hierarchical level.
     * @param {number} level
     * @returns {TreeViewNodeModel}
     */
    setLevel(level: number): TreeViewNodeModel;
    /**
     * If the node is currently expanded.
     * @returns {boolean}
     */
    isExpanded(): boolean;
    /**
     * Set the expanded value of the node.
     * @param {boolean} value
     * @returns {TreeViewNodeModel}
     */
    setExpanded(value: boolean): TreeViewNodeModel;
    /**
     * If the node is currently filtered.
     * @returns {boolean}
     */
    isFiltered(): boolean;
    /**
     * Set the filtered value of the node.
     * @param {boolean} value
     * @returns {TreeViewNodeModel}
     */
    setFiltered(value: boolean): TreeViewNodeModel;
    /**
     * Show breadCrumbs.
     * @returns {string}
     */
    getShowRoute(): string;
    /**
     * Set the show breadCrumbs.
     * @returns {string}
     */
    setShowRoute(value: string): TreeViewNodeModel;
    /**
     * Edit breadCrumbs.
     * @returns {string}
     */
    getEditRoute(): string;
    /**
     * Set the edit breadCrumbs.
     * @returns {string}
     */
    setEditRoute(value: string): TreeViewNodeModel;
    /**
     * Toggle expanded.
     */
    toggle(): TreeViewNodeModel;
    /**
     * Set the expand value for the tree with root this.
     * @param value
     */
    expand(value: boolean): TreeViewNodeModel;
    /**
     * Set the value of the property filtered for each node of the tree with root this.
     * @param term
     */
    filter(term: string): TreeViewNodeModel;
    /**
     * The tree which the node belong to.
     * @returns {TreeViewModel}
     */
    getTree(): TreeViewModel;
    /**
     * Set the tree which the node belong to.
     * @returns {TreeViewModel}
     */
    setTree(tree: TreeViewModel): TreeViewNodeModel;
    /**
     * First rendered node.
     * @returns {boolean}
     */
    isFirst(): boolean;
    /**
     * Last rendered node.
     * @returns {boolean}
     */
    isLast(): boolean;
    /**
     * Css classes.
     */
    classes(...args: any[]): any;
    /**
     * Css styles.
     * @param args
     */
    styles(...args: any[]): any;
}

interface TreeViewModel {
    /**
     * Set the nodes of the tree.
     * @param {TreeViewNodeModel[]} nodes
     * @returns {TreeViewModel}
     */
    withNodes(nodes: TreeViewNodeModel[]): TreeViewModel;
    /**
     * Get the nodes of the tree.
     * @returns {TreeViewNodeModel[]}
     */
    getNodes(): TreeViewNodeModel[];
    /**
     * Handler on expand tree click.
     */
    onExpandTree(): void;
    /**
     * Handler on collapse tree click.
     */
    onCollapseTree(): void;
    /**
     * Handler on filter input.
     * @param e
     */
    onFilterInput(e: any): void;
    /**
     * Foreach node of the tree applies the filter method implementation.
     * @param {string} term
     */
    filterTree(term: string): void;
    /**
     * The number of the node of the tree.
     * @returns {number}
     */
    getSize(): number;
    /**
     * First rendered node of the tree.
     * @returns {TreeViewNodeModel}
     */
    getFirst(): TreeViewNodeModel;
    /**
     * Last rendered node of the tree.
     * @returns {TreeViewNodeModel}
     */
    getLast(): TreeViewNodeModel;
}

declare class TreeView implements TreeViewModel {
    private nodes;
    private count;
    private firstNode;
    private lastNode;
    private onFiltering;
    constructor();
    withNodes(nodes: TreeViewNodeModel[]): TreeViewModel;
    getNodes(): TreeViewNodeModel[];
    onExpandTree(): void;
    onCollapseTree(): void;
    onFilterInput(e: any): void;
    getSize(): number;
    private computeSize;
    filterTree(term: string): void;
    getFirst(): TreeViewNodeModel;
    getLast(): TreeViewNodeModel;
    private setFirstAndLast;
    private lastChildren;
    private resetTree;
    private resetNode;
}

declare class TreeViewNode implements TreeViewNodeModel {
    title: string;
    private tree;
    private id;
    private level;
    private children;
    private expanded;
    private filtered;
    private showRoute;
    private editRoute;
    constructor();
    getId(): number;
    setId(value: number): TreeViewNodeModel;
    getChildren(): TreeViewNodeModel[];
    hasChildren(): boolean;
    setChildren(children: TreeViewNodeModel[]): TreeViewNodeModel;
    containsChildWithGivenData(childData: any): boolean;
    getSize(): number;
    getLevel(): number;
    setLevel(level: number): TreeViewNodeModel;
    isExpanded(): boolean;
    setExpanded(value: boolean): TreeViewNodeModel;
    isFiltered(): boolean;
    setFiltered(value: boolean): TreeViewNodeModel;
    getShowRoute(): string;
    setShowRoute(value: string): TreeViewNodeModel;
    getEditRoute(): string;
    setEditRoute(value: string): TreeViewNodeModel;
    toggle(): TreeViewNodeModel;
    expand(value: boolean): TreeViewNodeModel;
    filter(term: string): TreeViewNodeModel;
    protected filterImpl(term: string, force: boolean, value: boolean): void;
    protected filterCondition(term: string): boolean;
    getTree(): TreeViewModel;
    setTree(tree: TreeViewModel): TreeViewNodeModel;
    isFirst(): boolean;
    isLast(): boolean;
    styles(): any;
    classes(focusId: number): any;
}

interface TreeViewNodeItemOptions {
    idField: string;
    parentIdField: string;
    descriptionField: string;
    colorField: string;
    imgField: string;
    iconField: string;
    leafIcon: Icon;
    leafConditionField: string;
}

export { ActivityListComponent, ActivityListModule, ActivityTimelineComponent, ActivityTimelineModule, AgendaEvent, AgendaEventPerDay, CalendarView, CoLinearGaugeComponent, CoLinearGaugeModule, ComponentActivityListComponent, ComponentActivityListModule, DatePlanningComponent, DatePlanningModule, DateRange, Day, DocsignComponent, DocsignModule, FilesUploadComponent, FilesUploadModule, FingerPrintService, FormBuilderUserFormComponent, FormBuilderUserFormModule, GaugeColor$1 as GaugeColor, KeyPadComponent, KeyPadModule, LayoutSwitcherComponent, LayoutSwitcherModule, Month, NULL_AGENDA_EVENT, NULL_AGENDA_EVENT_PER_DAY, NULL_DAY, NULL_MONTH, NULL_WEEK, PreferredPlanningComponent, PreferredPlanningModule, RoleEmailSelectorComponent, RoleEmailSelectorModule, SendMethod, SendMethodDialogComponent, SendMethodDialogModule, SharedComponentsDictionaryService, SharedComponentsTranslationModule, SharedEventService, SharedLocalizePipe, SharedService, SharedSettings, SimpleTagsComponent, SimpleTagsFormComponent, SimpleTagsFormModule, SimpleTagsModule, StatusbarComponent, StatusbarModule, StatusbarPopupComponent, StockComponent, StockModule, TagTreeItem, TaskCreatorComponent, TaskCreatorModule, TimeWindow, TreeObject, TreeView, TreeViewNode, UserFormMode, Week, Weekday, WorkflowInfoTilesComponent, WorkflowInfoTilesModule, sendMethodsWithIcon };
export type { StatusbarData, TextDimension, TreeViewModel, TreeViewNodeItemOptions, TreeViewNodeModel };