@colijnit/corecomponents_v12 261.1.1 → 261.20.0

package/index.d.ts

@@ -0,0 +1,3971 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, NgZone, AfterViewInit, OnInit, EventEmitter, ComponentFactoryResolver, ApplicationRef, Injector, ElementRef, ComponentRef, ChangeDetectorRef, ViewContainerRef, OnChanges, SimpleChanges, PipeTransform, TemplateRef, ModuleWithProviders, QueryList, Renderer2, ComponentFactory, StaticProvider, AfterContentInit, InjectionToken } from '@angular/core';
+import * as i4$1 from '@angular/forms';
+import { UntypedFormControl, UntypedFormGroup, NgModel, ValidatorFn, AsyncValidatorFn, AbstractControl, ValidationErrors } from '@angular/forms';
+import { Subject, Observable, Subscription, BehaviorSubject } from 'rxjs';
+import { ObjectConfiguration } from '@colijnit/ioneconnector/build/model/object-configuration';
+import { ObjectConfigurationDefaultValueType } from '@colijnit/ioneconnector/build/type/object-configuration-default-value-type';
+import * as i3 from '@angular/platform-browser';
+import { SafeHtml, DomSanitizer, HammerGestureConfig } from '@angular/platform-browser';
+import * as i2 from '@angular/common';
+import { DatePipe } from '@angular/common';
+import * as _angular_animations from '@angular/animations';
+import * as i4 from '@angular/cdk/drag-drop';
+import { CdkDrag, CdkDropList, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { Overlay } from '@angular/cdk/overlay';
+import * as i7 from '@angular/cdk/scrolling';
+import { BusinessObject } from '@colijnit/ioneconnector/build/model/business-object';
+import { ValidationResult } from '@colijnit/ioneconnector/build/model/validation-result';
+import { ObjectConfigKind } from '@colijnit/ioneconnector/build/enum/object-config-kind';
+
+declare class FormInputUserModelChangeListenerService implements OnDestroy {
+    readonly userModelChange: Subject<any>;
+    readonly clearAllMarkedAsUserTouched: Subject<void>;
+    hasUserModelChanges: boolean;
+    private _subs;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputUserModelChangeListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormInputUserModelChangeListenerService>;
+}
+
+declare class NgZoneWrapperService {
+    private _ngZone;
+    constructor(_ngZone: NgZone);
+    setTimeoutOutsideAngular(fn: Function, millis?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgZoneWrapperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgZoneWrapperService>;
+}
+
+/** AUTO GENERATED FILE. DO NOT CHANGE.. OR YOU WILL SUFFER THE CONSEQUENCES OF YOUR ACTIONS **/
+declare enum CoreComponentsIcon {
+    Account = "account",
+    AccountRoundOpen = "account_round_open",
+    Activities = "activities",
+    AddToCartDrop = "add_to_cart_drop",
+    ArrowDown = "arrow_down",
+    ArrowFatLeft = "arrow_fat_left",
+    ArrowFatRight = "arrow_fat_right",
+    ArrowLeft = "arrow_left",
+    ArrowLeftRoundOpen = "arrow_left_round_open",
+    ArrowPointDown = "arrow_point_down",
+    ArrowPointLeft = "arrow_point_left",
+    ArrowPointRight = "arrow_point_right",
+    ArrowPointUp = "arrow_point_up",
+    ArrowRightRoundOpen = "arrow_right_round_open",
+    ArrowScrollDown = "arrow_scroll_down",
+    ArrowScrollLeft = "arrow_scroll_left",
+    ArrowScrollRight = "arrow_scroll_right",
+    ArrowScrollUp = "arrow_scroll_up",
+    ArrowUp = "arrow_up",
+    ArrowUpArrowDown = "arrow_up_arrow_down",
+    Article = "article",
+    ArticleWithFold = "article_with_fold",
+    AsteriskSmall = "asterisk_small",
+    Attachments = "attachments",
+    BackToTop = "back_to_top",
+    Barcode = "Barcode",
+    BigMac = "big_mac",
+    Boxes = "boxes",
+    BoxesPackingRegular = "boxes_packing_regular",
+    Brush = "brush",
+    BrushRoundOpen = "brush_round_open",
+    BuildingColumns = "building_columns",
+    Businessrules = "businessrules",
+    Calendar = "calendar",
+    CalendarDay = "calendar_day",
+    CalendarDayRegular = "calendar_day_regular",
+    CalendarEmpty = "calendar_empty",
+    CalendarRange = "calendar_range",
+    CalendarRoundOpen = "calendar_round_open",
+    Camera = "camera",
+    Cancel = "cancel",
+    CancelRoundFilled = "cancel_round_filled",
+    CancelRoundOpen = "cancel_round_open",
+    CaretDownSolid = "caret_down_solid",
+    CaretUpSolid = "caret_up_solid",
+    Cart = "cart",
+    CartOpen = "cart_open",
+    CaseManager = "case_manager",
+    CashRegister = "CashRegister",
+    CashRegisterSimple = "cash_register_simple",
+    ChangeLocation = "change_location",
+    Check = "check",
+    CheckDuotone = "check_duotone",
+    CheckRound = "check_round",
+    CheckRoundOpen = "check_round_open",
+    CheckSimple = "check_simple",
+    CheckThin = "check_thin",
+    ChevronDownRegular = "chevron_down_regular",
+    ChevronUpRegular = "chevron_up_regular",
+    CirclePlusSkinny = "CirclePlusSkinny",
+    Client = "client",
+    Clock = "clock",
+    ClockArrow = "clockArrow",
+    CogWheelPlus = "cogWheelPlus",
+    CogWheels = "cogWheels",
+    ColumnOptions = "column_options",
+    Company = "company",
+    CompanyFlat = "company_flat",
+    Configurable = "configurable",
+    Consultant = "consultant",
+    Copy = "copy",
+    Crosshair1 = "crosshair_1",
+    CrossSkinny = "CrossSkinny",
+    Dashboard = "dashboard",
+    DeliveryMethod = "delivery_method",
+    DeliveryStatusUncheck = "delivery_status_uncheck",
+    DeliveryTruck = "delivery_truck",
+    DetailRecord = "detail_record",
+    DetailView = "detail_view",
+    Dictionary = "dictionary",
+    Documents = "documents",
+    DocumentWrench = "documentWrench",
+    Dollar = "dollar",
+    Download = "download",
+    Dropdown = "dropdown",
+    Dropzone = "dropzone",
+    EditPencil = "edit_pencil",
+    EditPencilCircle = "edit_pencil_circle",
+    EditPencilRound = "edit_pencil_round",
+    EditPencilSimple = "edit_pencil_simple",
+    Email = "email",
+    EmailRoundOpen = "email_round_open",
+    Employee = "employee",
+    EmployeeTwo = "employee_two",
+    Employer = "employer",
+    Employment = "employment",
+    EmploymentEnd = "employment_end",
+    Equal = "equal",
+    Euro = "euro",
+    Exclamation = "exclamation",
+    ExclamationRoundOpen = "exclamation_round_open",
+    EyeCircle = "eye_circle",
+    EyeCircleLarge = "eye_circle_large",
+    EyeRoundFilled = "eye_round_filled",
+    Factory = "factory",
+    Fasttrack = "fasttrack",
+    Filter = "filter",
+    Finish = "finish",
+    FixedOptionValueTree = "fixed_option_value_tree",
+    FixedTreeOptionValue = "fixed_tree_option_value",
+    FloppyDiskSolid = "floppy_disk_solid",
+    FolderArrow = "FolderArrow",
+    FolderArrowIn = "folder_arrow_in",
+    Formula = "formula",
+    Fullscreen = "fullscreen",
+    GearDouble = "gear_double",
+    GlobalSearch = "global_search",
+    Globe = "globe",
+    GreaterThan = "greater_than",
+    GripDotsVerticalSolid = "grip_dots_vertical_solid",
+    Groupby = "groupby",
+    Hamburger = "hamburger",
+    HandPointer = "hand_pointer",
+    Hbarchart = "hbarchart",
+    Home = "Home",
+    HomeCircle = "home_circle",
+    HomeOpen = "home_open",
+    HomeRoundOpen = "home_round_open",
+    Hourglass = "hourglass",
+    Icon3d = "icon_3d",
+    Id = "id",
+    Image = "image",
+    IncomingStorage = "incoming_storage",
+    Information = "information",
+    InformationRoundOpen = "information_round_open",
+    InputMultiplechoice = "input_multiplechoice",
+    InputText = "input_text",
+    InputTextarea = "input_textarea",
+    Inventory = "inventory",
+    Invoice = "invoice",
+    IoneLogo = "ione_logo",
+    IoneLogoFat = "ione_logo_fat",
+    IoneStatusNext = "ione_status_next",
+    IoneWorkflow = "ione_workflow",
+    Keyboard = "keyboard",
+    Keychain = "keychain",
+    Label = "label",
+    LabelRoundOpen = "label_round_open",
+    LandmarkFlag = "landmark_flag",
+    Library = "library",
+    Linechart = "linechart",
+    LinkedProducts = "linked_products",
+    LinkCircle = "link_circle",
+    ListView = "list_view",
+    Location = "location",
+    Lock = "lock",
+    LockRoundOpen = "lock_round_open",
+    Logo = "logo",
+    Logout = "logout",
+    MagicWand = "magic_wand",
+    Magnifier = "magnifier",
+    Manager = "manager",
+    Mask = "mask",
+    MasterDetail = "master_detail",
+    MaterialCircleLarge = "material_circle_large",
+    MedalBronze = "medal_bronze",
+    MedalGold = "medal_gold",
+    MedalSilver = "medal_silver",
+    MedicalOfficer = "medical_officer",
+    Microphone = "microphone",
+    MinusRoundOpen = "minus_round_open",
+    MinusSimple = "minus_simple",
+    Mobile = "mobile",
+    MultiSelectCheck = "multi_select_check",
+    NewTask = "new_task",
+    Note = "note",
+    NoteBordered = "note_bordered",
+    Notification = "notification",
+    NotEqual = "not_equal",
+    Option = "option",
+    Optionset = "optionset",
+    Order = "order",
+    Orderpicking = "orderpicking",
+    OutgoingStorage = "outgoing_storage",
+    OverBooking = "over_booking",
+    ParagraphSolid = "paragraph_solid",
+    PauseCircle = "pause_circle",
+    PencilRoundOpen = "pencil_round_open",
+    PenToSquareSolid = "pen_to_square_solid",
+    Phone = "phone",
+    PhoneRoundOpen = "phone_round_open",
+    Piechart = "piechart",
+    Pin = "pin",
+    PinRoundOpen = "pin_round_open",
+    PlayCircle = "play_circle",
+    PlusRound = "plus_round",
+    PlusRoundOpen = "plus_round_open",
+    PlusSimple = "plus_simple",
+    PlusSkinny = "plus_skinny",
+    PlusSolid = "plus_solid",
+    PlusStars = "plus_stars",
+    Pointer = "pointer",
+    Pointer3d = "pointer_3d",
+    PointerFilled = "pointer_filled",
+    POS = "POS",
+    Positioning = "positioning",
+    Pregnancy = "pregnancy",
+    Preset = "preset",
+    Print = "print",
+    ProductProperties = "product_properties",
+    Purchase = "purchase",
+    Qrcode = "qrcode",
+    Question = "question",
+    RadioUncheck = "radio_uncheck",
+    Range = "range",
+    RangeSelect = "range_select",
+    Rectangles = "rectangles",
+    Refresh = "refresh",
+    RegularBoxesPackingCircleCheck = "regular_boxes_packing_circle_check",
+    Relations = "relations",
+    Remark = "remark",
+    RemarkRoundOpen = "remark_round_open",
+    ReportInType = "report_in_type",
+    Resize = "resize",
+    ResizeDown = "resize_down",
+    ResizeUp = "resize_up",
+    Returns = "returns",
+    ReturnGoods = "return_goods",
+    RotateLeftSolid = "rotate_left_solid",
+    SaveDisk = "save_disk",
+    SaveSkinny = "save_skinny",
+    ScaleBalanced = "scale_balanced",
+    Scanner = "scanner",
+    SearchRoundOpen = "search_round_open",
+    Sections = "sections",
+    SelectAllRound = "select_all_round",
+    Services = "services",
+    Settings = "settings",
+    Shop = "Shop",
+    ShoppingCart = "shopping_cart",
+    ShoppingCartNr = "shopping_cart_nr",
+    Shortcut = "shortcut",
+    SinglePerson = "SinglePerson",
+    Skills = "skills",
+    SliderPanel = "slider_panel",
+    SlideIn = "slide_in",
+    SmallerThan = "smaller_than",
+    SmallTiles = "small_tiles",
+    SortAsc = "sort_asc",
+    SortDesc = "sort_desc",
+    Star = "Star",
+    StarRoundOpen = "star_round_open",
+    StatusActive = "status_active",
+    StatusAdoption = "status_adoption",
+    StatusFostercare = "status_fostercare",
+    StatusIll = "status_ill",
+    StatusLeave = "status_leave",
+    StatusPregnancy = "status_pregnancy",
+    Stock = "stock",
+    StockManagement = "stock_management",
+    Storage = "storage",
+    Supervisor = "supervisor",
+    Supplier = "supplier",
+    Surgery = "surgery",
+    Tablechart = "tablechart",
+    Tag = "tag",
+    TalkTooMuch = "talk_too_much",
+    Target = "target",
+    Task = "task",
+    ThickLines = "thick_lines",
+    ThinLines = "thin_lines",
+    ThreeSixtyView = "three_sixty_view",
+    ThumbBronze = "thumb_bronze",
+    ThumbGold = "thumb_gold",
+    ThumbSilver = "thumb_silver",
+    Timeline = "timeline",
+    Transactions = "transactions",
+    TransactionDetail = "transaction_detail",
+    TrashBin = "TrashBin",
+    TrashCanSolid = "trash_can_solid",
+    TriangleDown = "triangle_down",
+    TriangleLarge = "triangle_large",
+    TriangleLeft = "triangle_left",
+    TriangleRight = "triangle_right",
+    TriangleUp = "triangle_up",
+    Truck = "truck",
+    TruckCalendar = "truck_calendar",
+    UndoRoundOpen = "undo_round_open",
+    User = "user",
+    Variants = "variants",
+    Vbarchart = "vbarchart",
+    View = "view",
+    Warehouse = "warehouse",
+    Watermark = "watermark",
+    Website = "website",
+    Wizard = "wizard",
+    Wms = "wms",
+    WorkInProgress = "work_in_progress",
+    WorkInProgressRoundOpen = "work_in_progress_round_open",
+    Wrench = "wrench",
+    XAxis = "x_axis",
+    YAxis = "y_axis"
+}
+
+/**
+ * Service to use inside [providers] of some leaf component that contains multiple <co-form>'s inside, possibly nested. Gives the master
+ * full control over submits etc. of all its inner co-forms with just one service.
+ */
+declare class FormMasterService implements OnDestroy {
+    readonly validSlavesSubmit: Subject<void>;
+    private _slaveForms;
+    private _subs;
+    private _slaveHoldingFirstInvalidField;
+    private _keyOfFirstInvalidFieldInDom;
+    private _positionOfFirstInvalidFieldInDom;
+    private _firstErrorTooltipSpawned;
+    constructor();
+    ngOnDestroy(): void;
+    addSlave(coFormComp: FormComponent): void;
+    removeSlave(coFormComp: FormComponent): void;
+    submitSlaves(): boolean;
+    resetSlaves(): void;
+    setFirstInvalidField(form: FormComponent, key: string, element: HTMLElement): void;
+    allSlavesValid(): boolean;
+    private _resetFirstInvalidFieldProps;
+    private _handleFormCompInvalidity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormMasterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormMasterService>;
+}
+
+declare class FormComponent implements AfterViewInit, OnDestroy, OnInit {
+    private _formMaster;
+    set readonly(value: boolean);
+    get readonly(): boolean;
+    keepInView: Element;
+    onChange: EventEmitter<UntypedFormControl>;
+    showClass: boolean;
+    submitted: boolean;
+    readonly validSubmit: EventEmitter<void>;
+    readonly anySubmit: EventEmitter<void>;
+    readonly validityChange: EventEmitter<boolean>;
+    readonly readonlyChange: EventEmitter<boolean>;
+    formGroup: UntypedFormGroup;
+    invalidSubmit: Subject<void>;
+    private _readonly;
+    private _valueChangeSub;
+    private _statusChangeSub;
+    private _init;
+    private _componentMap;
+    constructor(_formMaster: FormMasterService);
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    addFormInput(formInput: BaseInputComponent<any>): void;
+    removeFormInput(formInput: BaseInputComponent<any>): void;
+    updateFormInput(formInput: BaseInputComponent<any>): void;
+    checkUpdateValidity(): boolean;
+    isTouched(): boolean;
+    isValid(): boolean;
+    reset(): void;
+    submit(throughFormMaster?: boolean): boolean;
+    showErrorTooltipOnFormGroupControl(key: string): void;
+    private _setFirstInvalidElementOnMaster;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "co-form", never, { "readonly": { "alias": "readonly"; "required": false; }; "keepInView": { "alias": "keepInView"; "required": false; }; }, { "onChange": "onChange"; "validSubmit": "validSubmit"; "anySubmit": "anySubmit"; "validityChange": "validityChange"; "readonlyChange": "readonlyChange"; "invalidSubmit": "invalidSubmit"; }, never, ["*"], false, never>;
+}
+
+interface ScreenConfigAdapterComponent {
+    objectConfigName: string;
+    hidden: boolean;
+    required: boolean;
+    forceReadonly: boolean;
+    readonly: boolean;
+    maxLength: number;
+    defaultValue?: ObjectConfigurationDefaultValueType;
+    decimals: number;
+    redErrorBackground: boolean;
+    configObject?: ObjectConfiguration;
+}
+
+declare class OverlayService {
+    private _componentFactoryResolver;
+    private _appRef;
+    private _injector;
+    private _componentRefs;
+    constructor(_componentFactoryResolver: ComponentFactoryResolver, _appRef: ApplicationRef, _injector: Injector);
+    createComponent(compClass: any, inputs: any, events?: any, parentRef?: ElementRef): ComponentRef<any>;
+    removeComponent(componentRef: ComponentRef<any>): void;
+    private _componentRefExists;
+    private _removeComponentRef;
+    private _getClassFromComponentRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayService>;
+}
+
+/**
+ * Abstract base class for all concrete form input components that contain a native <input> element. Provides common data and functionality, such as
+ * adding self as a control to the parent form.
+ */
+declare abstract class BaseInputComponent<T> implements OnInit, OnDestroy, AfterViewInit, ScreenConfigAdapterComponent {
+    protected changeDetector: ChangeDetectorRef;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected overlayService: OverlayService;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    readonly icons: typeof CoreComponentsIcon;
+    validationErrorContainer: ViewContainerRef;
+    _ngModel: NgModel;
+    get ngModel(): NgModel;
+    static BaseFormInputComponentIndex: number;
+    static HiddenClass: string;
+    showSaveCancel: boolean;
+    set model(value: T);
+    get model(): T;
+    label: string;
+    noValidation: boolean;
+    initFocus: boolean;
+    noClickFocus: boolean;
+    businessObjectId: any;
+    name: string;
+    set disabled(disabled: boolean);
+    get disabled(): boolean;
+    set maxLength(maxLength: number);
+    get maxLength(): number;
+    set defaultValue(defaultValue: ObjectConfigurationDefaultValueType);
+    get defaultValue(): ObjectConfigurationDefaultValueType;
+    forcedMaxLength: number;
+    set readonly(readonly: boolean);
+    get readonly(): boolean;
+    set forceReadonly(forceReadonly: boolean);
+    get forceReadonly(): boolean;
+    set required(required: boolean);
+    get required(): boolean;
+    forceRequired: boolean;
+    set validators(validators: ValidatorFn[]);
+    get validators(): ValidatorFn[];
+    set asyncValidators(validators: AsyncValidatorFn[]);
+    get asyncValidators(): AsyncValidatorFn[];
+    set hidden(hidden: boolean);
+    get hidden(): boolean;
+    set decimals(value: number);
+    get decimals(): number;
+    icon: CoreComponentsIcon;
+    customCssClass: string;
+    redErrorBackground: boolean;
+    set myFormInputInstance(value: BaseInputComponent<T>);
+    get myFormInputInstance(): BaseInputComponent<T>;
+    commitOnBlur: boolean;
+    readonly nativeBlur: EventEmitter<any>;
+    readonly blur: EventEmitter<any>;
+    readonly enter: EventEmitter<any>;
+    readonly focus: EventEmitter<any>;
+    readonly keyDown: EventEmitter<any>;
+    readonly keyUp: EventEmitter<any>;
+    readonly modelChange: EventEmitter<any>;
+    readonly selectedValueChange: EventEmitter<any>;
+    readonly userModelChange: EventEmitter<any>;
+    readonly hiddenChange: EventEmitter<boolean>;
+    readonly cancelClicked: EventEmitter<void>;
+    focused: boolean;
+    formComponent: FormComponent;
+    formInput: boolean;
+    customWidth: boolean;
+    customHeight: boolean;
+    noTriangleGraphic: boolean;
+    keepFocussed: boolean;
+    halfWidth: boolean;
+    fullWidth: boolean;
+    excludeUserModelChange: boolean;
+    noFormGroupControl: boolean;
+    get formSubmitted(): boolean;
+    get hasNoLabel(): boolean;
+    get hasValue(): boolean;
+    get invalid(): boolean;
+    get isDisabled(): boolean;
+    get isReadonly(): boolean;
+    get isRequired(): boolean;
+    get touchedInvalid(): boolean;
+    get valid(): boolean;
+    get validationDisabled(): boolean;
+    onClick(event: MouseEvent): void;
+    onFocusIn(): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    get canChange(): boolean;
+    get control(): UntypedFormControl;
+    get formInputInstance(): BaseInputComponent<T>;
+    get isDestroyed(): boolean;
+    input: HTMLInputElement | HTMLTextAreaElement;
+    keepFocus: boolean;
+    set canSaveOrCancel(value: boolean);
+    get canSaveOrCancel(): boolean;
+    objectConfigName: string;
+    validationError: string;
+    shouldCommit: boolean;
+    protected _markedAsUserTouched: boolean;
+    protected _destroyed: boolean;
+    protected _hasOnPushCdStrategy: boolean;
+    protected _model: T;
+    protected _modelDirtyForCommit: boolean;
+    protected _initialModel: T;
+    protected _initialModelSet: boolean;
+    private _myFormInputInstance;
+    private _errorValidationComponent;
+    private _decimals;
+    private _hidden;
+    private _disabled;
+    private _maxLength;
+    private _defaultValue;
+    private _readonly;
+    private _required;
+    private _forceReadonly;
+    private _validators;
+    private _asyncValidators;
+    private _speechSub;
+    private _modelChangeSub;
+    private _formAnySubmitSub;
+    private _formReadonlyChangeSub;
+    private _clearMarkedAsUserTouchedSub;
+    private _canSaveOrCancel;
+    private _commitButtonsComponentRef;
+    private _validationComponentRef;
+    constructor(changeDetector: ChangeDetectorRef, componentFactoryResolver: ComponentFactoryResolver, overlayService: OverlayService, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    commit: (model: any) => Promise<boolean>;
+    cancelClick(event?: MouseEvent): void;
+    showValidationError(error: string): void;
+    /**
+     * Emits a modelChange event with given value, indicating that the model of this form input
+     * has changed and its new value is given value. Also emits userModelChange if markedAsUserTouched.
+     */
+    setModel(value: any): void;
+    requestFocus(): void;
+    doFocus(event?: any): any;
+    doBlur(event?: any, handleCommit?: boolean): Promise<any>;
+    detectChanges(): void;
+    markForCheck(): void;
+    detectChangesAfterAngular(): void;
+    /**
+     * Links the given formComp.submit event to the firing of detectChanges() of given change detector. This is a 'utility-like' method,
+     * but we manage the actual subscription (with UNSUBSCRIBE()!) on this base class.
+     * @param formComp The form whose submit we want to link with the call of .detectChanges() on given change detector ref.
+     * @param changeDetectorRef This should be given as param. I choose not to make this part of our (BaseFormInputComponent) constructor,
+     * because we already have 21 extenders.
+     */
+    markAsUserTouched(): void;
+    clearMarkedAsUserTouched(): void;
+    protected modelSet(): void;
+    protected setMaxLength(maxLength: number): void;
+    protected _markAsOnPush(): void;
+    protected _checkState(): boolean;
+    protected _updateControlValidatorsAndOwnFlags(): void;
+    private _handleCommit;
+    private _commitFinished;
+    private _clearErrorComponent;
+    private _controlExists;
+    private _controlIsValid;
+    private _setNativeDisabled;
+    private _setNativeMaxLength;
+    protected _setNativeReadOnly(readonly: boolean): void;
+    private _setNativeRequired;
+    private _subscribeToSpeechInput;
+    private _addOrRemoveSelfFromForm;
+    private _updateSelfInForm;
+    private _removeSelfFromForm;
+    private _addSelfToForm;
+    private _prepareInput;
+    private _findInputNode;
+    private _positionValidationError;
+    protected _handleKeyDown(event: KeyboardEvent): Promise<any>;
+    private _createNewFocusEvent;
+    private _setFocusOnNextPossibleInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInputComponent<any>, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseInputComponent<any>, never, never, { "showSaveCancel": { "alias": "showSaveCancel"; "required": false; }; "model": { "alias": "model"; "required": false; }; "label": { "alias": "label"; "required": false; }; "noValidation": { "alias": "noValidation"; "required": false; }; "initFocus": { "alias": "initFocus"; "required": false; }; "noClickFocus": { "alias": "noClickFocus"; "required": false; }; "businessObjectId": { "alias": "businessObjectId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "forcedMaxLength": { "alias": "forcedMaxLength"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "forceReadonly": { "alias": "forceReadonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "forceRequired": { "alias": "forceRequired"; "required": false; }; "validators": { "alias": "validators"; "required": false; }; "asyncValidators": { "alias": "asyncValidators"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "decimals": { "alias": "decimals"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "customCssClass": { "alias": "customCssClass"; "required": false; }; "redErrorBackground": { "alias": "redErrorBackground"; "required": false; }; "myFormInputInstance": { "alias": "myFormInputInstance"; "required": false; }; "commitOnBlur": { "alias": "commitOnBlur"; "required": false; }; "customWidth": { "alias": "customWidth"; "required": false; }; "customHeight": { "alias": "customHeight"; "required": false; }; "noTriangleGraphic": { "alias": "noTriangleGraphic"; "required": false; }; "keepFocussed": { "alias": "keepFocussed"; "required": false; }; "halfWidth": { "alias": "halfWidth"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "excludeUserModelChange": { "alias": "excludeUserModelChange"; "required": false; }; "noFormGroupControl": { "alias": "noFormGroupControl"; "required": false; }; }, { "nativeBlur": "nativeBlur"; "blur": "blur"; "enter": "enter"; "focus": "focus"; "keyDown": "keyDown"; "keyUp": "keyUp"; "modelChange": "modelChange"; "selectedValueChange": "selectedValueChange"; "userModelChange": "userModelChange"; "hiddenChange": "hiddenChange"; "cancelClicked": "cancelClicked"; }, never, never, true, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseInputComponent<any>>;
+}
+
+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;
+    private _allIcons;
+    constructor(_sanitizer: DomSanitizer);
+    getIcon(iconName: CoreComponentsIcon): SafeHtml;
+    getRawIcon(iconName: CoreComponentsIcon): string;
+    getIconAsBase64(iconName: CoreComponentsIcon): SafeHtml;
+    getIconRawBase64(iconName: CoreComponentsIcon): string;
+    setIconCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconCacheService>;
+}
+
+declare enum LevelIndicatorLevel {
+    Low = "low",
+    Medium = "medium",
+    High = "high"
+}
+
+declare class ArticleTileComponent {
+    icons: IconCacheService;
+    imageData: string;
+    description: string;
+    price: number | string;
+    level: LevelIndicatorLevel;
+    isSelected: boolean;
+    isSmallModus: boolean;
+    hasConfigureButton: boolean;
+    hasThreeDButton: boolean;
+    hasCartButton: boolean;
+    readonly contentClick: EventEmitter<MouseEvent>;
+    readonly configureButtonClick: EventEmitter<MouseEvent>;
+    readonly threeDButtonClick: EventEmitter<MouseEvent>;
+    readonly cartButtonClick: EventEmitter<MouseEvent>;
+    readonly Icons: any;
+    constructor(icons: IconCacheService);
+    onHostClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleTileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArticleTileComponent, "co-article-tile", never, { "imageData": { "alias": "imageData"; "required": false; }; "description": { "alias": "description"; "required": false; }; "price": { "alias": "price"; "required": false; }; "level": { "alias": "level"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "isSmallModus": { "alias": "isSmallModus"; "required": false; }; "hasConfigureButton": { "alias": "hasConfigureButton"; "required": false; }; "hasThreeDButton": { "alias": "hasThreeDButton"; "required": false; }; "hasCartButton": { "alias": "hasCartButton"; "required": false; }; }, { "contentClick": "contentClick"; "configureButtonClick": "configureButtonClick"; "threeDButtonClick": "threeDButtonClick"; "cartButtonClick": "cartButtonClick"; }, never, ["[tile-top-content]", "[over-image]", "[card-extra-content]"], false, never>;
+}
+
+declare class IconComponent implements OnInit {
+    private _iconCache;
+    set icon(value: CoreComponentsIcon);
+    set iconData(value: SafeHtml | undefined);
+    showClass: boolean;
+    innerIconData: SafeHtml | undefined;
+    private _icon;
+    private _iconData;
+    constructor(_iconCache: IconCacheService);
+    ngOnInit(): void;
+    private _prepareIcon;
+    private _setIconFromEnum;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "co-icon", never, { "icon": { "alias": "icon"; "required": false; }; "iconData": { "alias": "iconData"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IconModule, [typeof IconComponent], [typeof i2.CommonModule], [typeof IconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IconModule>;
+}
+
+declare class ButtonComponent implements ScreenConfigAdapterComponent, OnDestroy {
+    private _elementRef;
+    label: string;
+    iconData: SafeHtml | undefined;
+    iconDataRight: SafeHtml | undefined;
+    isToggleButton: boolean;
+    isToggled: boolean;
+    hidden: boolean;
+    disabled: boolean;
+    showClass(): boolean;
+    readonly onClick: EventEmitter<MouseEvent>;
+    readonly clickedWhileDisabled: EventEmitter<MouseEvent>;
+    readonly isToggledChange: EventEmitter<boolean>;
+    get hasIcon(): boolean;
+    onHostClick(event: MouseEvent): void;
+    objectConfigName: string;
+    required: boolean;
+    forceReadonly: boolean;
+    readonly: boolean;
+    maxLength: number;
+    defaultValue: ObjectConfigurationDefaultValueType;
+    decimals: number;
+    redErrorBackground: boolean;
+    constructor(_elementRef: ElementRef);
+    ngOnDestroy(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "co-button", never, { "label": { "alias": "label"; "required": false; }; "iconData": { "alias": "iconData"; "required": false; }; "iconDataRight": { "alias": "iconDataRight"; "required": false; }; "isToggleButton": { "alias": "isToggleButton"; "required": false; }; "isToggled": { "alias": "isToggled"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onClick": "onClick"; "clickedWhileDisabled": "clickedWhileDisabled"; "isToggledChange": "isToggledChange"; }, never, never, false, never>;
+}
+
+/** Possible states for a ripple element. */
+declare enum CoRippleState {
+    FADING_IN = 0,
+    VISIBLE = 1,
+    FADING_OUT = 2,
+    HIDDEN = 3
+}
+/**
+ * Reference to a previously launched ripple element.
+ */
+declare class CoRippleRef {
+    private _renderer;
+    element: HTMLElement;
+    config: CoRippleConfig;
+    /** Current state of the ripple reference. */
+    state: CoRippleState;
+    constructor(_renderer: CoRippleRenderer, element: HTMLElement, config: CoRippleConfig);
+    /** Fades out the ripple element. */
+    fadeOut(): void;
+}
+
+/**
+ * Sends an event when the directive's element is scrolled. Registers itself with the
+ * ScrollDispatcher service to include itself as part of its collection of scrolling events that it
+ * can be listened to through the service.
+ */
+declare class CoScrollableDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _scroll;
+    constructor(_elementRef: ElementRef, _scroll: CoScrollDispatcherService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Returns observable that emits when a scroll event is fired on the host element.
+     */
+    elementScrolled(): Observable<any>;
+    getElementRef(): ElementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoScrollableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoScrollableDirective, "[cdk-scrollable]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Service contained all registered Scrollable references and emits an event when any one of the
+ * Scrollable references emit a scrolled event.
+ */
+declare class CoScrollDispatcherService {
+    /** Subject for notifying that a registered scrollable reference element has been scrolled. */
+    _scrolled: Subject<void>;
+    /** Keeps track of the global `scroll` and `resize` subscriptions. */
+    _globalSubscription: Subscription;
+    /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */
+    private _scrolledCount;
+    /**
+     * Map of all the scrollable references that are registered with the service and their
+     * scroll event subscriptions.
+     */
+    scrollableReferences: Map<CoScrollableDirective, Subscription>;
+    /**
+     * Registers a Scrollable with the service and listens for its scrolled events. When the
+     * scrollable is scrolled, the service emits the event in its scrolled observable.
+     * @param scrollable Scrollable instance to be registered.
+     */
+    register(scrollable: CoScrollableDirective): void;
+    /**
+     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.
+     * @param scrollable Scrollable instance to be deregistered.
+     */
+    deregister(scrollable: CoScrollableDirective): void;
+    /**
+     * Subscribes to an observable that emits an event whenever any of the registered Scrollable
+     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms
+     * to override the default "throttle" time.
+     */
+    scrolled(auditTimeInMs: number, callback: () => any): Subscription;
+    /** Returns all registered Scrollables that contain the provided element. */
+    getScrollContainers(elementRef: ElementRef): CoScrollableDirective[];
+    /** Returns true if the element is contained within the provided Scrollable. */
+    scrollableContainsElement(scrollable: CoScrollableDirective, elementRef: ElementRef): boolean;
+    /** Sends a notification that a scroll event has been fired. */
+    _notify(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoScrollDispatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoScrollDispatcherService>;
+}
+
+/**
+ * Simple utility for getting the bounds of the browser viewport.
+ * @docs-private
+ */
+declare class CoViewportRulerService {
+    /** Cached document client rectangle. */
+    private _documentRect?;
+    constructor(scrollDispatcher: CoScrollDispatcherService);
+    /** Gets a ClientRect for the viewport's bounds. */
+    getViewportRect(documentRect?: ClientRect): DOMRect;
+    /**
+     * Gets the (top, left) scroll position of the viewport.
+     * @param documentRect
+     */
+    getViewportScrollPosition(documentRect?: ClientRect): {
+        top: number;
+        left: number;
+    };
+    /** Caches the latest client rectangle of the document element. */
+    _cacheViewportGeometry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoViewportRulerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoViewportRulerService>;
+}
+
+type CoRippleConfig = {
+    color?: string;
+    centered?: boolean;
+    radius?: number;
+    speedFactor?: number;
+    persistent?: boolean;
+};
+/**
+ * Helper service that performs DOM manipulations. Not intended to be used outside this module.
+ * The constructor takes a reference to the ripple directive's host element and a map of DOM
+ * event handlers to be installed on the element that triggers ripple animations.
+ * This will eventually become a custom renderer once Angular support exists.
+ * @docs-private
+ */
+declare class CoRippleRenderer {
+    private _ngZone;
+    private _ruler;
+    /** Element where the ripples are being added to. */
+    private _containerElement;
+    /** Element which triggers the ripple elements on mouse events. */
+    private _triggerElement;
+    /** Whether the mouse is currently down or not. */
+    private _isMousedown;
+    /** Events to be registered on the trigger element. */
+    private _triggerEvents;
+    /** Set of currently active ripple references. */
+    private _activeRipples;
+    /** Ripple config for all ripples created by events. */
+    rippleConfig: CoRippleConfig;
+    /** Whether mouse ripples should be created or not. */
+    rippleDisabled: boolean;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone, _ruler: CoViewportRulerService);
+    /** Fades in a ripple at the given coordinates. */
+    fadeInRipple(pageX: number, pageY: number, config?: CoRippleConfig): CoRippleRef;
+    /** Fades out a ripple reference. */
+    fadeOutRipple(rippleRef: CoRippleRef): void;
+    /** Fades out all currently active ripples. */
+    fadeOutAll(): void;
+    /** Sets the trigger element and registers the mouse events. */
+    setTriggerElement(element: HTMLElement): void;
+    /** Listener being called on mousedown event. */
+    private onMousedown;
+    /** Listener being called on mouseup event. */
+    private onMouseup;
+    /** Listener being called on mouseleave event. */
+    private onMouseLeave;
+    /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
+    private runTimeoutOutsideZone;
+}
+
+declare class CoRippleDirective implements OnChanges, OnDestroy {
+    /**
+     * The element that triggers the ripple when click events are received. Defaults to the
+     * directive's host element.
+     */
+    trigger: HTMLElement | HTMLElement;
+    /**
+     * Whether the ripple always originates from the center of the host element's bounds, rather
+     * than originating from the location of the click event.
+     */
+    centered: boolean;
+    /**
+     * Whether click events will not trigger the ripple. It can still be triggered by manually
+     * calling createRipple()
+     */
+    disabled: boolean;
+    /**
+     * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
+     * will be the distance from the center of the ripple to the furthest corner of the host element's
+     * bounding rectangle.
+     */
+    radius: number;
+    /**
+     * If set, the normal duration of ripple animations is divided by this value. For example,
+     * setting it to 0.5 will cause the animations to take twice as long.
+     * A changed speedFactor will not modify the fade-out duration of the ripples.
+     */
+    speedFactor: number;
+    /** Custom color for ripples. */
+    color: string;
+    /** Whether foreground ripples should be visible outside the component's bounds. */
+    unbounded: boolean;
+    /** Renderer for the ripple DOM manipulations. */
+    private _rippleRenderer;
+    /** Options that are set globally for all ripples. */
+    private _globalOptions;
+    constructor(elementRef: ElementRef, ngZone: NgZone, ruler: CoViewportRulerService, globalOptions: any);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Launches a manual ripple at the specified position. */
+    launch(pageX: number, pageY: number, config?: CoRippleConfig): CoRippleRef;
+    /** Fades out all currently showing ripple elements. */
+    fadeOutAll(): void;
+    /** Ripple configuration from the directive's input values. */
+    get rippleConfig(): CoRippleConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoRippleDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoRippleDirective, "[md-ripple], [mat-ripple], [mdRipple], [matRipple]", ["mdRipple"], { "trigger": { "alias": "mdRippleTrigger"; "required": false; }; "centered": { "alias": "mdRippleCentered"; "required": false; }; "disabled": { "alias": "mdRippleDisabled"; "required": false; }; "radius": { "alias": "mdRippleRadius"; "required": false; }; "speedFactor": { "alias": "mdRippleSpeedFactor"; "required": false; }; "color": { "alias": "mdRippleColor"; "required": false; }; "unbounded": { "alias": "mdRippleUnbounded"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RippleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RippleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RippleModule, [typeof CoRippleDirective, typeof CoScrollableDirective], never, [typeof CoRippleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RippleModule>;
+}
+
+declare class ButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, [typeof ButtonComponent], [typeof i2.CommonModule, typeof IconModule, typeof RippleModule], [typeof ButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
+}
+
+declare class ImageComponent implements OnInit {
+    private _sanitizer;
+    /**
+     * Source of the image, can be an URL or a base64 data string
+      */
+    source: string;
+    /**
+     * Placeholder svg source to show when there is no image
+     */
+    placeHolder: string;
+    showClass: boolean;
+    error: boolean;
+    innerPlaceHolder: SafeHtml | undefined;
+    private _defaultPlaceholder;
+    constructor(_sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    handleImageError(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageComponent, "co-image", never, { "source": { "alias": "source"; "required": false; }; "placeHolder": { "alias": "placeHolder"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ImageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageModule, [typeof ImageComponent], [typeof i2.CommonModule, typeof IconModule], [typeof ImageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImageModule>;
+}
+
+declare class StopClickDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _ngZone;
+    stopClick: boolean;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _killEventHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StopClickDirective, "[stopClick]", never, { "stopClick": { "alias": "stopClick"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class StopClickModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopClickModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StopClickModule, [typeof StopClickDirective], never, [typeof StopClickDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StopClickModule>;
+}
+
+declare class LevelIndicatorComponent {
+    set model(value: LevelIndicatorLevel);
+    get model(): LevelIndicatorLevel;
+    showClass: boolean;
+    get modelAsString(): string;
+    private _model;
+    private _modelAsString;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LevelIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LevelIndicatorComponent, "co-level-indicator", never, { "model": { "alias": "model"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LevelIndicatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LevelIndicatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LevelIndicatorModule, [typeof LevelIndicatorComponent], [typeof i2.CommonModule], [typeof LevelIndicatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LevelIndicatorModule>;
+}
+
+declare class PriceDisplayPipe implements PipeTransform {
+    transform(value: number | string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PriceDisplayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PriceDisplayPipe, "priceDisplay", false>;
+}
+
+declare class PriceDisplayPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PriceDisplayPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PriceDisplayPipeModule, [typeof PriceDisplayPipe], never, [typeof PriceDisplayPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PriceDisplayPipeModule>;
+}
+
+declare class TileComponent {
+    private _iconCache;
+    readonly icon: typeof CoreComponentsIcon;
+    image: string;
+    mouseOverExtended: boolean;
+    small: boolean;
+    noImagePlaceholder: boolean;
+    onImageClick: EventEmitter<void>;
+    showClass: boolean;
+    imagePlaceHolder: null | SafeHtml;
+    constructor(_iconCache: IconCacheService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TileComponent, "co-tile", never, { "image": { "alias": "image"; "required": false; }; "mouseOverExtended": { "alias": "mouseOverExtended"; "required": false; }; "small": { "alias": "small"; "required": false; }; "noImagePlaceholder": { "alias": "noImagePlaceholder"; "required": false; }; }, { "onImageClick": "onImageClick"; }, never, ["[tile-top-content]", "[tile-over-image]", "[tile-bottom-content]", "[tile-extra-bottom-content]", "[tile-extended-content]"], false, never>;
+}
+
+declare class TileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TileModule, [typeof TileComponent], [typeof i2.CommonModule, typeof IconModule, typeof ImageModule], [typeof TileComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TileModule>;
+}
+
+declare class ArticleTileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleTileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArticleTileModule, [typeof ArticleTileComponent], [typeof i2.CommonModule, typeof IconModule, typeof ButtonModule, typeof ImageModule, typeof StopClickModule, typeof LevelIndicatorModule, typeof PriceDisplayPipeModule, typeof TileModule], [typeof ArticleTileComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArticleTileModule>;
+}
+
+declare class CardComponent {
+    icons: IconCacheService;
+    private _changeDetector;
+    imageData: string;
+    description: string;
+    price: number | string;
+    level: LevelIndicatorLevel;
+    isSelected: boolean;
+    isSmallModus: boolean;
+    hasMagnifierButton: boolean;
+    hasInfoButton: boolean;
+    readonly contentClick: EventEmitter<MouseEvent>;
+    readonly infoButtonClick: EventEmitter<MouseEvent>;
+    readonly magnifierButtonClick: EventEmitter<MouseEvent>;
+    showClass: boolean;
+    onHostClick(event: MouseEvent): void;
+    readonly Icons: any;
+    heightCard: number;
+    constructor(icons: IconCacheService, _changeDetector: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "co-card", never, { "imageData": { "alias": "imageData"; "required": false; }; "description": { "alias": "description"; "required": false; }; "price": { "alias": "price"; "required": false; }; "level": { "alias": "level"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "isSmallModus": { "alias": "isSmallModus"; "required": false; }; "hasMagnifierButton": { "alias": "hasMagnifierButton"; "required": false; }; "hasInfoButton": { "alias": "hasInfoButton"; "required": false; }; }, { "contentClick": "contentClick"; "infoButtonClick": "infoButtonClick"; "magnifierButtonClick": "magnifierButtonClick"; }, never, ["[over-image]", "*"], false, never>;
+}
+
+declare class CardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, [typeof CardComponent], [typeof i2.CommonModule, typeof IconModule, typeof ButtonModule, typeof ImageModule, typeof StopClickModule, typeof LevelIndicatorModule, typeof PriceDisplayPipeModule, typeof TileModule], [typeof CardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
+}
+
+declare class Carousel3dComponent implements AfterViewInit, OnDestroy {
+    canvasContainer: ElementRef;
+    carouselWrapper: ElementRef;
+    set children(children: any);
+    tileWidth: number;
+    tileHeight: number;
+    cameraHeight: number;
+    shadow: boolean;
+    selectedIndex: number;
+    indexSelected: EventEmitter<number>;
+    showClass(): boolean;
+    private _camera;
+    private _cameraZoom;
+    private _backgroundColor;
+    private _sceneCss;
+    private _scene;
+    private _rendererCss;
+    private _renderer;
+    private _ambientLight;
+    private _tileSize;
+    private _tileMargin;
+    private _targetPositions;
+    private _tileElements;
+    private _tileOffset;
+    private _tiles3D;
+    private _planeColor;
+    private _planeHeight;
+    private _spotLightPosition;
+    private _fullCircle;
+    private _initialized;
+    private _elementsCreated;
+    canNavigateLeft: boolean;
+    canNavigateRight: boolean;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    handleButtonLeftClick(): void;
+    handleButtonRightClick(): void;
+    private _buildCarousel;
+    private _init;
+    private _initCamera;
+    private _initScene;
+    private _initRenderer;
+    private _disposeObject;
+    private _clearScenes;
+    private _createTiles;
+    private _adjustCameraZoom;
+    private _checkNavigationButtons;
+    private _animate;
+    private _getSelectedIndex;
+    private _rotate;
+    private _rotateTo;
+    private _resizeCanvasToDisplaySize;
+    private _render;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Carousel3dComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Carousel3dComponent, "co-carousel-3d", never, { "tileWidth": { "alias": "tileWidth"; "required": false; }; "tileHeight": { "alias": "tileHeight"; "required": false; }; "cameraHeight": { "alias": "cameraHeight"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "indexSelected": "indexSelected"; }, ["children"], never, false, never>;
+}
+
+declare class Carousel3dModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Carousel3dModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<Carousel3dModule, [typeof Carousel3dComponent], [typeof i2.CommonModule], [typeof Carousel3dComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<Carousel3dModule>;
+}
+
+declare class CarouselComponent implements OnDestroy {
+    set containerChild(child: any);
+    set contentChildren(content: any);
+    showClass(): boolean;
+    carouselItems: ElementRef[];
+    canNavigateLeft: boolean;
+    canNavigateRight: boolean;
+    container: ElementRef;
+    activeIndex: number;
+    ro: ResizeObserver;
+    private _disableButtons;
+    ngOnDestroy(): void;
+    handlePress(event: any): void;
+    handleSwipe(event: any): void;
+    handleButtonLeftClick(): Promise<void>;
+    handleButtonRightClick(): Promise<void>;
+    private _navigate;
+    private _checkNavigationButtons;
+    private _getLeftPositionFromActiveItem;
+    private _scrollWrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CarouselComponent, "co-carousel", never, {}, {}, ["contentChildren"], ["*"], false, never>;
+}
+
+declare class CarouselHammerConfig extends HammerGestureConfig {
+    overrides: any;
+}
+declare class CarouselModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CarouselModule, [typeof CarouselComponent], [typeof i2.CommonModule, typeof i3.HammerModule], [typeof CarouselComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CarouselModule>;
+}
+
+declare const showHideDialog: _angular_animations.AnimationTriggerMetadata[];
+declare class CoDialogComponent implements OnInit {
+    readonly icons: typeof CoreComponentsIcon;
+    customCssClass: string;
+    headerTemplate: TemplateRef<any>;
+    footerTemplate: TemplateRef<any>;
+    showCloseIcon: boolean;
+    modal: boolean;
+    borderless: boolean;
+    readonly closeClick: EventEmitter<MouseEvent>;
+    showClass(): boolean;
+    handleKeyDown(event: KeyboardEvent): void;
+    isTouch: boolean;
+    mobile: boolean;
+    state: string;
+    ngOnInit(): void;
+    handleCloseDialog(event?: MouseEvent): void;
+    handleOverlayClick(event: MouseEvent): void;
+    private _checkDevice;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CoDialogComponent, "co-dialog", never, { "customCssClass": { "alias": "customCssClass"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "showCloseIcon": { "alias": "showCloseIcon"; "required": false; }; "modal": { "alias": "modal"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; }, { "closeClick": "closeClick"; }, never, ["*"], false, never>;
+}
+
+declare class CoDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoDialogModule, [typeof CoDialogComponent], [typeof i2.CommonModule, typeof IconModule, typeof i4.DragDropModule], [typeof CoDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoDialogModule>;
+}
+
+declare class CoDialogWizardComponent {
+    readonly icons: typeof CoreComponentsIcon;
+    showCloseIcon: boolean;
+    animation: boolean;
+    readonly closeClick: EventEmitter<MouseEvent>;
+    showClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoDialogWizardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CoDialogWizardComponent, "co-dialog-wizard", never, { "showCloseIcon": { "alias": "showCloseIcon"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, { "closeClick": "closeClick"; }, never, ["[header]", "*"], false, never>;
+}
+
+declare class CoDialogWizardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoDialogWizardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoDialogWizardModule, [typeof CoDialogWizardComponent], [typeof i2.CommonModule, typeof IconModule], [typeof CoDialogWizardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoDialogWizardModule>;
+}
+
+declare class CollapsibleComponent implements OnDestroy {
+    private _elementRef;
+    headerContent: TemplateRef<any>;
+    customHeaderContent: boolean;
+    headerTitle: string;
+    buttonText: string;
+    iconData: SafeHtml | undefined;
+    expandButtonLast: boolean;
+    showButton: boolean;
+    expanded: boolean;
+    expandedChange: EventEmitter<boolean>;
+    buttonClicked: EventEmitter<void>;
+    showClass(): boolean;
+    onHostClick(event: MouseEvent): void;
+    constructor(_elementRef: ElementRef);
+    ngOnDestroy(): void;
+    focus(): void;
+    changeExpanded(): void;
+    onButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapsibleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollapsibleComponent, "co-collapsible", never, { "headerContent": { "alias": "headerContent"; "required": false; }; "customHeaderContent": { "alias": "customHeaderContent"; "required": false; }; "headerTitle": { "alias": "headerTitle"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "iconData": { "alias": "iconData"; "required": false; }; "expandButtonLast": { "alias": "expandButtonLast"; "required": false; }; "showButton": { "alias": "showButton"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; }, { "expandedChange": "expandedChange"; "buttonClicked": "buttonClicked"; }, never, ["*"], false, never>;
+}
+
+declare class CollapsibleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapsibleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CollapsibleModule, [typeof CollapsibleComponent], [typeof i2.CommonModule, typeof IconModule, typeof ButtonModule], [typeof CollapsibleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CollapsibleModule>;
+}
+
+declare class FormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormModule, [typeof FormComponent], [typeof i2.CommonModule], [typeof FormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormModule>;
+}
+
+declare class GridToolbarComponent {
+    iconsService: IconCacheService;
+    readonly icons: typeof CoreComponentsIcon;
+    showEdit: boolean;
+    showAdd: boolean;
+    showDelete: boolean;
+    deleteEnabled: boolean;
+    editClick: EventEmitter<MouseEvent>;
+    cancelClick: EventEmitter<void>;
+    saveClick: EventEmitter<void>;
+    addClick: EventEmitter<void>;
+    deleteClick: EventEmitter<void>;
+    showClass(): boolean;
+    constructor(iconsService: IconCacheService);
+    handleDeleteClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridToolbarComponent, "co-grid-toolbar", never, { "showEdit": { "alias": "showEdit"; "required": false; }; "showAdd": { "alias": "showAdd"; "required": false; }; "showDelete": { "alias": "showDelete"; "required": false; }; "deleteEnabled": { "alias": "deleteEnabled"; "required": false; }; }, { "editClick": "editClick"; "cancelClick": "cancelClick"; "saveClick": "saveClick"; "addClick": "addClick"; "deleteClick": "deleteClick"; }, never, never, false, never>;
+}
+
+declare class GridToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GridToolbarModule, [typeof GridToolbarComponent], [typeof IconModule, typeof ButtonModule, typeof i2.CommonModule], [typeof GridToolbarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GridToolbarModule>;
+}
+
+declare class GridToolbarButtonComponent {
+    iconData: SafeHtml | undefined;
+    disabled: boolean;
+    buttonClick: EventEmitter<void>;
+    showClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridToolbarButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridToolbarButtonComponent, "co-grid-toolbar-button", never, { "iconData": { "alias": "iconData"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, false, never>;
+}
+
+declare class GridToolbarButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridToolbarButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GridToolbarButtonModule, [typeof GridToolbarButtonComponent], [typeof IconModule], [typeof GridToolbarButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GridToolbarButtonModule>;
+}
+
+declare enum CoDirection {
+    Right = "right",
+    Left = "left",
+    Up = "top",
+    Down = "bottom"
+}
+
+declare enum CoOrientation {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}
+declare function OrientationOfDirection(direction: CoDirection): CoOrientation;
+
+declare class IconCollapseHandleComponent {
+    showClass(): boolean;
+    orientation: CoOrientation;
+    set arrowDirection(arrowDirection: CoDirection);
+    get arrowDirection(): CoDirection;
+    twoArrows: boolean;
+    get isVertical(): boolean;
+    get arrowsOrientatedHorizontally(): boolean;
+    get oppositeArrowDirection(): CoDirection;
+    readonly iconColorClass: string;
+    hidden: boolean;
+    required: boolean;
+    readonly: boolean;
+    readonly Icons: typeof CoreComponentsIcon;
+    private _arrowDirection;
+    private _oppositeArrowDirection;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconCollapseHandleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconCollapseHandleComponent, "co-icon-collapse-handle", never, { "orientation": { "alias": "orientation"; "required": false; }; "arrowDirection": { "alias": "arrowDirection"; "required": false; }; "twoArrows": { "alias": "twoArrows"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IconCollapseHandleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconCollapseHandleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IconCollapseHandleModule, [typeof IconCollapseHandleComponent], [typeof i2.CommonModule, typeof IconModule, typeof RippleModule], [typeof IconCollapseHandleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IconCollapseHandleModule>;
+}
+
+declare enum FilterItemMode {
+    Filterlist = "filterlist",
+    SingleSelectList = "singleSelectList",
+    SelectListWithStringCollectionOutput = "selectListWithStringCollectionOutput",
+    SelectListWithNumberOutput = "selectListWithNumberOutput",
+    Slider = "slider",
+    NullableSlider = "nullableSlider",
+    TextField = "textField",
+    DateField = "dateField",
+    DateRangeField = "dateRangeField",
+    Checkbox = "checkbox",
+    CheckboxToSimpleText = "checkboxToSimpleText",
+    CheckboxToText = "checkboxToText",
+    CheckboxToTFSimpleText = "checkboxToTFSimpleText",
+    CheckboxToTFText = "checkboxToTFText",
+    CheckboxToBinary = "checkboxToBinary"
+}
+
+declare class InputCheckboxComponent extends BaseInputComponent<boolean> {
+    formComponent: FormComponent;
+    iconCacheService: IconCacheService;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    cssClass: string;
+    clickableLabel: boolean;
+    modelChange: EventEmitter<boolean>;
+    showClass(): boolean;
+    handleClick(event: MouseEvent): void;
+    constructor(formComponent: FormComponent, iconCacheService: IconCacheService, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    handleModelChange(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCheckboxComponent, [{ optional: true; }, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCheckboxComponent, "co-input-checkbox", never, { "cssClass": { "alias": "cssClass"; "required": false; }; "clickableLabel": { "alias": "clickableLabel"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, false, never>;
+}
+
+declare class BaseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaseModule, never, [typeof i2.CommonModule, typeof i4$1.FormsModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaseModule>;
+}
+
+declare class InputCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputCheckboxModule, [typeof InputCheckboxComponent], [typeof BaseModule, typeof i2.CommonModule, typeof i4$1.FormsModule], [typeof InputCheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputCheckboxModule>;
+}
+
+declare abstract class BaseInputDatePickerDirective extends BaseInputComponent<any> implements OnInit {
+    readonly rightIcon: CoreComponentsIcon;
+    parentForOverlay: ElementRef;
+    locale: string;
+    placeholder: string;
+    leftIcon: CoreComponentsIcon;
+    leftIconData: SafeHtml;
+    leftIconClick: EventEmitter<MouseEvent>;
+    closeAfterDateSelection: boolean;
+    showCalendar: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInputDatePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseInputDatePickerDirective, never, never, { "locale": { "alias": "locale"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "closeAfterDateSelection": { "alias": "closeAfterDateSelection"; "required": false; }; }, { "leftIconClick": "leftIconClick"; }, never, never, true, never>;
+}
+
+declare class InputDatePickerComponent extends BaseInputDatePickerDirective {
+    formComponent: FormComponent;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    modelAsString: string;
+    private _calendarComponentRef;
+    firstDayOfWeek: string;
+    showClearButton: boolean;
+    showClass(): boolean;
+    constructor(formComponent: FormComponent, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    handleDateSelected(date: Date): void;
+    toggleCalendar(show: boolean): void;
+    finalizeDate(): void;
+    finalize(): void;
+    private isValidDateString;
+    handleDateChange(value: string): void;
+    protected modelSet(): void;
+    private setModelAsString;
+    handleClearIconClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDatePickerComponent, [{ optional: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDatePickerComponent, "co-input-date", never, { "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare enum KeyboardCode {
+    Backspace = 8,
+    Tab = 9,
+    Enter = 13,
+    Shift = 16,
+    Escape = 27,
+    SpaceBar = 32,
+    End = 35,
+    Home = 36,
+    Left = 37,
+    Up = 38,
+    Right = 39,
+    Down = 40,
+    Insert = 45,
+    Delete = 46,
+    Zero = 48,
+    One = 49,
+    Two = 50,
+    Three = 51,
+    Four = 52,
+    Five = 53,
+    Six = 54,
+    Seven = 55,
+    Eight = 56,
+    Nine = 57,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    e = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    NumpadZero = 96,
+    NumpadOne = 97,
+    NumpadTwo = 98,
+    NumpadThree = 99,
+    NumpadFour = 100,
+    NumpadFive = 101,
+    NumpadSix = 102,
+    NumpadSeven = 103,
+    NumpadEight = 104,
+    NumpadNine = 105,
+    Substract = 109,
+    DecimalPoint = 110,
+    Add = 107,
+    MinusFireFox = 173,
+    Equal = 187,
+    Comma = 188,
+    Minus = 189,
+    Period = 190,
+    Tilde = 192
+}
+
+declare class InputTextComponent extends BaseInputComponent<any> implements AfterViewInit {
+    formComponent: FormComponent;
+    protected injector: Injector;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    useContent: boolean;
+    placeholder: string;
+    align: string;
+    type: string;
+    formatPipe: any;
+    min: number;
+    max: number;
+    pattern: string;
+    digitsOnly: boolean;
+    excludePlusMinus: boolean;
+    showClearButton: boolean;
+    keyDownWhiteList: KeyboardCode[];
+    showPlaceholderOnFocus: boolean;
+    leftIcon: CoreComponentsIcon;
+    rightIcon: CoreComponentsIcon;
+    leftIconData: SafeHtml | undefined;
+    rightIconData: SafeHtml | undefined;
+    selectOnFocus: boolean;
+    emptyPlace: boolean;
+    firstDayOfWeek: string;
+    noStyle: boolean;
+    hideArrowButtons: boolean;
+    get isDate(): boolean;
+    leftIconClick: EventEmitter<MouseEvent>;
+    leftIconMouseDown: EventEmitter<MouseEvent>;
+    leftIconMouseUp: EventEmitter<MouseEvent>;
+    rightIconClick: EventEmitter<MouseEvent>;
+    rightIconMouseDown: EventEmitter<MouseEvent>;
+    rightIconMouseUp: EventEmitter<MouseEvent>;
+    clearIconClick: EventEmitter<MouseEvent>;
+    isFocused: EventEmitter<boolean>;
+    showClass(): boolean;
+    get hasLeftIcon(): boolean;
+    get hasRightIcon(): boolean;
+    hasOwnLabel: boolean;
+    handleDocumentPointerUp(event: PointerEvent): void;
+    set model(value: any);
+    get model(): any;
+    get pipedModel(): any;
+    isFocusedOnDate: boolean;
+    weekInputBuffer: string;
+    isWeekInputMode: boolean;
+    private _isLeftIconMouseDown;
+    private _isRightIconMouseDown;
+    constructor(formComponent: FormComponent, injector: Injector, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    handleLeftIconClick(event: MouseEvent): void;
+    handleLeftIconMouseDown(event: MouseEvent): void;
+    handleLeftIconMouseUp(event: MouseEvent): void;
+    handleRightIconClick(event: MouseEvent): void;
+    handleRightIconMouseDown(event: MouseEvent): void;
+    handleRightIconMouseUp(event: MouseEvent): void;
+    handleRightIconPointerDown(event: PointerEvent): void;
+    handleRightIconPointerUp(event: PointerEvent): void;
+    handleInputFocus(event: FocusEvent): void;
+    handleBlur(event: FocusEvent): void;
+    handleDoFocus(event: MouseEvent): void;
+    clearInput(event: MouseEvent): void;
+    handleKeyDownInput(event: KeyboardEvent): void;
+    private convertWeekToDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextComponent, [{ optional: true; }, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTextComponent, "co-input-text", never, { "useContent": { "alias": "useContent"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "align": { "alias": "align"; "required": false; }; "type": { "alias": "type"; "required": false; }; "formatPipe": { "alias": "formatPipe"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "digitsOnly": { "alias": "digitsOnly"; "required": false; }; "excludePlusMinus": { "alias": "excludePlusMinus"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "keyDownWhiteList": { "alias": "keyDownWhiteList"; "required": false; }; "showPlaceholderOnFocus": { "alias": "showPlaceholderOnFocus"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "rightIcon": { "alias": "rightIcon"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "rightIconData": { "alias": "rightIconData"; "required": false; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; }; "emptyPlace": { "alias": "emptyPlace"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "noStyle": { "alias": "noStyle"; "required": false; }; "hideArrowButtons": { "alias": "hideArrowButtons"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, { "leftIconClick": "leftIconClick"; "leftIconMouseDown": "leftIconMouseDown"; "leftIconMouseUp": "leftIconMouseUp"; "rightIconClick": "rightIconClick"; "rightIconMouseDown": "rightIconMouseDown"; "rightIconMouseUp": "rightIconMouseUp"; "clearIconClick": "clearIconClick"; "isFocused": "isFocused"; }, never, ["*"], false, never>;
+}
+
+declare class AppendPipe implements PipeTransform {
+    transform(value: string, append?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppendPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AppendPipe, "append", false>;
+}
+
+declare class AppendPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppendPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppendPipeModule, [typeof AppendPipe], never, [typeof AppendPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppendPipeModule>;
+}
+
+declare class ValidationErrorComponent {
+    icons: IconCacheService;
+    readonly Icons: any;
+    error: string;
+    parentForOverlay: ElementRef;
+    top: number;
+    left: number;
+    showClass(): boolean;
+    constructor(icons: IconCacheService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValidationErrorComponent, "co-validation-error", never, { "error": { "alias": "error"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; "top": { "alias": "top"; "required": false; }; "left": { "alias": "left"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class OverlayParentDirective implements OnDestroy {
+    elementRef: ElementRef;
+    constructor(elementRef: ElementRef);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayParentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlayParentDirective, "[overlayParent]", ["overlayParent"], {}, {}, never, never, false, never>;
+}
+
+declare class OverlayDirective implements OnDestroy, OnInit {
+    set parent(value: OverlayParentDirective | ElementRef | HTMLElement);
+    view: HTMLElement;
+    /**
+     * true; Element is added to the parent template
+     * false; Element is added to the bottom of the DOM
+     */
+    inline: boolean;
+    keepInView: boolean;
+    inheritWidth: boolean;
+    rightAlign: boolean;
+    fullSize: boolean;
+    private _elementRef;
+    private _resizeObserver;
+    private _intersectionObserver;
+    private _parent;
+    constructor(elementRef: ElementRef);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    handleScroll: (event: Event) => void;
+    private _checkAndPlaceElement;
+    private _placeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlayDirective, "[overlay]", never, { "parent": { "alias": "overlay"; "required": false; }; "view": { "alias": "view"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "keepInView": { "alias": "keepInView"; "required": false; }; "inheritWidth": { "alias": "inheritWidth"; "required": false; }; "rightAlign": { "alias": "rightAlign"; "required": false; }; "fullSize": { "alias": "fullSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class OverlayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OverlayModule, [typeof OverlayDirective, typeof OverlayParentDirective], never, [typeof OverlayDirective, typeof OverlayParentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OverlayModule>;
+}
+
+declare class CoreDictionaryService {
+    private readonly _placeholder;
+    translation: {};
+    /**
+     * 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreDictionaryService>;
+}
+
+declare class CoreLocalizePipe implements PipeTransform {
+    private _dictionaryService;
+    constructor(_dictionaryService: CoreDictionaryService);
+    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreLocalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CoreLocalizePipe, "coreLocalize", false>;
+}
+
+declare class CoreComponentsTranslationModule {
+    static forRoot(): ModuleWithProviders<CoreComponentsTranslationModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreComponentsTranslationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreComponentsTranslationModule, [typeof CoreLocalizePipe], never, [typeof CoreLocalizePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreComponentsTranslationModule>;
+}
+
+declare class ValidationErrorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationErrorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ValidationErrorModule, [typeof ValidationErrorComponent], [typeof i2.CommonModule, typeof IconModule, typeof OverlayModule, typeof CoreComponentsTranslationModule], [typeof ValidationErrorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ValidationErrorModule>;
+}
+
+declare class CommitButtonsComponent {
+    private _renderer;
+    set content(children: any);
+    animateDivs: QueryList<ElementRef>;
+    firstShow: boolean;
+    set committing(value: boolean);
+    get committing(): boolean;
+    set commitFinished(value: boolean);
+    get commitFinished(): boolean;
+    parentForOverlay: ElementRef;
+    cancelClick: EventEmitter<MouseEvent>;
+    commitClick: EventEmitter<MouseEvent>;
+    showClass(): boolean;
+    private _committing;
+    private _commitFinished;
+    constructor(_renderer: Renderer2);
+    private _checkAnimation;
+    private _checkAnimationFinished;
+    private _handleAnimationIteration;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommitButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommitButtonsComponent, "co-commit-buttons", never, { "committing": { "alias": "committing"; "required": false; }; "commitFinished": { "alias": "commitFinished"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; }, { "cancelClick": "cancelClick"; "commitClick": "commitClick"; }, never, never, false, never>;
+}
+
+declare class CommitButtonsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommitButtonsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CommitButtonsModule, [typeof CommitButtonsComponent], [typeof i2.CommonModule, typeof OverlayModule], [typeof CommitButtonsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CommitButtonsModule>;
+}
+
+declare class InputTextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputTextModule, [typeof InputTextComponent], [typeof BaseModule, typeof i2.CommonModule, typeof i4$1.FormsModule, typeof IconModule, typeof AppendPipeModule, typeof ValidationErrorModule, typeof CommitButtonsModule, typeof OverlayModule], [typeof InputTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputTextModule>;
+}
+
+declare class CalendarComponent {
+    locale: string;
+    parentForOverlay: ElementRef;
+    highlightDaysBetweenDates: boolean;
+    selectedDate: Date;
+    secondSelectedDate: Date;
+    secondHoveringDate: Date;
+    dateSelected: EventEmitter<Date>;
+    hoveringDate: EventEmitter<Date>;
+    clickedOutside: EventEmitter<void>;
+    showClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarComponent, "co-calendar", never, { "locale": { "alias": "locale"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; "highlightDaysBetweenDates": { "alias": "highlightDaysBetweenDates"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "secondSelectedDate": { "alias": "secondSelectedDate"; "required": false; }; "secondHoveringDate": { "alias": "secondHoveringDate"; "required": false; }; }, { "dateSelected": "dateSelected"; "hoveringDate": "hoveringDate"; "clickedOutside": "clickedOutside"; }, never, never, false, never>;
+}
+
+declare class CalendarTemplateComponent {
+    readonly icons: typeof CoreComponentsIcon;
+    showWeekNumbers: boolean;
+    weekNumbers: number[];
+    locale: string;
+    highlightDaysBetweenDates: boolean;
+    showButtons: boolean;
+    doubleCalendar: boolean;
+    set selectedDate(value: Date | string | number | null | undefined);
+    get selectedDate(): Date | null;
+    set secondSelectedDate(value: Date | string | number | null | undefined);
+    get secondSelectedDate(): Date | null;
+    set secondHoveringDate(value: Date | string | number | null | undefined);
+    private _coerceToDate;
+    dateSelected: EventEmitter<Date>;
+    secondDateSelected: EventEmitter<Date>;
+    hoveringDate: EventEmitter<Date>;
+    clickedOutside: EventEmitter<void>;
+    clearDates: EventEmitter<void>;
+    showCalendarBody: boolean;
+    showMonthSelection: boolean;
+    showYearSelection: boolean;
+    showSelectedMonth: string;
+    workingDay: Date;
+    workingYear: number;
+    workingMonth: number;
+    monthHeader: string;
+    yearHeader: string;
+    monthSelection: boolean;
+    yearSelection: boolean;
+    dayNames: any[];
+    monthNames: any[];
+    monthSelectionNames: string[];
+    yearSelectionYears: number[];
+    daysInMonth: Date[];
+    daysUnixTimestamps: number[];
+    daysToHighlight: Date[];
+    temporarySelectedSecondaryDate: Date;
+    private _secondHoveringDate;
+    private _secondSelectedDate;
+    private _selectedDate;
+    private _initialSelectedDate;
+    showClass(): boolean;
+    ngOnInit(): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    prevYear(): void;
+    nextYear(): void;
+    generateCalendar(): void;
+    private _setInitialValues;
+    private _setMonthDaysForDate;
+    generateYearSelectionYears(): void;
+    openMonthSelection(): void;
+    openYearSelection(): void;
+    selectDate(day: Date): void;
+    selectMonth(month: string): void;
+    selectYear(year: number): void;
+    generateMonthNames(): void;
+    handleMouseOverDay(day: Date): void;
+    private _fillDatesBetweenSelected;
+    private _capitalizeFirstLetter;
+    private calculateWeekNumbers;
+    getISOWeek(date: Date): number;
+    setAndClose(): void;
+    clearDate(): void;
+    closeDate(): void;
+    private closePopup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarTemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarTemplateComponent, "calendar-template", never, { "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "highlightDaysBetweenDates": { "alias": "highlightDaysBetweenDates"; "required": false; }; "showButtons": { "alias": "showButtons"; "required": false; }; "doubleCalendar": { "alias": "doubleCalendar"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "secondSelectedDate": { "alias": "secondSelectedDate"; "required": false; }; "secondHoveringDate": { "alias": "secondHoveringDate"; "required": false; }; }, { "dateSelected": "dateSelected"; "secondDateSelected": "secondDateSelected"; "hoveringDate": "hoveringDate"; "clickedOutside": "clickedOutside"; "clearDates": "clearDates"; }, never, never, false, never>;
+}
+
+declare class ClickOutsideMasterService implements OnDestroy {
+    private readonly _ngZone;
+    get currentClick(): MouseEvent;
+    private _clickOutsideRefs;
+    private _currentClick;
+    constructor(_ngZone: NgZone);
+    ngOnDestroy(): void;
+    onClick: (event: MouseEvent) => void;
+    checkEmit(clickOutside: ClickOutsideDirective, event: Event, force?: boolean): void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    addClickOutside(clickOutside: ClickOutsideDirective): void;
+    removeClickOutside(clickOutside: ClickOutsideDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideMasterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickOutsideMasterService>;
+}
+
+declare class ClickOutsideDirective implements OnDestroy, AfterViewInit {
+    elementRef: ElementRef;
+    private _ngZone;
+    private _master;
+    get currentClick(): MouseEvent;
+    set enabled(enabled: boolean);
+    alwaysTrigger: boolean;
+    readonly clickOutside: EventEmitter<Event>;
+    private _currentClick;
+    private _enabled;
+    private _initialized;
+    constructor(elementRef: ElementRef, _ngZone: NgZone, _master: ClickOutsideMasterService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick: (event: MouseEvent) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[clickOutside]", ["clickOutside"], { "enabled": { "alias": "clickOutside"; "required": false; }; "alwaysTrigger": { "alias": "alwaysTrigger"; "required": false; }; }, { "clickOutside": "clickOutside"; }, never, never, false, never>;
+}
+
+declare class ClickoutsideModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickoutsideModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClickoutsideModule, [typeof ClickOutsideDirective], never, [typeof ClickOutsideDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClickoutsideModule>;
+}
+
+declare class CalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CalendarModule, [typeof CalendarComponent, typeof CalendarTemplateComponent], [typeof i2.CommonModule, typeof IconModule, typeof OverlayModule, typeof ClickoutsideModule, typeof CoreComponentsTranslationModule], [typeof CalendarComponent, typeof CalendarTemplateComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CalendarModule>;
+}
+
+declare class InputDatePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDatePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputDatePickerModule, [typeof InputDatePickerComponent], [typeof i2.CommonModule, typeof InputTextModule, typeof CalendarModule, typeof ClickoutsideModule, typeof OverlayModule, typeof i4$1.ReactiveFormsModule], [typeof InputDatePickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputDatePickerModule>;
+}
+
+declare abstract class BaseInputTimeDirective extends BaseInputComponent<any> implements OnInit {
+    readonly rightIcon: CoreComponentsIcon;
+    parentForOverlay: ElementRef;
+    locale: string;
+    placeholder: string;
+    leftIcon: CoreComponentsIcon;
+    leftIconData: SafeHtml;
+    leftIconClick: EventEmitter<MouseEvent>;
+    closeAfterDateSelection: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInputTimeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseInputTimeDirective, never, never, { "locale": { "alias": "locale"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "closeAfterDateSelection": { "alias": "closeAfterDateSelection"; "required": false; }; }, { "leftIconClick": "leftIconClick"; }, never, never, true, never>;
+}
+
+declare class InputTimeComponent extends BaseInputTimeDirective {
+    timeAsString: string;
+    protected modelSet(): void;
+    private setTimeAsString;
+    handleTimeChange(value: string): void;
+    handleClearIconClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTimeComponent, "co-input-time", never, {}, {}, never, never, false, never>;
+}
+
+declare class InputTimeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputTimeModule, [typeof InputTimeComponent], [typeof i2.CommonModule, typeof InputTextModule, typeof ClickoutsideModule, typeof OverlayModule], [typeof InputTimeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputTimeModule>;
+}
+
+declare class DoubleCalendarComponent extends BaseInputDatePickerDirective implements OnInit {
+    selectedDates: Date[];
+    ownParentForOverlay: ElementRef;
+    datesSelected: EventEmitter<Date[]>;
+    secondDateSelected: EventEmitter<void>;
+    clickedOutside: EventEmitter<void>;
+    selectedFirstDate: Date;
+    selectedSecondDate: Date;
+    secondHoveringDate: Date;
+    showClass(): boolean;
+    ngOnInit(): void;
+    handleFirstDateSelected(date: Date): void;
+    handleSecondDateSelected(date: Date): void;
+    outputRangeIfValid(): void;
+    handleSecondHoveringDate(day: Date): void;
+    clearAllDates(): void;
+    private _closeIfRangeComplete;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DoubleCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DoubleCalendarComponent, "co-double-calendar", never, { "selectedDates": { "alias": "selectedDates"; "required": false; }; "ownParentForOverlay": { "alias": "ownParentForOverlay"; "required": false; }; }, { "datesSelected": "datesSelected"; "secondDateSelected": "secondDateSelected"; "clickedOutside": "clickedOutside"; }, never, never, false, never>;
+}
+
+declare class DoubleCalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DoubleCalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DoubleCalendarModule, [typeof DoubleCalendarComponent], [typeof i2.CommonModule, typeof CalendarModule, typeof OverlayModule, typeof ClickoutsideModule], [typeof DoubleCalendarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DoubleCalendarModule>;
+}
+
+declare class InputDateRangePickerComponent extends BaseInputDatePickerDirective {
+    firstDateAsString: any;
+    secondDateAsString: any;
+    private readonly EARLIEST_DATE;
+    private readonly LATEST_DATE;
+    private _doubleCalendarComponentRef;
+    firstDayOfWeek: string;
+    firstInput: ElementRef;
+    secondInput: ElementRef;
+    showClass(): boolean;
+    handleFirstInputClick(event: Event): void;
+    handleSecondInputClick(event: Event): void;
+    handleDatesSelected(dates: Date[]): void;
+    handleSecondDateSelected(): void;
+    clearDate(index: number): void;
+    toggleCalendar(): void;
+    handleFirstDateChanged(value: string): void;
+    handleSecondDateChanged(value: string): void;
+    finalizeDates(): void;
+    finalize(): void;
+    private isValidDateString;
+    protected modelSet(): void;
+    private setModelAsString;
+    private formatDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateRangePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateRangePickerComponent, "co-input-date-range", never, { "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class InputDateRangePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateRangePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputDateRangePickerModule, [typeof InputDateRangePickerComponent], [typeof i2.CommonModule, typeof InputTextModule, typeof ClickoutsideModule, typeof OverlayModule, typeof DoubleCalendarModule], [typeof InputDateRangePickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputDateRangePickerModule>;
+}
+
+declare class BoundsConstrainedNumberValue {
+    set value(value: number);
+    get value(): number;
+    get valueAsSting(): string;
+    set min(min: number);
+    get min(): number;
+    set max(max: number);
+    get max(): number;
+    get trueMax(): number;
+    set step(step: number);
+    set decimals(decimals: number);
+    get step(): number;
+    get stepDecimals(): number;
+    get constraintsEnabled(): boolean;
+    valueChange: Subject<number>;
+    protected _value: number;
+    protected _decimals: number;
+    protected _valueAsString: string;
+    protected _min: number;
+    protected _max: number;
+    protected _step: number;
+    protected _stepDecimals: number;
+    protected _trueMax: number;
+    private _constraintsEnabled;
+    private _precision?;
+    private _scale?;
+    constructor();
+    roundedDecimals(value: number): number;
+    putPrecision(precision: number): void;
+    putScale(scale: number): void;
+    init(silent?: boolean): void;
+    setValueByUserInputText(text: string, silent?: boolean): boolean;
+    /**
+     * Makes sure current value adheres to our stepped bounds. Returns true if inner value really changed (after sanitizing), false if not.
+     * Returns whether value really changed.
+     */
+    setValue(newValue: number, silent?: boolean): boolean;
+    increment(steps?: number): void;
+    decrement(steps?: number): void;
+    disableConstraints(): void;
+    enableConstraints(): void;
+    private _updateTrueMax;
+    private _updateStepDecimals;
+    private _setValue;
+}
+
+declare enum InputNumberPickerButtonShowMode {
+    Always = "always",
+    OnFocusOnly = "onFocusOnly",
+    Never = "never"
+}
+
+declare class InputNumberPickerComponent extends BaseInputComponent<number> implements OnInit, OnDestroy {
+    formComponent: FormComponent;
+    iconCacheService: IconCacheService;
+    protected overlayService: OverlayService;
+    private _ngZone;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    set model(model: number);
+    get model(): number;
+    modelChangeOnEnter: boolean;
+    showPermanentLabel: boolean;
+    leftIconData: SafeHtml | undefined;
+    set min(min: number);
+    set step(step: number);
+    set max(max: number);
+    ngModelOptions: any;
+    minusIcon: CoreComponentsIcon;
+    plusIcon: CoreComponentsIcon;
+    buttonShowMode: InputNumberPickerButtonShowMode;
+    noValidation: boolean;
+    set decimals(decimals: number);
+    readonly modelChange: EventEmitter<number>;
+    readonly iconClick: EventEmitter<MouseEvent>;
+    get showButtonsOnFocusOnly(): boolean;
+    get hasLabel(): boolean;
+    showClass(): boolean;
+    showButtons: boolean;
+    readonly myKeyDownWhiteList: KeyboardCode[];
+    readonly numberLogic: BoundsConstrainedNumberValue;
+    minSelected: boolean;
+    plusSelected: boolean;
+    private _numberInputHasFocus;
+    private _changeFromButton;
+    private _numberLogicValueChangeSub;
+    private readonly _delayBeforeStartAutoCountMs;
+    private readonly _stepFactors;
+    private readonly _msChangeStepFactor;
+    private readonly _msDoStep;
+    private _stepFactor;
+    private _mayAutoCount;
+    private _autoCountTimeout;
+    private _stepIncrementTimeout;
+    private _startAutocountTimeout;
+    constructor(formComponent: FormComponent, iconCacheService: IconCacheService, overlayService: OverlayService, _ngZone: NgZone, componentFactoryResolver: ComponentFactoryResolver, changeDetector: ChangeDetectorRef, formUserChangeListener: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    doIncrementAuto(): void;
+    handleInputKeyDown(event: KeyboardEvent): boolean;
+    handleBlur(): void;
+    handleChangeModel(value: number): void;
+    doDecrementAuto(): void;
+    stopAutoCounting(): void;
+    setValue(newValue: number, silent?: boolean): void;
+    increment(steps?: number): void;
+    decrement(steps?: number): void;
+    onPlusMouseDown(event: Event): void;
+    onMinusMouseDown(event: Event): void;
+    private _doIncreaseStepFactor;
+    private _getNextStepFactorMouseDown;
+    private _updateButtonsShowState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputNumberPickerComponent, [{ optional: true; }, null, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputNumberPickerComponent, "co-input-number-picker", never, { "model": { "alias": "model"; "required": false; }; "modelChangeOnEnter": { "alias": "modelChangeOnEnter"; "required": false; }; "showPermanentLabel": { "alias": "showPermanentLabel"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "min": { "alias": "min"; "required": false; }; "step": { "alias": "step"; "required": false; }; "max": { "alias": "max"; "required": false; }; "ngModelOptions": { "alias": "ngModelOptions"; "required": false; }; "minusIcon": { "alias": "minusIcon"; "required": false; }; "plusIcon": { "alias": "plusIcon"; "required": false; }; "buttonShowMode": { "alias": "buttonShowMode"; "required": false; }; "noValidation": { "alias": "noValidation"; "required": false; }; "decimals": { "alias": "decimals"; "required": false; }; }, { "modelChange": "modelChange"; "iconClick": "iconClick"; }, never, never, false, never>;
+}
+
+declare class InputNumberPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputNumberPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputNumberPickerModule, [typeof InputNumberPickerComponent], [typeof i2.CommonModule, typeof i4$1.FormsModule, typeof ButtonModule, typeof InputTextModule, typeof IconModule], [typeof InputNumberPickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputNumberPickerModule>;
+}
+
+declare class InputRadioButtonComponent extends BaseInputComponent<any> {
+    formComponent: FormComponent;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    get isModelSelected(): boolean;
+    showClass(): boolean;
+    handleClick(event: MouseEvent): void;
+    constructor(formComponent: FormComponent, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputRadioButtonComponent, [{ optional: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputRadioButtonComponent, "co-input-radio-button", never, {}, {}, never, never, false, never>;
+}
+
+declare class InputRadioButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputRadioButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputRadioButtonModule, [typeof InputRadioButtonComponent], [typeof BaseModule, typeof i2.CommonModule, typeof i4$1.FormsModule], [typeof InputRadioButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputRadioButtonModule>;
+}
+
+declare class InputSearchComponent extends BaseInputComponent<string> implements OnDestroy {
+    readonly searchIcon: CoreComponentsIcon;
+    placeholder: string;
+    handleKeydown: boolean;
+    search: EventEmitter<string>;
+    isFocused: EventEmitter<boolean>;
+    leftIconClick: EventEmitter<MouseEvent>;
+    rightIconClick: EventEmitter<MouseEvent>;
+    useLeftIcon: boolean;
+    useRightIcon: boolean;
+    leftIconData: SafeHtml | undefined;
+    rightIconData: SafeHtml | undefined;
+    centerLabel: boolean;
+    showClass(): boolean;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleModelChange(model: string): void;
+    private isMobileDevice;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputSearchComponent, "co-input-search", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "handleKeydown": { "alias": "handleKeydown"; "required": false; }; "useLeftIcon": { "alias": "useLeftIcon"; "required": false; }; "useRightIcon": { "alias": "useRightIcon"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "rightIconData": { "alias": "rightIconData"; "required": false; }; "centerLabel": { "alias": "centerLabel"; "required": false; }; }, { "search": "search"; "isFocused": "isFocused"; "leftIconClick": "leftIconClick"; "rightIconClick": "rightIconClick"; }, never, never, false, never>;
+}
+
+declare class InputSearchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSearchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputSearchModule, [typeof InputSearchComponent], [typeof i2.CommonModule, typeof IconModule, typeof i4$1.FormsModule, typeof InputTextModule], [typeof InputSearchComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputSearchModule>;
+}
+
+declare class InputTextareaComponent extends BaseInputComponent<any> implements AfterViewInit {
+    formComponent: FormComponent;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    placeholder: string;
+    showClass(): boolean;
+    hasOwnLabel: boolean;
+    constructor(formComponent: FormComponent, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextareaComponent, [{ optional: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTextareaComponent, "co-input-textarea", never, { "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class InputTextareaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextareaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputTextareaModule, [typeof InputTextareaComponent], [typeof i2.CommonModule, typeof i4$1.FormsModule, typeof ValidationErrorModule, typeof CommitButtonsModule, typeof OverlayModule], [typeof InputTextareaComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputTextareaModule>;
+}
+
+declare enum PopupButtonType {
+    Ok = 0,
+    Open = 1,
+    Save = 2,
+    Cancel = 3,
+    Yes = 4,
+    No = 5,
+    NoButton = 6
+}
+
+declare enum PopupType {
+    Notification = 0,
+    Warning = 1,
+    Error = 2,
+    Question = 3,
+    Blank = 4,
+    FullScreen = 5,
+    Confirmation = 6
+}
+
+declare class PopupButton {
+    label: string;
+    cssClass: string;
+    closeType: PopupButtonType;
+    disabled: boolean;
+    constructor(label: string, cssClass: string, closeType: PopupButtonType);
+}
+
+declare class PopupButtonsComponent implements OnInit {
+    popupWindow: any;
+    readonly buttonClick: EventEmitter<PopupButton>;
+    firstButton: ButtonComponent;
+    buttons: PopupButton[];
+    constructor();
+    ngOnInit(): void;
+    handleClick(event: MouseEvent, button: PopupButton): void;
+    focusFirstButton(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopupButtonsComponent, "co-popup-buttons", never, { "popupWindow": { "alias": "popupWindow"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, false, never>;
+}
+
+declare class PopupWindowShellComponent implements AfterViewInit, OnDestroy, OnInit {
+    private _iconCache;
+    private _changeDetector;
+    viewContainerRef: ViewContainerRef;
+    readonly icons: typeof CoreComponentsIcon;
+    popupWindow: PopupWindowModel;
+    hasMobileSizings: boolean;
+    protected _viewContainer: ViewContainerRef;
+    protected _appPopupButtons: PopupButtonsComponent;
+    isError: boolean;
+    isWarning: boolean;
+    isNotification: boolean;
+    isQuestion: boolean;
+    isMovable: boolean;
+    isBlank: boolean;
+    closeIcon: SafeHtml;
+    downloadIcon: SafeHtml;
+    private _popupCompRef;
+    private _filterClickSub;
+    private _popupCloseRequestSub;
+    constructor(_iconCache: IconCacheService, _changeDetector: ChangeDetectorRef, viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(eventType: PopupButtonType): Promise<void>;
+    onButtonClick(button: PopupButton): void;
+    onDownloadClick(): void;
+    onCloseClick(): void;
+    private _close;
+    private _createPopupComponent;
+    private _initOnClickAutoClose;
+    private _initAppPopupCloseRequestHandler;
+    private _setHostBindings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupWindowShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopupWindowShellComponent, "co-popup-window-shell", never, { "popupWindow": { "alias": "popupWindow"; "required": false; }; "hasMobileSizings": { "alias": "hasMobileSizings"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class PopupSettings {
+    title: string;
+    autoClose: boolean;
+    type: PopupType;
+    buttons?: PopupButton[];
+    hideCloseIcon?: boolean;
+    noButtonFocus?: boolean;
+    fixed?: boolean;
+    downloadable?: boolean;
+    constructor();
+    enableButtonByType(buttonType: PopupButtonType): void;
+    disableButtonByType(buttonType: PopupButtonType): void;
+    enableSaveButton(): void;
+    disableSaveButton(): void;
+    enableOpenButton(): void;
+    disableOpenButton(): void;
+    private _getButtonByType;
+}
+
+declare class PopupWindowModel {
+    factory: ComponentFactory<Popup>;
+    settings: PopupSettings;
+    inputs: any;
+    static readonly closeDefaultOutputStr: string;
+    get type(): PopupType;
+    uuid: string;
+    popupWindowComponent?: PopupWindowShellComponent;
+    constructor(factory: ComponentFactory<Popup>, settings: PopupSettings, inputs: any);
+    closeDefault(): void;
+    enableOpenButton(): void;
+    disableOpenButton(): void;
+    getTitle(): string;
+    onClose(eventType: PopupButtonType, output?: any): void;
+}
+
+interface Popup<T = any> {
+    readonly closeRequest?: EventEmitter<PopupButtonType>;
+    popupModel?: PopupWindowModel;
+    onOpen?(): void;
+    onClose(eventType: PopupButtonType): Promise<T>;
+}
+
+declare class TextInputPopupComponent implements Popup<string>, AfterViewInit, OnDestroy {
+    private _changeDetector;
+    text: string;
+    label: string;
+    constructor(_changeDetector: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onClose(eventType: PopupButtonType): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextInputPopupComponent, "co-text-input-popup", never, { "text": { "alias": "text"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class PopupMessageDisplayComponent implements Popup<PopupButtonType> {
+    set message(value: string);
+    get message(): string;
+    details: string;
+    image: boolean;
+    private _message;
+    constructor();
+    onClose(eventType: PopupButtonType): Promise<PopupButtonType>;
+    handleCopyClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupMessageDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopupMessageDisplayComponent, "co-popup-message-display", never, { "message": { "alias": "message"; "required": false; }; "details": { "alias": "details"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class PopupModule {
+    static forRoot(): ModuleWithProviders<PopupModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PopupModule, [typeof TextInputPopupComponent, typeof PopupMessageDisplayComponent, typeof PopupWindowShellComponent, typeof PopupButtonsComponent], [typeof i2.CommonModule, typeof InputTextModule, typeof ButtonModule], [typeof TextInputPopupComponent, typeof PopupWindowShellComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PopupModule>;
+}
+
+interface PopupCloseEvent<T = any> {
+    eventType: PopupButtonType;
+    output: T;
+}
+
+declare class PopupShowerService {
+    private _compFactoryResolver;
+    private _appRef;
+    private _overlay;
+    private _injector;
+    constructor(_compFactoryResolver: ComponentFactoryResolver, _appRef: ApplicationRef, _overlay: Overlay, _injector: Injector);
+    showPopup<T = any>(popupCompClazz: any, popupSettings: PopupSettings, inputs?: any): Promise<PopupCloseEvent<T>>;
+    private _createWindowShell;
+    private _createOverlay;
+    private _getConfig;
+    private _attachDialogContainer;
+    private _createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupShowerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PopupShowerService>;
+}
+
+declare class StringPromptResultEvent {
+    eventType: PopupButtonType;
+    output: string;
+    constructor(eventType: PopupButtonType, output: string);
+}
+
+declare class PromptService {
+    private _popupShower;
+    constructor(_popupShower: PopupShowerService);
+    promptString(title: string, label?: string, initialText?: string): Promise<StringPromptResultEvent>;
+    showError(textOrImageDataUri: string, title?: string, details?: string): Promise<PopupCloseEvent<void>>;
+    showWarning(textOrImageDataUri: string, title?: string): Promise<PopupCloseEvent<void>>;
+    showNotification(textOrImageDataUri: string, title?: string, showOk?: boolean, autoClose?: boolean, hideCloseIcon?: boolean, downloadable?: boolean): Promise<boolean>;
+    showImage(imageDataUri: string, title?: string): Promise<any>;
+    showYesNo(textOrImageDataUri: string, title?: string): Promise<boolean>;
+    showModalYesNoCancel(textOrImageDataUri: string, title?: string): Promise<PopupCloseEvent<void>>;
+    showOk(text: string, title?: string): Promise<boolean>;
+    showOkCancel(text: string, title?: string): Promise<boolean>;
+    showOkModal(text: string, title?: string): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PromptService>;
+}
+
+declare enum ColumnAlign {
+    Left = "left-align",
+    Center = "center-align",
+    Right = "right-align"
+}
+declare class SimpleGridColumnDirective implements OnInit, OnDestroy {
+    elementRef: ElementRef;
+    private static _MinManualResizeWidthPx;
+    set headerTemplate(template: TemplateRef<any>);
+    get headerTemplate(): TemplateRef<any>;
+    set template(template: TemplateRef<any>);
+    get template(): TemplateRef<any>;
+    set editTemplate(template: TemplateRef<any>);
+    get editTemplate(): TemplateRef<any>;
+    headerText: string;
+    field: string;
+    codeField: string;
+    displayField: string;
+    textAlign: ColumnAlign;
+    format: string;
+    resizable: boolean;
+    required: boolean;
+    autoFit: boolean;
+    isSelected: boolean;
+    set width(value: number | string);
+    get width(): number | string;
+    readonly: boolean;
+    collection: {}[];
+    order: number;
+    singleColumn: boolean;
+    originalWidth: number | string;
+    widthPercentage: string;
+    private _width;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getFieldValue(value: any): string;
+    private _headerTemplate;
+    private _template;
+    private _editTemplate;
+    private _setSingleColumnProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleGridColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SimpleGridColumnDirective, "co-simple-grid-column", never, { "headerText": { "alias": "headerText"; "required": false; }; "field": { "alias": "field"; "required": false; }; "codeField": { "alias": "codeField"; "required": false; }; "displayField": { "alias": "displayField"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "format": { "alias": "format"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "required": { "alias": "required"; "required": false; }; "autoFit": { "alias": "autoFit"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "width": { "alias": "width"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "order": { "alias": "order"; "required": false; }; "singleColumn": { "alias": "singleColumn"; "required": false; }; }, {}, ["headerTemplate", "template", "editTemplate"], never, false, never>;
+}
+
+declare abstract class BaseSimpleGridComponent {
+    protected changeDetection: ChangeDetectorRef;
+    readonly MIN_COLUMN_WIDTH: number;
+    readonly dataChanged: Subject<void>;
+    set content(columnComponents: QueryList<SimpleGridColumnDirective>);
+    set data(value: Object[]);
+    get data(): Object[];
+    set exportData(value: Object[]);
+    get exportData(): Object[];
+    dragDropEnabled: boolean;
+    resizable: boolean;
+    inlineEdit: boolean;
+    showEdit: boolean;
+    showToolbar: boolean;
+    autoAddRow: boolean;
+    /**
+     * Should component emit drag and drop actions instead of handle
+     * (update collection) by itself
+     */
+    emitDragDrop: boolean;
+    set extraColumns(value: SimpleGridColumnDirective[]);
+    onDrop: EventEmitter<{
+        from: number;
+        to: number;
+    }>;
+    selectRow: EventEmitter<{}>;
+    deselectRow: EventEmitter<void>;
+    dblClickRow: EventEmitter<{}>;
+    saveRow: EventEmitter<{}>;
+    deleteRow: EventEmitter<{}>;
+    addRow: EventEmitter<void>;
+    rowVisible: EventEmitter<{}>;
+    handleMouseMove(event: MouseEvent): void;
+    handleMouseUp(event: MouseEvent): void;
+    columns: SimpleGridColumnDirective[];
+    headerColumns: SimpleGridColumnDirective[];
+    headerColumnsCopy: SimpleGridColumnDirective[];
+    protected _data: Object[];
+    protected _exportData: Object[];
+    protected disabledRows: number[];
+    private _columnForResize;
+    private _prepared;
+    private _startMousePositionX;
+    constructor(changeDetection: ChangeDetectorRef);
+    handleSizerMouseDown(event: MouseEvent, column: SimpleGridColumnDirective): void;
+    handleCanDragDrop(drag: CdkDrag, drop: CdkDropList): boolean;
+    handleDrop(event: CdkDragDrop<Object[]>): void;
+    isSingleColumnRow(row: Object): boolean;
+    singleColumnIndex(row: Object): number;
+    protected prepareDataRow(row: any, index: number): Promise<void>;
+    private _setColumns;
+    private _prepareData;
+    private _resizeColumnsToFit;
+    private _setWidthOfAllColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSimpleGridComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSimpleGridComponent, never, never, { "data": { "alias": "data"; "required": false; }; "exportData": { "alias": "exportData"; "required": false; }; "dragDropEnabled": { "alias": "dragDropEnabled"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "inlineEdit": { "alias": "inlineEdit"; "required": false; }; "showEdit": { "alias": "showEdit"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "autoAddRow": { "alias": "autoAddRow"; "required": false; }; "emitDragDrop": { "alias": "emitDragDrop"; "required": false; }; "extraColumns": { "alias": "extraColumns"; "required": false; }; }, { "onDrop": "onDrop"; "selectRow": "selectRow"; "deselectRow": "deselectRow"; "dblClickRow": "dblClickRow"; "saveRow": "saveRow"; "deleteRow": "deleteRow"; "addRow": "addRow"; "rowVisible": "rowVisible"; }, ["content"], never, true, never>;
+}
+
+declare class SimpleGridComponent extends BaseSimpleGridComponent {
+    icons: IconCacheService;
+    protected changeDetection: ChangeDetectorRef;
+    private _formMaster;
+    readonly defaultTextAlign: ColumnAlign;
+    set headerCells(cells: any);
+    rowElements: QueryList<ElementRef>;
+    showAdd: boolean;
+    showDelete: boolean;
+    deselectAllowed: boolean;
+    editOnCellClick: boolean;
+    rightToolbar: boolean;
+    showGridSettings: boolean;
+    rowsPerPage: number;
+    rowDisabledFn: Function;
+    showColumnSort: boolean;
+    showRowButtons: boolean;
+    /**
+     * Promise function, if provided should return boolean
+     */
+    canRowBeEdittedFn: Function;
+    showClass(): boolean;
+    handleKeyDown(event: KeyboardEvent): void;
+    editing: boolean;
+    isSettingsMenuOpen: boolean;
+    editRowIndex: number;
+    editCellIndex: number;
+    selectedRowIndex: number;
+    rowToEdit: any;
+    currentPage: number;
+    sortColumnValue: string;
+    sortDirection: 'asc' | 'desc';
+    hoveredRowIndex: number;
+    readonly Icons: typeof CoreComponentsIcon;
+    private _doubleClicked;
+    private _newRow;
+    private _newRowReference;
+    protected readonly IconCacheService: typeof IconCacheService;
+    protected readonly CoreComponentsIcon: typeof CoreComponentsIcon;
+    constructor(icons: IconCacheService, changeDetection: ChangeDetectorRef, _formMaster: FormMasterService);
+    handleClickOutsideRow(): void;
+    getIsRowDisabled(idx: number): boolean;
+    isRowDisabled(row: any, index: number): Promise<boolean>;
+    addNewRow(): Promise<void>;
+    validateAndSave(stopediting?: boolean): boolean;
+    cancelEditRow(): void;
+    removeRow(row: any): void;
+    removeSelectedRow(): void;
+    handleClickRow(event: MouseEvent, index: number): void;
+    selectTheRow(index: number, emit?: boolean): void;
+    handleDblClickRow(event: MouseEvent, index: number, row: any): Promise<void>;
+    editRow(event: MouseEvent, selectCell?: boolean, rowIndex?: number): Promise<void>;
+    handleCellClick(event: MouseEvent, row: any, rowIndex: number, cellIndex: number): Promise<void>;
+    toggleSettingsMenu(): void;
+    toggleColumnMenu(col: any): void;
+    hideColumn(col: any): void;
+    sortColumn(col: any, columnValue: string): void;
+    showAllColumns(): void;
+    exportToExcel(): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    setCurrentPage(page: number): void;
+    get isNewRow(): boolean;
+    private _filterSelectedOrReturnAll;
+    protected prepareDataRow(row: any, index: number): Promise<void>;
+    private _resetDblClick;
+    /**
+     *
+     * @param next; Move to next or previous cell
+     * @param start; Start from cellindex
+     * @private
+     */
+    private _nextAvailableCellToEdit;
+    private _getNextEditCellIndex;
+    private _getPreviousEditCellIndex;
+    private _getNextEditRowIndex;
+    private _getPreviousEditRowIndex;
+    private _saveRow;
+    private _detectChanges;
+    private _resetEdit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleGridComponent, "co-simple-grid", never, { "showAdd": { "alias": "showAdd"; "required": false; }; "showDelete": { "alias": "showDelete"; "required": false; }; "deselectAllowed": { "alias": "deselectAllowed"; "required": false; }; "editOnCellClick": { "alias": "editOnCellClick"; "required": false; }; "rightToolbar": { "alias": "rightToolbar"; "required": false; }; "showGridSettings": { "alias": "showGridSettings"; "required": false; }; "rowsPerPage": { "alias": "rowsPerPage"; "required": false; }; "rowDisabledFn": { "alias": "rowDisabledFn"; "required": false; }; "showColumnSort": { "alias": "showColumnSort"; "required": false; }; "showRowButtons": { "alias": "showRowButtons"; "required": false; }; "canRowBeEdittedFn": { "alias": "canRowBeEdittedFn"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SimpleGridCellComponent {
+    private _changeDetector;
+    get editMode(): boolean;
+    set editMode(value: boolean);
+    readonly defaultTextAlign: ColumnAlign;
+    set editTemplateContent(template: any);
+    set noEditTemplateContent(template: any);
+    set noTemplateContent(template: any);
+    column: SimpleGridColumnDirective;
+    row: {};
+    private _editMode;
+    set fieldEditMode(value: boolean);
+    get fieldEditMode(): boolean;
+    cellClick: EventEmitter<MouseEvent>;
+    showClass(): boolean;
+    handleClick(event: MouseEvent): void;
+    private _fieldEditMode;
+    private _focused;
+    private _editTemplate;
+    private _template;
+    private _inputTemplate;
+    constructor(_changeDetector: ChangeDetectorRef);
+    private _setFocusComponent;
+    private _getFirstFormInput;
+    private _createNewEvent;
+    private _getElement;
+    private _detectChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleGridCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleGridCellComponent, "co-simple-grid-cell", never, { "editMode": { "alias": "editMode"; "required": false; }; "column": { "alias": "column"; "required": false; }; "row": { "alias": "row"; "required": false; }; "fieldEditMode": { "alias": "fieldEditMode"; "required": false; }; }, { "cellClick": "cellClick"; }, never, never, false, never>;
+}
+
+declare class ObserveVisibilityDirective implements OnDestroy, OnInit, AfterViewInit {
+    private _element;
+    threshold: number;
+    visibilityChange: EventEmitter<boolean>;
+    visible: boolean;
+    private _observer;
+    constructor(_element: ElementRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _createObserver;
+    private _startObservingElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserveVisibilityDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ObserveVisibilityDirective, "[observeVisibility]", ["visibilityObserve"], { "threshold": { "alias": "threshold"; "required": false; }; }, { "visibilityChange": "visibilityChange"; }, never, never, false, never>;
+}
+
+declare class ObserveVisibilityModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserveVisibilityModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ObserveVisibilityModule, [typeof ObserveVisibilityDirective], never, [typeof ObserveVisibilityDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ObserveVisibilityModule>;
+}
+
+interface IPaginationInstance {
+    id?: string;
+    itemsPerPage: number;
+    currentPage: number;
+    /**
+     * The total number of items in the collection. Only useful when
+     * doing server-side paging, where the collection size is limited
+     * to a single page returned by the server API.
+     *
+     * For in-memory paging, this property should not be set, as it
+     * will be automatically set to the value of  collection.length.
+     */
+    totalItems?: number;
+}
+
+declare class PaginationService {
+    private static readonly DEFAULT_ID;
+    change: Subject<string>;
+    get DEFAULT_ID(): string;
+    private readonly instances;
+    constructor();
+    register(instance: IPaginationInstance): void;
+    getCurrentPage(id: string): number;
+    setCurrentPage(id: string, page: number): void;
+    setTotalItems(id: string, totalItems: number): void;
+    setItemsPerPage(id: string, itemsPerPage: number): void;
+    /**
+     * Returns a clone of the pagination instance object matching the id. If no
+     * id specified, returns the instance corresponding to the default id.
+     */
+    getInstance(id?: string): IPaginationInstance;
+    /**
+     * Check each property of the instance and update any that have changed. Return
+     * true if any changes were made, else return false.
+     */
+    private updateInstance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationService>;
+}
+
+declare class PaginationComponent implements OnInit, OnChanges, OnDestroy {
+    private _paginationService;
+    readonly template: ElementRef;
+    id: string;
+    maxSize: number;
+    directionLinks: boolean;
+    previousLabel: string;
+    nextLabel: string;
+    autoHide: boolean;
+    readonly pageChange: EventEmitter<number>;
+    showClass: boolean;
+    totalItems: number;
+    itemsPerPage: number;
+    private changeSub;
+    constructor(_paginationService: PaginationService);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    goToFirstPage(): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    setCurrentPage(page: number): void;
+    shouldBeHidden(): boolean;
+    /**
+     * Updates the page links and checks that the current page is valid. Should run whenever the
+     * PaginationService.change stream emits a value matching the current ID, or when any of the
+     * input values changes.
+     */
+    private _updatePageLinks;
+    getCurrentPage(): number;
+    /**
+     * Checks that the instance.currentPage property is within bounds for the current page range.
+     * If not, return a correct value for currentPage, or the current value if OK.
+     */
+    private outOfBoundCorrection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "co-pagination", never, { "id": { "alias": "id"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "directionLinks": { "alias": "directionLinks"; "required": false; }; "previousLabel": { "alias": "previousLabel"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; }, { "pageChange": "pageChange"; }, never, ["*"], false, never>;
+}
+
+declare class PaginatePipe implements PipeTransform {
+    private state;
+    transform(collection: any[], args: any): any;
+    private _createInstance;
+    private _checkConfig;
+    /**
+     * To avoid returning a brand new array each time the pipe is run, we store the state of the sliced
+     * array for a given id. This means that the next time the pipe is run on this collection & id, we just
+     * need to check that the collection, start and end points are all identical, and if so, return the
+     * last sliced array.
+     */
+    private _saveState;
+    private _stateIsIdentical;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PaginatePipe, "paginate", false>;
+}
+
+interface IPage {
+    label: string;
+    value: any;
+}
+declare class PaginationBarComponent implements OnInit, OnChanges {
+    directionLinks: boolean;
+    previousLabel: string;
+    nextLabel: string;
+    currentPage: number;
+    itemsPerPage: number;
+    set totalItems(value: number);
+    get totalItems(): number;
+    paginationRange: number;
+    autoHide: boolean;
+    previousClick: EventEmitter<void>;
+    nextClick: EventEmitter<void>;
+    pageClick: EventEmitter<any>;
+    showClass(): boolean;
+    private _totalItems;
+    pages: IPage[];
+    totalPages: number;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    isOnFirstPage(): boolean;
+    isOnLastPage(): boolean;
+    onPreviousClick(): void;
+    onNextClick(): void;
+    onPageClick(value: any): void;
+    shouldBeHidden(): boolean;
+    private _createPageArray;
+    private _calculatePageNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationBarComponent, "co-pagination-bar", never, { "directionLinks": { "alias": "directionLinks"; "required": false; }; "previousLabel": { "alias": "previousLabel"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "paginationRange": { "alias": "paginationRange"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; }, { "previousClick": "previousClick"; "nextClick": "nextClick"; "pageClick": "pageClick"; }, never, never, false, never>;
+}
+
+declare class PaginationBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginationBarModule, [typeof PaginationBarComponent], [typeof i2.CommonModule], [typeof PaginationBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PaginationBarModule>;
+}
+
+declare class PaginationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginationModule, [typeof PaginationComponent, typeof PaginatePipe], [typeof i2.CommonModule, typeof PaginationBarModule], [typeof PaginationComponent, typeof PaginatePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PaginationModule>;
+}
+
+declare class SimpleGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SimpleGridModule, [typeof SimpleGridComponent, typeof SimpleGridCellComponent, typeof SimpleGridColumnDirective], [typeof i2.CommonModule, typeof i4.DragDropModule, typeof GridToolbarModule, typeof InputTextModule, typeof FormModule, typeof ObserveVisibilityModule, typeof PaginationModule, typeof PaginationBarModule, typeof ClickoutsideModule, typeof ButtonModule, typeof CoreComponentsTranslationModule, typeof IconModule], [typeof SimpleGridComponent, typeof SimpleGridCellComponent, typeof SimpleGridColumnDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SimpleGridModule>;
+}
+
+declare enum ContentViewMode {
+    List = 0,
+    Grid = 1,
+    GridExpanded = 2,
+    MasterDetail = 3,
+    Timeline = 4,
+    Tiles = 5
+}
+
+declare class ViewModeButtonsComponent implements OnInit {
+    iconCacheService: IconCacheService;
+    readonly icons: typeof CoreComponentsIcon;
+    readonly viewModes: typeof ContentViewMode;
+    showViewModes: ContentViewMode[];
+    viewModeChange: EventEmitter<ContentViewMode>;
+    set activeViewMode(value: ContentViewMode);
+    get activeViewMode(): ContentViewMode;
+    showClass(): boolean;
+    private _activeViewMode;
+    ngOnInit(): void;
+    constructor(iconCacheService: IconCacheService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModeButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewModeButtonsComponent, "co-view-mode-buttons", never, { "showViewModes": { "alias": "showViewModes"; "required": false; }; "activeViewMode": { "alias": "activeViewMode"; "required": false; }; }, { "viewModeChange": "viewModeChange"; }, never, never, false, never>;
+}
+
+declare class ViewModeButtonsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModeButtonsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ViewModeButtonsModule, [typeof ViewModeButtonsComponent], [typeof i2.CommonModule, typeof ButtonModule], [typeof ViewModeButtonsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ViewModeButtonsModule>;
+}
+
+declare class ListOfValuesComponent extends BaseInputComponent<any> implements OnInit {
+    formComponent: FormComponent;
+    iconCacheService: IconCacheService;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    readonly icons: typeof CoreComponentsIcon;
+    set model(value: any);
+    get model(): any;
+    parentForOverlay: ElementRef;
+    multiselect: boolean;
+    showToggleAll: boolean;
+    largeCollection: boolean;
+    displayField: string;
+    optionIcon: string;
+    set collection(value: any[]);
+    get collection(): any[];
+    collectionLoadFn: Function;
+    collectionLoadFnProp: string;
+    leftIconData: SafeHtml | undefined;
+    searchPlaceholder: string;
+    searchDisabled: boolean;
+    showChips: boolean;
+    showClass(): boolean;
+    isSelectOpen: boolean;
+    state: string;
+    filterText: string;
+    selectedModel: string;
+    selectedModels: string[];
+    filteredCollection: any[];
+    isLoading: boolean;
+    private _collection;
+    private debounceTimeout;
+    private _lovPopupComponentRef;
+    constructor(formComponent: FormComponent, iconCacheService: IconCacheService, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+    ngOnInit(): void;
+    handleInputModelChange(model: string): void;
+    onModelChange(model: string): void;
+    applyFilter(text: string): Promise<[]>;
+    handleInputKeyDown(event: KeyboardEvent): boolean;
+    clearModel(event: MouseEvent): void;
+    toggleSelect(): void;
+    openPopup(): void;
+    removeOptionFromModel(chip: any): void;
+    optionChosen(option: any): void;
+    closePopup(): void;
+    checkModel(): void;
+    private _setSelectedModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOfValuesComponent, [{ optional: true; }, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListOfValuesComponent, "co-list-of-values", never, { "model": { "alias": "model"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "showToggleAll": { "alias": "showToggleAll"; "required": false; }; "largeCollection": { "alias": "largeCollection"; "required": false; }; "displayField": { "alias": "displayField"; "required": false; }; "optionIcon": { "alias": "optionIcon"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "collectionLoadFn": { "alias": "collectionLoadFn"; "required": false; }; "collectionLoadFnProp": { "alias": "collectionLoadFnProp"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "searchDisabled": { "alias": "searchDisabled"; "required": false; }; "showChips": { "alias": "showChips"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface lovViewModel {
+    checked: boolean;
+    model: any;
+}
+declare class ListOfValuesPopupComponent implements OnInit {
+    iconCacheService: IconCacheService;
+    private _elementRef;
+    set lovItems(children: any);
+    dropDownList: ElementRef;
+    set inputSearch(component: InputSearchComponent);
+    model: any;
+    multiselect: boolean;
+    showToggleAll: boolean;
+    displayField: string;
+    searchPlaceholder: string;
+    customCssClass: string;
+    searchDisabled: boolean;
+    parentForOverlay: ElementRef;
+    optionIcon: string;
+    set collection(value: any[]);
+    get collection(): any[];
+    modelChange: EventEmitter<any>;
+    closePopup: EventEmitter<Event>;
+    keyDown: EventEmitter<KeyboardEvent>;
+    showClass(): boolean;
+    animBase: boolean;
+    isOpen: boolean;
+    set searchTerm(value: string);
+    get searchTerm(): string;
+    viewModels: lovViewModel[];
+    viewModelsMain: lovViewModel[];
+    highLightModel: lovViewModel;
+    allSelected: boolean;
+    private _collection;
+    private _searchTerm;
+    private _lovItems;
+    private _searchInput;
+    constructor(iconCacheService: IconCacheService, _elementRef: ElementRef);
+    ngOnInit(): void;
+    handleInputKeyDown(event: KeyboardEvent): boolean;
+    filterViewModels(): void;
+    selectViewModel(viewModel: lovViewModel, closePopup?: boolean): void;
+    selectModelByViewModel(viewModel: lovViewModel, closePopup?: boolean): void;
+    selectOptionAndClosePopup(): void;
+    selectOptions(): void;
+    selectNextOption(back?: boolean): void;
+    selectAll(): void;
+    toggleAll(): void;
+    startCloseAnimation(): void;
+    isActive(vm: lovViewModel): boolean;
+    private _prepareViewModelsMain;
+    private _prepareViewModels;
+    private _scrollIntoView;
+    private _scrollActiveItemIntoView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOfValuesPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListOfValuesPopupComponent, "co-list-of-values-popup", never, { "model": { "alias": "model"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "showToggleAll": { "alias": "showToggleAll"; "required": false; }; "displayField": { "alias": "displayField"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "customCssClass": { "alias": "customCssClass"; "required": false; }; "searchDisabled": { "alias": "searchDisabled"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; "optionIcon": { "alias": "optionIcon"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; }, { "modelChange": "modelChange"; "closePopup": "closePopup"; "keyDown": "keyDown"; }, never, never, false, never>;
+}
+
+declare class ListOfValuesMultiselectPopupComponent extends BaseInputComponent<any> implements OnInit {
+    readonly icons: typeof CoreComponentsIcon;
+    showClass(): boolean;
+    chosenCollection: EventEmitter<any[]>;
+    closePopup: EventEmitter<any>;
+    returnChosenCollection: any[];
+    parentForOverlay: ElementRef;
+    displayField: string;
+    set collection(value: any[]);
+    get collection(): any[];
+    selectedCollection: any[];
+    selectedOptions: any[];
+    allOptionsSelected: boolean;
+    searchTerm: string;
+    private _collection;
+    get filteredCollection(): any;
+    ngOnInit(): void;
+    onOptionClick(option: any): void;
+    okClicked(): void;
+    onToggleSelectAll(): void;
+    searchCollection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOfValuesMultiselectPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListOfValuesMultiselectPopupComponent, "co-list-of-values-multiselect-popup", never, { "returnChosenCollection": { "alias": "returnChosenCollection"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; "displayField": { "alias": "displayField"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; }, { "chosenCollection": "chosenCollection"; "closePopup": "closePopup"; }, never, never, false, never>;
+}
+
+declare class ListOfValuesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOfValuesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ListOfValuesModule, [typeof ListOfValuesComponent, typeof ListOfValuesPopupComponent, typeof ListOfValuesMultiselectPopupComponent], [typeof i2.CommonModule, typeof i4$1.FormsModule, typeof InputTextModule, typeof InputCheckboxModule, typeof OverlayModule, typeof ClickoutsideModule, typeof IconModule, typeof InputSearchModule, typeof CoreComponentsTranslationModule], [typeof ListOfValuesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ListOfValuesModule>;
+}
+
+interface IconListItem {
+    id?: number;
+    icon: SafeHtml;
+    label: string;
+    children?: IconListItem[];
+}
+
+declare class ListOfIconsComponent implements OnInit {
+    icons: IconCacheService;
+    set collection(value: IconListItem[]);
+    get collection(): IconListItem[];
+    iconSize: number;
+    activeItem?: IconListItem;
+    itemSelected: EventEmitter<IconListItem>;
+    showClass(): boolean;
+    readonly Icon: any;
+    showMenu: boolean;
+    showSubCategories: boolean;
+    private _collection;
+    constructor(icons: IconCacheService);
+    ngOnInit(): void;
+    toggleMenu(): void;
+    selectItem(item: IconListItem): void;
+    handlePickingCategoryClicked(subCategory: IconListItem): void;
+    onClickOutside(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOfIconsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListOfIconsComponent, "co-list-of-icons", never, { "collection": { "alias": "collection"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "activeItem": { "alias": "activeItem"; "required": false; }; }, { "itemSelected": "itemSelected"; }, never, never, false, never>;
+}
+
+declare class ListOfIconsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOfIconsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ListOfIconsModule, [typeof ListOfIconsComponent], [typeof i2.CommonModule, typeof i4$1.FormsModule, typeof IconModule, typeof ClickoutsideModule, typeof CoreComponentsTranslationModule], [typeof ListOfIconsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ListOfIconsModule>;
+}
+
+declare class ResponsiveTextComponent {
+    text: string;
+    showClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResponsiveTextComponent, "co-responsive-text", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ResponsiveTextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveTextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ResponsiveTextModule, [typeof ResponsiveTextComponent], [typeof i2.CommonModule], [typeof ResponsiveTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ResponsiveTextModule>;
+}
+
+declare class ColorPickerComponent extends BaseInputComponent<any> {
+    showClass: boolean;
+    label: string;
+    handleModelChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPickerComponent, "co-color-picker", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ColorPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ColorPickerModule, [typeof ColorPickerComponent], [typeof i4$1.FormsModule, typeof i2.CommonModule], [typeof ColorPickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ColorPickerModule>;
+}
+
+declare enum AppPopupType {
+    Error = 0,
+    Warning = 1,
+    Information = 2,
+    Confirmation = 3
+}
+
+declare enum AppPopupButtonType {
+    Ok = 0,
+    Open = 1,
+    Save = 2,
+    Cancel = 3,
+    Yes = 4,
+    No = 5,
+    NoButton = 6
+}
+
+declare abstract class DialogBaseComponent {
+    onClose(eventType: AppPopupButtonType, output?: any, rememberChoice?: boolean): void;
+}
+
+declare class ConfirmationDialogComponent extends DialogBaseComponent {
+    iconCacheService: IconCacheService;
+    readonly icons: typeof CoreComponentsIcon;
+    readonly ptype: typeof AppPopupType;
+    title: string;
+    text: string;
+    details: string;
+    type: AppPopupType;
+    showRememberCheckbox: boolean;
+    showClass(): boolean;
+    rememberChoice: boolean;
+    constructor(iconCacheService: IconCacheService);
+    handleYesClick(event: MouseEvent): void;
+    handleNoClick(event: MouseEvent): void;
+    handleOkClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationDialogComponent, "co-confirmation-dialog", never, { "title": { "alias": "title"; "required": false; }; "text": { "alias": "text"; "required": false; }; "details": { "alias": "details"; "required": false; }; "type": { "alias": "type"; "required": false; }; "showRememberCheckbox": { "alias": "showRememberCheckbox"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class CoreDialogModule {
+    static forRoot(): ModuleWithProviders<CoreDialogModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDialogModule, [typeof ConfirmationDialogComponent], [typeof i2.CommonModule, typeof CoDialogModule, typeof CollapsibleModule, typeof CoreComponentsTranslationModule, typeof ButtonModule, typeof InputCheckboxModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDialogModule>;
+}
+
+interface DialogResponseInterface {
+    button: AppPopupButtonType;
+    output?: any;
+    rememberChoice?: boolean;
+}
+
+declare class CoreDynamicComponentService {
+    private _compFactoryResolver;
+    private appRef;
+    private injector;
+    private _componentRefs;
+    constructor(_compFactoryResolver: ComponentFactoryResolver, appRef: ApplicationRef, injector: Injector);
+    getComponentRefs(): ComponentRef<any>[];
+    createAndReturnComponentRef(componentClass: any, inputs?: any): Promise<any>;
+    createComponent(componentClass: any, inputs?: any, outputs?: any, providers?: StaticProvider[]): Promise<DialogResponseInterface>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDynamicComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreDynamicComponentService>;
+}
+
+declare class CoreDialogService {
+    private _compFactoryResolver;
+    private appRef;
+    private injector;
+    private dynamicComponentService;
+    private _componentRefs;
+    constructor(_compFactoryResolver: ComponentFactoryResolver, appRef: ApplicationRef, injector: Injector, dynamicComponentService: CoreDynamicComponentService);
+    showYesNo(title: string, text: string, showRememberChoice?: boolean): Promise<DialogResponseInterface>;
+    showError(message: string, details?: string): Promise<any>;
+    showInformation(message: string): Promise<any>;
+    showWarning(message: string): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreDialogService>;
+}
+
+declare class FilterItemViewmodel {
+    checked: boolean;
+    code: string | number;
+    description: string;
+    count?: number;
+    valueName?: string;
+    codeAsNumber?(): number;
+    constructor(code: string | number, description: string | number, checked: boolean, count?: number, valueName?: string);
+}
+
+declare class FilterItemComponent implements OnInit, ScreenConfigAdapterComponent, OnDestroy {
+    iconService: IconCacheService;
+    private _changeDetector;
+    icons: typeof CoreComponentsIcon;
+    modes: typeof FilterItemMode;
+    dateFieldValue?: Date;
+    set mode(value: FilterItemMode);
+    get mode(): FilterItemMode;
+    set collection(value: FilterItemViewmodel[]);
+    get collection(): FilterItemViewmodel[];
+    placeholder: string;
+    initialLimit: number;
+    expanded: boolean;
+    minSearchCharsToLoadCollection: number;
+    collectionLoadFn: Function;
+    customContent: boolean;
+    showAllResults: boolean;
+    filterButtonLabel: string;
+    searchPlaceholder: string;
+    showMoreLabel: string;
+    showLessLabel: string;
+    noResultsLabel: string;
+    sliderDefaultMin: number;
+    sliderDefaultMax: number;
+    fullRangeIsNull: boolean;
+    canFilterByCode: boolean;
+    firstDayOfWeek: string;
+    alwaysShowButton: boolean;
+    set model(newModel: any);
+    get model(): any;
+    set configObject(value: ObjectConfiguration);
+    get configObject(): ObjectConfiguration;
+    modelChange: EventEmitter<any>;
+    collectionChange: EventEmitter<FilterItemViewmodel[]>;
+    filterButtonClicked: EventEmitter<void>;
+    get hasClass(): boolean;
+    dateInput: any;
+    dateRangeInput: any;
+    filteredCollection: FilterItemViewmodel[];
+    limitTo: number;
+    filterText: string;
+    showButton: boolean;
+    isLoading: boolean;
+    sliderMin: number;
+    sliderMax: number;
+    dateRangeStart: Date;
+    dateRangeEnd: Date;
+    objectConfigName: string;
+    hidden: boolean;
+    required: boolean;
+    forceReadonly: boolean;
+    readonly: boolean;
+    maxLength: number;
+    defaultValue: ObjectConfigurationDefaultValueType;
+    decimals: number;
+    redErrorBackground: boolean;
+    checkBoxToTextModel: boolean;
+    private _configObject;
+    private _collection;
+    private _mode;
+    private _model;
+    private _defaultSet;
+    private _collectionSubject;
+    private _collectionSubscription;
+    private debounceTimeout;
+    constructor(iconService: IconCacheService, _changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setToInitialLimit(): void;
+    increaseLimit(): void;
+    moreToShow(): boolean;
+    lessToShow(): boolean;
+    handleModelChange(model: any): void;
+    valueSelected(): boolean;
+    onModelChange(text: string): void;
+    applyFilter(text: string): Promise<[]>;
+    onButtonClicked(): Promise<void>;
+    private uncheckForSingleSelect;
+    private readModelForMode;
+    private _createModelForFilterList;
+    private _createModelForStringCollectionList;
+    private _createModelForSingleSelectList;
+    private _createModelForSelectListWithNumberOutput;
+    private _createModelForSliderMode;
+    private _createModelForNullableSliderMode;
+    private _createModelForCheckboxToText;
+    private _createModelForCheckboxToTFText;
+    private _createModelForCheckboxToSimpleText;
+    private _createModelForCheckboxToTFSimpleText;
+    private _createModelForCheckboxToBinary;
+    private _createModelForDateField;
+    private _createModelForDateRange;
+    private _formatDateToString;
+    private _readModelForFilterList;
+    private _readModelForSingleSelectList;
+    private _readModelForStringCollectionList;
+    private _readModelForSelectListWithNumberOutput;
+    private _uncheckAll;
+    private _readModelForSliderMode;
+    private _readModelForCheckboxToText;
+    private _readModelForCheckboxToTFText;
+    private _readModelForCheckboxToBinary;
+    private _readModelForDateField;
+    private _readModelForDateRangeField;
+    private _applyDefaultForFilterList;
+    private _applyDefaultForStringCollectionList;
+    private _applyDefaultForSingleSelectList;
+    private _applyDefaultForSelectListWithNumberOutput;
+    private _applyDefaultForSlider;
+    private _applyDefaultForCheckboxToText;
+    private _applyDefaultForCheckboxToBinary;
+    private _applyDefaultForDateField;
+    private _applyDefaultForDateRangeField;
+    private _applyDefaultForTextField;
+    private _applyDefaultForCheckbox;
+    private _applyDefaultFilters;
+    private _sortCollectionByChecked;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterItemComponent, "co-filter-item", never, { "mode": { "alias": "mode"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "initialLimit": { "alias": "initialLimit"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "minSearchCharsToLoadCollection": { "alias": "minSearchCharsToLoadCollection"; "required": false; }; "collectionLoadFn": { "alias": "collectionLoadFn"; "required": false; }; "customContent": { "alias": "customContent"; "required": false; }; "showAllResults": { "alias": "showAllResults"; "required": false; }; "filterButtonLabel": { "alias": "filterButtonLabel"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "showMoreLabel": { "alias": "showMoreLabel"; "required": false; }; "showLessLabel": { "alias": "showLessLabel"; "required": false; }; "noResultsLabel": { "alias": "noResultsLabel"; "required": false; }; "sliderDefaultMin": { "alias": "sliderDefaultMin"; "required": false; }; "sliderDefaultMax": { "alias": "sliderDefaultMax"; "required": false; }; "fullRangeIsNull": { "alias": "fullRangeIsNull"; "required": false; }; "canFilterByCode": { "alias": "canFilterByCode"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "alwaysShowButton": { "alias": "alwaysShowButton"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, { "modelChange": "modelChange"; "collectionChange": "collectionChange"; "filterButtonClicked": "filterButtonClicked"; }, never, ["*"], false, never>;
+}
+
+declare class PrependPipe implements PipeTransform {
+    transform(value: string, prepend?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrependPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrependPipe, "prepend", false>;
+}
+
+declare class PrependPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrependPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PrependPipeModule, [typeof PrependPipe], never, [typeof PrependPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PrependPipeModule>;
+}
+
+declare class FilterItemModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterItemModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FilterItemModule, [typeof FilterItemComponent], [typeof i2.CommonModule, typeof CollapsibleModule, typeof InputTextModule, typeof InputCheckboxModule, typeof IconModule, typeof i7.ScrollingModule, typeof AppendPipeModule, typeof PrependPipeModule, typeof InputTextModule, typeof InputRadioButtonModule, typeof InputTextModule, typeof CoreComponentsTranslationModule, typeof InputDatePickerModule, typeof InputDateRangePickerModule], [typeof FilterItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FilterItemModule>;
+}
+
+declare class CheckmarkOverlayComponent {
+    private _renderer;
+    set content(children: any);
+    animateDivs: QueryList<ElementRef>;
+    set visible(value: boolean);
+    get visible(): boolean;
+    successful: boolean;
+    showClass(): boolean;
+    showOverlay: boolean;
+    showWrapper: boolean;
+    private _visible;
+    constructor(_renderer: Renderer2);
+    private _checkAnimation;
+    private _checkAnimationFinished;
+    private _handleAnimationIteration;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckmarkOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckmarkOverlayComponent, "co-checkmark-overlay", never, { "visible": { "alias": "visible"; "required": false; }; "successful": { "alias": "successful"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class CheckmarkOverlayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckmarkOverlayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckmarkOverlayModule, [typeof CheckmarkOverlayComponent], [typeof i2.CommonModule], [typeof CheckmarkOverlayComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CheckmarkOverlayModule>;
+}
+
+declare class FilterViewmodel {
+    filterItems: FilterItemViewmodel[];
+    constructor(collection: any[], fields: {
+        text: any;
+        value: any;
+    });
+}
+
+interface ScannerInput {
+    triggerCodeScanned(code?: string): void;
+}
+
+declare class ScannerService implements OnDestroy {
+    private _ngZone;
+    private _activeInput;
+    private barCodeScanner;
+    constructor(_ngZone: NgZone);
+    ngOnDestroy(): void;
+    registerInput(input: ScannerInput): void;
+    private _barCodeScanned;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScannerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScannerService>;
+}
+
+declare class InputScannerComponent implements ScannerInput, OnDestroy {
+    private _scannerService;
+    model: string;
+    placeholder: string;
+    centerLabel: boolean;
+    useLeftIcon: boolean;
+    useRightIcon: boolean;
+    leftIconData: SafeHtml | undefined;
+    rightIconData: SafeHtml | undefined;
+    customCssClass: string;
+    modelChange: EventEmitter<string>;
+    leftIconClick: EventEmitter<MouseEvent>;
+    rightIconClick: EventEmitter<MouseEvent>;
+    search: EventEmitter<string>;
+    isFocused: EventEmitter<boolean>;
+    barCodeScanned: EventEmitter<string>;
+    showClass(): boolean;
+    private _blockEnterKeydown;
+    private _keyDownTimeout;
+    constructor(_scannerService: ScannerService);
+    ngOnDestroy(): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    triggerCodeScanned(code?: string): void;
+    private _clearTimeout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputScannerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputScannerComponent, "co-input-scanner", never, { "model": { "alias": "model"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "centerLabel": { "alias": "centerLabel"; "required": false; }; "useLeftIcon": { "alias": "useLeftIcon"; "required": false; }; "useRightIcon": { "alias": "useRightIcon"; "required": false; }; "leftIconData": { "alias": "leftIconData"; "required": false; }; "rightIconData": { "alias": "rightIconData"; "required": false; }; "customCssClass": { "alias": "customCssClass"; "required": false; }; }, { "modelChange": "modelChange"; "leftIconClick": "leftIconClick"; "rightIconClick": "rightIconClick"; "search": "search"; "isFocused": "isFocused"; "barCodeScanned": "barCodeScanned"; }, never, never, false, never>;
+}
+
+declare class InputScannerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputScannerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputScannerModule, [typeof InputScannerComponent], [typeof i2.CommonModule, typeof InputSearchModule], [typeof InputScannerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputScannerModule>;
+}
+
+declare class LoaderComponent {
+    showClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "co-loader", never, {}, {}, never, never, false, never>;
+}
+
+declare class LoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LoaderModule, [typeof LoaderComponent], [typeof i2.CommonModule], [typeof LoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LoaderModule>;
+}
+
+declare class TileSelectComponent {
+    selected: boolean;
+    readonly: boolean;
+    showRadioButton: boolean;
+    selectedChange: EventEmitter<boolean>;
+    showClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TileSelectComponent, "co-tile-select", never, { "selected": { "alias": "selected"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showRadioButton": { "alias": "showRadioButton"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, ["*"], false, never>;
+}
+
+declare class TileSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TileSelectModule, [typeof TileSelectComponent], [typeof i2.CommonModule, typeof InputRadioButtonModule], [typeof TileSelectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TileSelectModule>;
+}
+
+declare class ScrollContainerComponent implements OnDestroy, AfterContentInit {
+    content: ElementRef;
+    vertical: boolean;
+    showClass: boolean;
+    gotoNextSlide(): void;
+    gotoPrevSlide(): void;
+    handleWindowResize(): void;
+    get currentIndex(): number;
+    set currentIndex(value: number);
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+    private _currentIndex;
+    private _scrollLeftOver;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    private _scrollCarouselToIndex;
+    private _checkScrollIcons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollContainerComponent, "co-scroll-container", never, { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class ScrollContainerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollContainerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ScrollContainerModule, [typeof ScrollContainerComponent], [typeof i2.CommonModule], [typeof ScrollContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ScrollContainerModule>;
+}
+
+declare class FilterPipe implements PipeTransform {
+    transform(items: any[], field: string, value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filter", false>;
+}
+
+declare class FilterPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FilterPipeModule, [typeof FilterPipe], never, [typeof FilterPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FilterPipeModule>;
+}
+
+/**
+ * A pipe for transforming strings or numbers to currency formatted strings for display as a price text, e.g. the number 1300.82 to "€ 1,300.82"
+ * or the string "9000" to "€ 9000,-"
+ */
+declare class CoCurrencyPipe implements PipeTransform {
+    private static readonly _CurrencySymbol;
+    private static readonly _WholeNumberedPriceSuffix;
+    transform(value: any, allowZero?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CoCurrencyPipe, "coCurrency", false>;
+}
+
+declare class CoCurrencyPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoCurrencyPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoCurrencyPipeModule, [typeof CoCurrencyPipe], never, [typeof CoCurrencyPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoCurrencyPipeModule>;
+}
+
+declare function equalValidator(valueGetterFn: () => any): ValidatorFn;
+
+declare function passwordValidator(userNameGetterFn: () => string): ValidatorFn;
+declare function getValidatePasswordErrorString(password: string, username: string): string;
+
+declare function emailValidator(control: AbstractControl): ValidationErrors | null;
+
+declare function requiredValidator(control: AbstractControl): ValidationErrors | null;
+
+declare function precisionScaleValidator(precision: number, scale: number): ValidatorFn;
+
+declare function maxStringLengthValidator(length: number): ValidatorFn;
+
+declare class AlignWithDirective implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private _ngZone;
+    private _elementRef;
+    set alignWith(alignWith: any | ElementRef);
+    enableAlign: boolean;
+    keepInView: boolean;
+    keepInViewHorizontal: boolean;
+    keepInViewVertical: boolean;
+    alignRight: boolean;
+    noWidthAlign: boolean;
+    alignTopOffsetPx: number;
+    alignLeftOffsetPx: number;
+    viewElement: ElementRef;
+    fixed: string;
+    left: number;
+    top: number;
+    width: number;
+    private _hostNativeEl;
+    private get _shouldDoAlign();
+    constructor(_ngZone: NgZone, _elementRef: ElementRef);
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    align(): void;
+    scroll: () => void;
+    resize: () => void;
+    handleKeyUp: () => void;
+    private _alignWithZone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlignWithDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlignWithDirective, "[alignWith]", never, { "alignWith": { "alias": "alignWith"; "required": false; }; "enableAlign": { "alias": "enableAlign"; "required": false; }; "keepInView": { "alias": "keepInView"; "required": false; }; "keepInViewHorizontal": { "alias": "keepInViewHorizontal"; "required": false; }; "keepInViewVertical": { "alias": "keepInViewVertical"; "required": false; }; "alignRight": { "alias": "alignRight"; "required": false; }; "noWidthAlign": { "alias": "noWidthAlign"; "required": false; }; "alignTopOffsetPx": { "alias": "alignTopOffsetPx"; "required": false; }; "alignLeftOffsetPx": { "alias": "alignLeftOffsetPx"; "required": false; }; "viewElement": { "alias": "viewElement"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AlignWithModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlignWithModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AlignWithModule, [typeof AlignWithDirective], never, [typeof AlignWithDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AlignWithModule>;
+}
+
+declare class TooltipDirective implements OnDestroy, OnInit {
+    private _compFactoryResolver;
+    private _appRef;
+    private _injector;
+    private _sanitizer;
+    set tooltip(str: string);
+    private _elementRef;
+    private _tooltipMessage;
+    private _componentRef;
+    constructor(elementRef: ElementRef, _compFactoryResolver: ComponentFactoryResolver, _appRef: ApplicationRef, _injector: Injector, _sanitizer: DomSanitizer);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    private _handleScroll;
+    private _handleMouseMove;
+    private _showTooltip;
+    private _removeTooltip;
+    private _createTooltipComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[tooltip]", never, { "tooltip": { "alias": "tooltip"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TooltipComponent implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _changeDetector;
+    private _renderer;
+    set hostElement(value: HTMLElement);
+    get hostElement(): HTMLElement;
+    toolTip: SafeHtml | string;
+    tooltipClosed: EventEmitter<void>;
+    showClass(): boolean;
+    top: number;
+    left: number;
+    bottom: boolean;
+    animate: boolean;
+    private _hostElement;
+    private _documentClickListener;
+    constructor(_elementRef: ElementRef, _changeDetector: ChangeDetectorRef, _renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _positionTooltip;
+    private closeTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "co-tooltip", never, { "hostElement": { "alias": "hostElement"; "required": false; }; "toolTip": { "alias": "toolTip"; "required": false; }; }, { "tooltipClosed": "tooltipClosed"; }, never, never, false, never>;
+}
+
+declare class TooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, [typeof TooltipComponent], [typeof i2.CommonModule], [typeof TooltipComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
+}
+
+declare class TooltipDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipDirectiveModule, [typeof TooltipDirective], [typeof TooltipModule], [typeof TooltipDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipDirectiveModule>;
+}
+
+declare abstract class BaseModuleScreenConfigService {
+    abstract screenModuleName: string;
+    readonly configSet: BehaviorSubject<ObjectConfiguration[]>;
+    get configObjects(): ObjectConfiguration[];
+    controlValidityByBoMap: {
+        bo: BusinessObject;
+        controlKey: string;
+        valid: boolean;
+    }[];
+    private _configObjects;
+    private _objectConfigsMap;
+    loadConfig(params?: string[], insertRights?: boolean): Promise<ObjectConfiguration[]>;
+    lazyLoadConfig(): Promise<void>;
+    isActiveFieldValidationObject(configObject: ObjectConfiguration): boolean;
+    isBoValid(bo: BusinessObject): boolean;
+    getObjectConfigurationFor(configName: string): ObjectConfiguration;
+    setObjectConfigurationFor(configName: string, configObject: ObjectConfiguration): void;
+    mayRead(configName: string): boolean;
+    isReadonly(configName: string): boolean;
+    mayWrite(configName: string): boolean;
+    immediatelyVisible(configName: string): boolean;
+    immediatelyHidden(configName: string): boolean;
+    noRights(configName: string): boolean;
+    isHidden(configName: string): boolean;
+    isRequired(configName: string): boolean;
+    getDefaultValue(configName: string): ObjectConfigurationDefaultValueType;
+    getDefaultStringValue(configName: string): string;
+    getDefaultNumberValue(configName: string): number;
+    getMaxLength(configName: string): number;
+    getDecimals(configName: string): number;
+    hasConfigObjects(): boolean;
+    isKind(configName: string, kind: ObjectConfigKind): boolean;
+    isDataNameHiddenByItselfOrAnyOfItsParentRubrics(dataName: string): boolean;
+    protected abstract loadConfigForModule(params: string[], insertRights?: boolean): Promise<ObjectConfiguration[]>;
+    private isDataNameHiddenByAnyOfItsParentRubrics;
+    private _getConfigNameByDataName;
+    private _getConfigObjectByDataName;
+    private _buildScreenConfigMap;
+    setScreenConfigurationObjectsReadOnly(value: boolean): void;
+    setScreenConfigurationObjectsRedErrorBackground(errorValidation: ValidationResult, setAllFalse?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseModuleScreenConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseModuleScreenConfigService>;
+}
+
+/**
+ * Base class for top-level services of CRUD-style iOne modules (the Relation, Article and Transaction modules).
+ * What sets these modules apart, is the concept of a relatively bulky, 'single businessobject' being manipulated throughout all the tabs.
+ *
+ * Many other (smaller?) iOne modules work with multiple LISTS of different business object types instead.
+ */
+declare abstract class BaseModuleService implements OnDestroy {
+    protected screenConfigService: BaseModuleScreenConfigService;
+    readonly readonlyChange: Subject<boolean>;
+    readonly errorValidationReceived: Subject<ValidationResult>;
+    readonly successfulUpdate: Subject<void>;
+    get readonly(): boolean;
+    set readonly(readonly: boolean);
+    protected _readonly: boolean;
+    private _subscriptions;
+    constructor(screenConfigService: BaseModuleScreenConfigService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseModuleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseModuleService>;
+}
+
+declare class ScreenConfigurationDirective implements OnDestroy {
+    hostComponent: ScreenConfigAdapterComponent;
+    private _element;
+    private _configService;
+    private _renderer;
+    private _moduleService?;
+    set screenConfigurationObject(value: string);
+    get screenConfigurationObject(): string;
+    dataName: string;
+    screenConfigNativeElement: boolean;
+    noModuleService: boolean;
+    private _isHeader;
+    private _screenConfigurationObject;
+    private _isTurnedOff;
+    private _subs;
+    constructor(hostComponent: ScreenConfigAdapterComponent, _element: ElementRef, _configService: BaseModuleScreenConfigService, _renderer: Renderer2, _moduleService?: BaseModuleService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _updateHost;
+    /**
+     * Spawn error message tooltip onto our host comp, if any error was meant for the host (found by screenConfigurationObject);
+     * @param errorValidation A top-level full validation result, either from the backend or from some client-side validation error.
+     */
+    private _setErrorRedBackgroundAfterScrCfgValidate;
+    private _moduleInReadonlyMode;
+    private _mayUpdateHost;
+    private _setHostVisible;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenConfigurationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScreenConfigurationDirective, "[screenConfigurationObject]", never, { "screenConfigurationObject": { "alias": "screenConfigurationObject"; "required": false; }; "dataName": { "alias": "dataName"; "required": false; }; "screenConfigNativeElement": { "alias": "screenConfigNativeElement"; "required": false; }; "noModuleService": { "alias": "noModuleService"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ScreenConfigurationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenConfigurationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ScreenConfigurationModule, [typeof ScreenConfigurationDirective], [typeof i2.CommonModule], [typeof ScreenConfigurationDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ScreenConfigurationModule>;
+}
+
+declare class TemplateWrapperDirective implements OnDestroy, OnChanges {
+    protected viewContainer: ViewContainerRef;
+    templateWrapper: TemplateRef<any> | null;
+    templateWrapperContext: Object | null;
+    private _viewRef;
+    constructor(viewContainer: ViewContainerRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private _shouldRecreateView;
+    private _hasContextShapeChanged;
+    private _updateExistingContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateWrapperDirective, "[templateWrapper]", never, { "templateWrapper": { "alias": "templateWrapper"; "required": false; }; "templateWrapperContext": { "alias": "templateWrapperContext"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TemplateWrapperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateWrapperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TemplateWrapperModule, [typeof TemplateWrapperDirective], never, [typeof TemplateWrapperDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TemplateWrapperModule>;
+}
+
+declare const SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME: InjectionToken<ScreenConfigAdapterComponent>;
+
+declare class ColorSequenceService {
+    colors: Map<number, string>;
+    getRandomColor(id: number): string;
+    GetRandomColorWithSettings(h?: number[], s?: number[], l?: number[], a?: number[]): string;
+    GetRandomNumber(low: any, high: any): number;
+    GetHSLAColor(h: number, s: number, l: number, a: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSequenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColorSequenceService>;
+}
+
+declare class CoreComponentsTranslationService {
+    private _dictionaryService;
+    constructor(_dictionaryService: CoreDictionaryService);
+    setTranslation(translation: {}): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreComponentsTranslationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreComponentsTranslationService>;
+}
+
+declare class HourSchedulingTestObjectComponent {
+    showClass(): boolean;
+    title: string;
+    subTitle: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingTestObjectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HourSchedulingTestObjectComponent, "co-hour-scheduling-test-object", never, { "title": { "alias": "title"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface SchedulingObject$1 {
+    start: number;
+    end: number;
+    title?: string;
+    subTitle?: string;
+    selected?: boolean;
+    height?: number;
+    top?: number;
+    [key: string]: any;
+}
+
+declare class HourSchedulingComponent implements OnInit {
+    private cdRef;
+    private datePipe;
+    private zone;
+    hourLabels: string[];
+    scheduledObjects: {
+        [hour: string]: SchedulingObject$1[];
+    };
+    activeHour: string | null;
+    activeHalfHour: string | null;
+    private draggedObject;
+    schedule: any;
+    startTimeProp: string;
+    endTimeProp: string;
+    objectsProp: string;
+    childProp: string;
+    customTemplate: TemplateRef<any>;
+    customTemplateUsed: boolean;
+    idProp: string;
+    timeChangeEvent: EventEmitter<Object>;
+    newObjectPlanEvent: EventEmitter<{
+        currentHour: string;
+        data: string;
+    }>;
+    showClass: boolean;
+    constructor(cdRef: ChangeDetectorRef, datePipe: DatePipe, zone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    generateTimeBlocks(): void;
+    generateScheduledObjects(): void;
+    private _getObjectsForHourAndMinutes;
+    onDragStart(event: DragEvent, obj: any): void;
+    onCustomDragStart(event: DragEvent, obj: SchedulingObject$1): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent, hour: string): void;
+    convertToHourNotation(date: Date): string;
+    createDate(hours: number, minutes?: number): Date;
+    dateToUnixEpoch(date: Date): number;
+    formatHour(hour: number, minutes?: number): string;
+    addMinutes(hour: string): string;
+    onDocumentClick(event: Event): void;
+    onObjectDisplayClick(hour: string, half: 'firstHalf' | 'secondHalf'): void;
+    tryParseJSONObject(jsonString: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HourSchedulingComponent, "co-hour-scheduling", never, { "schedule": { "alias": "schedule"; "required": false; }; "startTimeProp": { "alias": "startTimeProp"; "required": false; }; "endTimeProp": { "alias": "endTimeProp"; "required": false; }; "objectsProp": { "alias": "objectsProp"; "required": false; }; "childProp": { "alias": "childProp"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; "customTemplateUsed": { "alias": "customTemplateUsed"; "required": false; }; "idProp": { "alias": "idProp"; "required": false; }; }, { "timeChangeEvent": "timeChangeEvent"; "newObjectPlanEvent": "newObjectPlanEvent"; }, never, never, false, never>;
+}
+
+declare class HourSchedulingComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HourSchedulingComponentModule, [typeof HourSchedulingComponent, typeof HourSchedulingTestObjectComponent], [typeof i2.CommonModule], [typeof HourSchedulingComponent, typeof HourSchedulingTestObjectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HourSchedulingComponentModule>;
+}
+
+interface SchedulingObject {
+    start: Date;
+    end: Date;
+    title?: string;
+    subTitle?: string;
+    height?: number;
+    top?: number;
+    id: number | string;
+    selected: boolean;
+    showTopResizer?: boolean;
+    showBottomResizer?: boolean;
+    [key: string]: any;
+}
+declare class HourSchedulingExpandableComponent implements OnInit {
+    private cdRef;
+    private eRef;
+    hourLabels: string[];
+    scheduledObjects: SchedulingObject[];
+    private resizing;
+    private resizeDirection;
+    private initialY;
+    private initialHeight;
+    private initialTop;
+    private currentResizingObject;
+    private currentDraggingObject;
+    private MIN_HEIGHT;
+    private _schedule;
+    set schedule(value: Object);
+    get schedule(): Object;
+    startTimeProp: string;
+    endTimeProp: string;
+    objectsProp: string;
+    childProp: string;
+    customTemplate: TemplateRef<any>;
+    idProp: string;
+    timeChangeEvent: EventEmitter<Object>;
+    newObjectPlanEvent: EventEmitter<{
+        currentHour: string;
+        data: string;
+    }>;
+    moveBetweenCalendarsEvent: EventEmitter<{
+        hour: string;
+        data: SchedulingObject;
+    }>;
+    showClass: boolean;
+    onResize(event: {
+        target: {
+            innerWidth: any;
+        };
+    }): void;
+    clickOut(event: {
+        target: any;
+    }): void;
+    constructor(cdRef: ChangeDetectorRef, eRef: ElementRef);
+    ngOnInit(): void;
+    private _findNextObject;
+    private _findPreviousObject;
+    renderObjects(): void;
+    onSelectBlock(obj: SchedulingObject): void;
+    onDragStartCustom(obj: SchedulingObject): void;
+    handleDrop(dragEvent: DragEvent, hour: string): void;
+    allowDrop(event: DragEvent, hour: string): boolean;
+    handleDragLeave(event: DragEvent): void;
+    onResizeStart(event: MouseEvent, obj: SchedulingObject, direction: 'top' | 'bottom'): void;
+    onResizing(event: MouseEvent): void;
+    onResizeEnd(event: MouseEvent): void;
+    timeDifference(date1: Date, date2: Date): number;
+    generateTimeBlocks(): void;
+    dateToUnixEpoch(date: Date): number;
+    addMinutes(date: Date, minutes: number): Date;
+    tryParseJSONObject(jsonString: string): any;
+    addHalfHour(hour: string): string;
+    convertTZ(date: any, tzString: any): Date;
+    convertDateToEuropean(date: Date): Date;
+    handleDeselectAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingExpandableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HourSchedulingExpandableComponent, "co-hour-scheduling-expandable", never, { "schedule": { "alias": "schedule"; "required": false; }; "startTimeProp": { "alias": "startTimeProp"; "required": false; }; "endTimeProp": { "alias": "endTimeProp"; "required": false; }; "objectsProp": { "alias": "objectsProp"; "required": false; }; "childProp": { "alias": "childProp"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; "idProp": { "alias": "idProp"; "required": false; }; }, { "timeChangeEvent": "timeChangeEvent"; "newObjectPlanEvent": "newObjectPlanEvent"; "moveBetweenCalendarsEvent": "moveBetweenCalendarsEvent"; }, never, ["*"], false, never>;
+}
+
+declare class HourSchedulingExpandableTemplateComponent {
+    private _objects;
+    layouts: {
+        leftPercent: number;
+        widthPercent: number;
+    }[];
+    objectTemplate: TemplateRef<any>;
+    set objects(objects: SchedulingObject$1[]);
+    get objects(): SchedulingObject$1[];
+    onDragStartCustom: Function;
+    onResizeStart: Function;
+    onSelectBlock: Function;
+    startTimeProp: string;
+    endTimeProp: string;
+    showClass(): boolean;
+    onExpandableDragStart(event: DragEvent, obj: Object, onDragStartCustom: Function): void;
+    calculateLeftAndWidthOfObjects(): {
+        leftPercent: number;
+        widthPercent: number;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingExpandableTemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HourSchedulingExpandableTemplateComponent, "co-hour-scheduling-expandable-template", never, { "objectTemplate": { "alias": "objectTemplate"; "required": false; }; "objects": { "alias": "objects"; "required": false; }; "onDragStartCustom": { "alias": "onDragStartCustom"; "required": false; }; "onResizeStart": { "alias": "onResizeStart"; "required": false; }; "onSelectBlock": { "alias": "onSelectBlock"; "required": false; }; "startTimeProp": { "alias": "startTimeProp"; "required": false; }; "endTimeProp": { "alias": "endTimeProp"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HourSchedulingExpandableTemplateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingExpandableTemplateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HourSchedulingExpandableTemplateModule, [typeof HourSchedulingExpandableTemplateComponent], [typeof i2.CommonModule], [typeof HourSchedulingExpandableTemplateComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HourSchedulingExpandableTemplateModule>;
+}
+
+declare class HourSchedulingExpandableComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HourSchedulingExpandableComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HourSchedulingExpandableComponentModule, [typeof HourSchedulingExpandableComponent], [typeof i2.CommonModule, typeof HourSchedulingComponentModule, typeof HourSchedulingExpandableTemplateModule], [typeof HourSchedulingExpandableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HourSchedulingExpandableComponentModule>;
+}
+
+declare class ElementPosition {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    constructor(top?: number, right?: number, bottom?: number, left?: number);
+}
+
+interface DataItem {
+    id?: number;
+    title?: string;
+    description?: string;
+    price?: number;
+    imageData?: string;
+    isActive?: boolean;
+}
+
+interface CoDragEvent {
+    element: any;
+    elementIndex: number;
+    source: any;
+}
+
+declare class DragDropContainer {
+    element: HTMLElement;
+    direction: CoOrientation;
+    constructor(element: HTMLElement, direction: CoOrientation);
+}
+
+interface CoDropEvent {
+    element: HTMLElement;
+    elementIndex: number;
+    container: DragDropContainer;
+    target: HTMLElement;
+    targetIndex: number;
+}
+
+declare class DragDropManagerService {
+    set renderer(value: Renderer2);
+    dragData: any;
+    drag: Subject<CoDragEvent>;
+    drop: Subject<CoDropEvent>;
+    private _renderer;
+    private _containers;
+    private _disabledContainers;
+    private _dropTargetElement;
+    private _dragHandles;
+    private _isdragging;
+    private _dragElement;
+    private _dragInContainer;
+    private _lastDropTarget;
+    /**
+     * Ghost image of the element being dragged
+     */
+    private _ghostDragImage;
+    private _clickCounter;
+    private set ghostLeft(value);
+    private set ghostTop(value);
+    private _ghostLeft;
+    private _ghostTop;
+    private _mouseDown;
+    private _currentMousePosition;
+    private _currentMouseOffset;
+    constructor();
+    addContainer(container: DragDropContainer): void;
+    addDragHandle(handle: any): void;
+    removeContainer(container: DragDropContainer): void;
+    removeDragHandle(handle: any): void;
+    enableContainer(container: DragDropContainer): void;
+    disableContainer(container: DragDropContainer): void;
+    private _setEvents;
+    private _setElementClass;
+    private _handleEventListener;
+    private _getContainerOfElement;
+    /**
+     * Checks if given element is a child of container(s)
+     * @param element
+     * @returns index of element
+     */
+    private _getElementOfContainer;
+    /**
+     * Returns next sibling of container that contains given element.
+     * @param element
+     * @returns null if there are no siblings left
+     */
+    private _getNextElementInContainer;
+    private _getDragHandleClicked;
+    private _getValidDragDropElement;
+    private _getNextSibling;
+    private _indexOf;
+    private _createGhostImage;
+    private _destroyGhostImage;
+    private _positionGhostImage;
+    private _getScroll;
+    private _getOffset;
+    private _determineDroptarget;
+    /**
+     * Briefly hides the ghost image to be able to determine which element is under mouse.
+     * @param x
+     * @param y
+     * @returns Top level element
+     */
+    private _getHoveredElement;
+    private _animateVisibility;
+    private _animateMove;
+    private _handleMouseDown;
+    private _handleMouseUp;
+    private _handleMouseMove;
+    private _startDrag;
+    private _drag;
+    private _endDrag;
+    private _resetDrag;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropManagerService>;
+}
+
+declare class DragDropContainerComponent implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _renderer;
+    private _dragDropService;
+    /**
+     * Model of list containing draggable items
+     */
+    sortableList: any[];
+    handleSort: boolean;
+    set enabled(value: boolean);
+    /**
+     * Class of the handle to drag operations
+     */
+    dragHandle: string;
+    sortingChange: EventEmitter<any[]>;
+    private _container;
+    private _enabled;
+    private _handleOrderSub;
+    private _initialized;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _dragDropService: DragDropManagerService);
+    ngAfterViewInit(): void;
+    /**
+     * Cleanup...
+     */
+    ngOnDestroy(): void;
+    handleEnabledChange(): void;
+    private _createDragDrop;
+    private _removeDragDrop;
+    private _handleOrder;
+    private _updateEnableDisableContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropContainerComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragDropContainerComponent, "co-drag-drop-container", never, { "sortableList": { "alias": "sortableList"; "required": false; }; "handleSort": { "alias": "handleSort"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "dragHandle": { "alias": "dragHandle"; "required": false; }; }, { "sortingChange": "sortingChange"; }, never, never, false, never>;
+}
+
+declare class DraggableDirective {
+    private _elementRef;
+    private _renderer;
+    private _dragService;
+    /**
+     * id/index of the draggable element
+     * null value means that draggable is disabled
+     */
+    set draggable(value: any);
+    set draggableObject(value: any);
+    horizontalDrag: boolean;
+    verticalDrag: boolean;
+    onDrag: EventEmitter<any>;
+    onDragEnd: EventEmitter<any>;
+    get getIdDragging(): boolean;
+    id: any;
+    object: any;
+    dragging: boolean;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _dragService: DragDropManagerService);
+    dragStart(event: any): void;
+    dragEnd(event: any): void;
+    setElementDraggable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective, "[co-draggable]", never, { "draggable": { "alias": "coDraggable"; "required": false; }; "draggableObject": { "alias": "coDraggableObject"; "required": false; }; "horizontalDrag": { "alias": "horizontalDrag"; "required": false; }; "verticalDrag": { "alias": "verticalDrag"; "required": false; }; }, { "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; }, never, never, false, never>;
+}
+
+declare class DragDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragDropModule, [typeof DragDropContainerComponent, typeof DraggableDirective], [typeof i2.CommonModule], [typeof DragDropContainerComponent, typeof DraggableDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragDropModule>;
+}
+
+interface DragDropContainerElement {
+    container: DragDropContainer;
+    element: HTMLElement;
+    elementIdx: number;
+}
+
+export { AlignWithDirective, AlignWithModule, AppendPipe, AppendPipeModule, ArticleTileComponent, ArticleTileModule, BaseInputComponent, BaseInputDatePickerDirective, BaseModuleScreenConfigService, BaseModuleService, ButtonComponent, ButtonModule, CalendarComponent, CalendarModule, CalendarTemplateComponent, CardComponent, CardModule, Carousel3dComponent, Carousel3dModule, CarouselComponent, CarouselHammerConfig, CarouselModule, CheckmarkOverlayComponent, CheckmarkOverlayModule, ClickOutsideDirective, ClickoutsideModule, CoCurrencyPipe, CoCurrencyPipeModule, CoDialogComponent, CoDialogModule, CoDialogWizardComponent, CoDialogWizardModule, CoDirection, CoOrientation, CollapsibleComponent, CollapsibleModule, ColorPickerComponent, ColorPickerModule, ColorSequenceService, ColumnAlign, ContentViewMode, CoreComponentsIcon, CoreComponentsTranslationModule, CoreComponentsTranslationService, CoreDialogModule, CoreDialogService, CoreLocalizePipe, DoubleCalendarComponent, DoubleCalendarModule, DragDropContainer, DragDropContainerComponent, DragDropManagerService, DragDropModule, DraggableDirective, ElementPosition, FilterItemComponent, FilterItemMode, FilterItemModule, FilterItemViewmodel, FilterPipe, FilterPipeModule, FilterViewmodel, FormComponent, FormInputUserModelChangeListenerService, FormMasterService, FormModule, GridToolbarButtonComponent, GridToolbarButtonModule, GridToolbarComponent, GridToolbarModule, HourSchedulingComponent, HourSchedulingComponentModule, HourSchedulingExpandableComponent, HourSchedulingExpandableComponentModule, HourSchedulingExpandableTemplateComponent, HourSchedulingExpandableTemplateModule, HourSchedulingTestObjectComponent, IconCacheService, IconCollapseHandleComponent, IconCollapseHandleModule, IconComponent, IconModule, ImageComponent, ImageModule, InputCheckboxComponent, InputCheckboxModule, InputDatePickerComponent, InputDatePickerModule, InputDateRangePickerComponent, InputDateRangePickerModule, InputNumberPickerComponent, InputNumberPickerModule, InputRadioButtonComponent, InputRadioButtonModule, InputScannerComponent, InputScannerModule, InputSearchComponent, InputSearchModule, InputTextComponent, InputTextModule, InputTextareaComponent, InputTextareaModule, InputTimeComponent, InputTimeModule, LevelIndicatorComponent, LevelIndicatorModule, ListOfIconsComponent, ListOfIconsModule, ListOfValuesComponent, ListOfValuesModule, ListOfValuesPopupComponent, LoaderComponent, LoaderModule, NgZoneWrapperService, ObserveVisibilityDirective, ObserveVisibilityModule, OrientationOfDirection, OverlayDirective, OverlayModule, OverlayParentDirective, OverlayService, PaginatePipe, PaginationBarComponent, PaginationBarModule, PaginationComponent, PaginationModule, PopupButtonsComponent, PopupMessageDisplayComponent, PopupModule, PopupWindowShellComponent, PrependPipe, PrependPipeModule, PriceDisplayPipe, PriceDisplayPipeModule, PromptService, ResponsiveTextComponent, ResponsiveTextModule, SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME, ScreenConfigurationDirective, ScreenConfigurationModule, ScrollContainerComponent, ScrollContainerModule, SimpleGridCellComponent, SimpleGridColumnDirective, SimpleGridComponent, SimpleGridModule, TemplateWrapperDirective, TemplateWrapperModule, TextInputPopupComponent, TileComponent, TileModule, TileSelectComponent, TileSelectModule, TooltipDirective, TooltipDirectiveModule, ViewModeButtonsComponent, ViewModeButtonsModule, emailValidator, equalValidator, getValidatePasswordErrorString, maxStringLengthValidator, passwordValidator, precisionScaleValidator, requiredValidator, showHideDialog };
+export type { CoDragEvent, CoDropEvent, DataItem, DialogResponseInterface, DragDropContainerElement, IPage, IconListItem, SchedulingObject$1 as SchedulingObject, ScreenConfigAdapterComponent, lovViewModel };