@indigina/ui-kit 1.1.204 → 1.1.205

package/index.d.ts

@@ -1,5 +1,4340 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@indigina/ui-kit" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InputSignal, EventEmitter, Predicate, ElementRef, OnInit, TemplateRef, WritableSignal, ChangeDetectorRef, Signal, OnChanges, OnDestroy, Renderer2, OutputEmitterRef, ModuleWithProviders, RendererFactory2, ViewContainerRef, ModelSignal, SimpleChanges, AfterContentInit, QueryList, AfterViewInit, InjectionToken, DestroyRef } from '@angular/core';
+import * as i2 from '@progress/kendo-angular-buttons';
+import * as i2$1 from '@angular/common';
+import { TitleCasePipe, DecimalPipe, DatePipe } from '@angular/common';
+import * as i3 from '@progress/kendo-angular-label';
+import { TooltipDirective } from '@progress/kendo-angular-tooltip';
+import * as i5 from '@angular/forms';
+import { ControlValueAccessor, AbstractControl, UntypedFormGroup, UntypedFormBuilder } from '@angular/forms';
+import * as i3$1 from '@progress/kendo-angular-inputs';
+import { TextBoxComponent } from '@progress/kendo-angular-inputs';
+import * as i4 from '@progress/kendo-angular-dropdowns';
+import { PopupSettings, DropDownListComponent, ItemDisabledFn, MultiSelectComponent } from '@progress/kendo-angular-dropdowns';
+import * as i3$2 from '@progress/kendo-angular-dateinputs';
+import { DateTimePickerComponent, DateRangePopupComponent, DatePickerComponent } from '@progress/kendo-angular-dateinputs';
+import { ToastrModule, ToastrService, ActiveToast } from 'ngx-toastr';
+import * as i3$3 from '@angular/router';
+import { ActivatedRoute, Router } from '@angular/router';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { DialogRef, DialogService, DialogSettings } from '@progress/kendo-angular-dialog';
+export { DialogAction, DialogCloseResult, DialogContentBase, DialogRef, DialogResult } from '@progress/kendo-angular-dialog';
+import * as i3$4 from '@progress/kendo-angular-indicators';
+import * as i3$5 from '@progress/kendo-angular-upload';
+import { FileInfo } from '@progress/kendo-angular-upload';
+import * as i8 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import { PopupService, PopupSettings as PopupSettings$1 } from '@progress/kendo-angular-popup';
+import * as i4$1 from '@progress/kendo-angular-layout';
+import { SelectEvent } from '@progress/kendo-angular-layout';
+import * as i4$2 from '@progress/kendo-angular-grid';
+import { PageChangeEvent, DetailExpandEvent, DetailCollapseEvent, CellClickEvent, ExcelExportEvent, GridComponent, RowClassArgs, PagerSettings } from '@progress/kendo-angular-grid';
+import { SortDescriptor, CompositeFilterDescriptor, FilterDescriptor } from '@progress/kendo-data-query';
+import { PDFOptions, PaperSize } from '@progress/kendo-drawing/dist/npm/pdf';
+import { Store, StateContext, StateToken } from '@ngxs/store';
+import { DataMoveEvent } from '@progress/kendo-angular-sortable';
+import { HttpClient } from '@angular/common/http';
+import { SchedulerEvent, EventClickEvent, SlotClickEvent, SchedulerComponent } from '@progress/kendo-angular-scheduler';
+
+declare enum KitSvgIcon {
+    LOGO = "logo",
+    CHEVRON_DOWN = "chevron-down",
+    CHEVRON_UP = "chevron-up",
+    CHEVRON_RIGHT = "chevron-right",
+    CHEVRON_LEFT = "chevron-left",
+    PLUS = "plus",
+    INFO = "info",
+    CALENDAR = "calendar",
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success",
+    EYE = "eye",
+    SEARCH = "search",
+    EDIT = "edit",
+    LOCATION = "location",
+    CROSS = "cross",
+    CHECK = "check",
+    CHECK_CIRCLE = "check-circle",
+    DISKETTE = "diskette",
+    CLIPBOARD = "clipboard",
+    LAYERS = "layers",
+    KNAUF = "knauf-logo",
+    HOME = "home",
+    DOUBLE_CIRCLE = "double-circle",
+    PENCIL = "pencil",
+    ORDER = "order",
+    RESET = "reset",
+    CIRCLE_CROSS = "circle-cross",
+    TRUCK = "truck",
+    DELIVERED = "delivered",
+    FTL = "ftl",
+    LTL = "ltl",
+    ORG = "org",
+    ARCHIVE = "archive",
+    LOGOUT = "logout",
+    CONTAINER = "container",
+    CARRIER = "carrier",
+    EXPORT = "export",
+    GEAR = "gear",
+    STOCK = "stock",
+    STATUS = "status",
+    CLOSE_SIGN = "close-sign",
+    CLOSE_SIGN_RED = "close-sign-red",
+    OPEN_SIGN_GREEN = "open-sign-green",
+    ARROW_LEFT = "arrow-left",
+    WARNING_YELLOW = "warning-yellow",
+    CIRCLE_MINUS = "circle-minus",
+    CIRCLE_PLUS = "circle-plus",
+    THREE_CIRCLE_ARROW_LEFT = "three-circle-arrow-left",
+    THREE_CIRCLE_ARROW_RIGHT = "three-circle-arrow-right",
+    SEND = "send",
+    CALENDAR_CHECK = "calendar-check",
+    CLIPBOARD_THIN = "clipboard-thin",
+    WALLET = "wallet",
+    CIRCLE_PULSE = "circle-pulse",
+    CIRCLE_CROSS_THIN = "circle-cross-thin",
+    TRASH = "trash",
+    WRENCH = "wrench",
+    TIME = "time",
+    WARNING_DEFAULT = "warning-default",
+    ROTATE_LEFT = "rotate-left",
+    DOWNLOAD = "download",
+    FILE_TEXT = "file-text",
+    ARROW_UP_RIGHT_FROM_SQUARE = "arrow-up-right-from-square",
+    CIRCLE_EXCLAMATION = "circle-exclamation",
+    TRIANGLE_EXCLAMATION = "triangle-exclamation",
+    SHIP = "ship",
+    CLOCK = "clock",
+    FACTORY = "factory",
+    COPY = "copy",
+    GEAR_1 = "gear-1",
+    HOUSE = "house",
+    CHART = "chart",
+    CLIP = "clip",
+    MAIL = "mail",
+    MENU = "menu",
+    MESSAGE = "message",
+    RELOAD = "reload",
+    WINDOW_RESTORE = "window-restore",
+    BACK_ARROW = "back-arrow",
+    USER = "user",
+    CARET_DOWN = "caret-down",
+    CARET_UP = "caret-up",
+    INFO_CIRCLE = "info-circle",
+    CHECK_CIRCLE_FILLED = "check-circle-filled",
+    WARNING_CIRCLE = "warning-circle",
+    WARNING_CIRCLE_FILLED = "warning-circle-filled",
+    CLOSE_CIRCLE_FILLED = "close-circle-filled",
+    QUESTION_CIRCLE = "question-circle",
+    STAR = "star",
+    SORT_ASCENDING = "sort-ascending",
+    SORT_DESCENDING = "sort-descending",
+    PAYMENTS = "payments",
+    SUPPLY_CHAIN = "supply-chain",
+    ANALYTICS = "analytics",
+    CONTROL_PANEL = "control-panel",
+    SEKO = "seko",
+    SEKO_360 = "seko-360",
+    FOUR_SQUARE = "four-square",
+    LOGISTICS = "logistics",
+    PRINTING = "printing",
+    SALES_CHANNELS = "sales-channels",
+    DESIGN = "design",
+    SHIPMENTS_TO_APPROVE = "shipments-to-approve",
+    SHIPMENTS_IN_TRANSIT = "shipments-in-transit",
+    CONTAINERS_TO_DELIVER = "containers-to-deliver",
+    SHIPMENTS_DRAFT = "shipments-draft",
+    SHIPMENTS_CANCELLATION_REQUESTS = "shipments-cancellation-requests",
+    SHIPMENTS_FOR_RE_AUTH = "shipments-for-re-auth",
+    SHIPMENTS_READY_TO_SHIP = "shipments-ready-to-ship",
+    BOOKINGS_DRAFT = "bookings-draft",
+    SHIPMENTS_PENDING_INSTRUCTIONS = "shipments-pending-instructions",
+    SHIPMENTS_PENDING_DOCUMENTS = "shipments-pending-documents",
+    DELIVERIES_TO_BOOK = "deliveries-to-book",
+    DELIVERIES_REQUIRE_CONFIRMATION = "deliveries-require-confirmation",
+    DELIVERIES_TO_RESCHEDULE = "deliveries-to-reschedule",
+    DELIVERIES_REQUIRE_AMENDMENTS = "deliveries-require-amendments",
+    DELIVERIES_REQUIRE_CANCELLATION = "deliveries-require-cancellation",
+    DELIVERIES_REQUIRE_POD_CUSTOMS = "deliveries-require-pod-customs",
+    WMS = "wms",
+    DCM = "dcm",
+    IHUB = "ihub",
+    TMS = "tms",
+    NSS = "nss",
+    DMS = "dms",
+    PMS = "pms",
+    EXCEL_FILE = "excel-file",
+    WORD_FILE = "word-file",
+    PDF_FILE = "pdf-file",
+    IMAGE_FILE = "image-file",
+    XML_FILE = "xml-file",
+    CSV_FILE = "csv-file",
+    EMPTY = "empty",
+    PRODUCT = "product",
+    NOTIFICATION = "notification",
+    COLUMNS = "columns",
+    DETAILS = "details",
+    FILTER = "filter",
+    NOTIFICATION_SUCCESS = "notification-success",
+    NOTIFICATION_WARNING = "notification-warning",
+    EYE_OPEN = "eye-open",
+    EYE_CLOSE = "eye-close",
+    GLOBAL = "global",
+    TO_APPROVE = "to-approve",
+    CHECK_STICKER = "check-sticker",
+    AIR = "air",
+    TABLE_VIEW = "table-view",
+    LIST_VIEW = "list-view",
+    KANBAN_VIEW = "kanban-view",
+    VIEWS = "views"
+}
+declare enum KitSvgIconType {
+    FILL = "fill",
+    STROKE = "stroke"
+}
+
+declare enum KitButtonType {
+    PRIMARY = "primary",
+    GHOST = "ghost",
+    TEXT = "text",
+    LINK = "link",
+    DASHED = "dashed"
+}
+declare enum KitButtonKind {
+    LARGE = "large",
+    MEDIUM = "medium",
+    SMALL = "small"
+}
+declare enum KitButtonIconPosition {
+    LEADING = "leading",
+    TRAILING = "trailing"
+}
+declare enum KitButtonState {
+    DEFAULT = "default",
+    SUCCESS = "success",
+    WARNING = "warning"
+}
+
+declare class KitButtonComponent {
+    /**
+     * States whether the button will be disabled or not from appearance point of view
+     */
+    disabled: boolean;
+    /**
+     * Defines a value that is going to be applied as a button label
+     */
+    label: string;
+    /**
+     * This value defines button type
+     */
+    type: KitButtonType;
+    /**
+     * An icon which will be used in a button with icon
+     */
+    icon?: KitSvgIcon;
+    /**
+     * Defines the icon type of the button
+     */
+    iconType?: KitSvgIconType;
+    /**
+     * Defines a kind of button (regular, mini, etc.)
+     */
+    kind: KitButtonKind;
+    readonly state: InputSignal<KitButtonState>;
+    /**
+     * A place where the icon will be displayed
+     */
+    iconPosition: KitButtonIconPosition;
+    /**
+     * A CSS class which will be applied to the HTML button component
+     */
+    buttonClass: string;
+    /**
+     * Defines an active state of the button
+     */
+    active: boolean;
+    /**
+     * An action which is emitted as soon as user clicked the button
+     */
+    clicked: EventEmitter<MouseEvent>;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitButtonComponent, "kit-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; "kind": { "alias": "kind"; "required": false; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, { "clicked": "clicked"; }, never, never, false, never>;
+}
+
+declare class KitSvgIconComponent {
+    /**
+     * Defines an icon which to be shown
+     */
+    icon: string | null;
+    /**
+     * Defines a CSS class that will be applied to an icon
+     */
+    iconClass: string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSvgIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSvgIconComponent, "kit-svg-icon", never, { "icon": { "alias": "icon"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitSvgIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSvgIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitSvgIconModule, [typeof KitSvgIconComponent], never, [typeof KitSvgIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitSvgIconModule>;
+}
+
+declare class KitButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitButtonModule, [typeof KitButtonComponent], [typeof i2.ButtonModule, typeof i2$1.CommonModule, typeof KitSvgIconModule], [typeof KitButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitButtonModule>;
+}
+
+declare class KitSvgSpriteComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSvgSpriteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSvgSpriteComponent, "kit-svg-sprite", never, {}, {}, never, never, false, never>;
+}
+
+declare class KitSvgSpriteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSvgSpriteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitSvgSpriteModule, [typeof KitSvgSpriteComponent], never, [typeof KitSvgSpriteComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitSvgSpriteModule>;
+}
+
+declare class KitLoaderComponent {
+    /**
+     * An icon which will be used for loader
+     */
+    readonly SvgIconLogo: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitLoaderComponent, "kit-loader", never, {}, {}, never, never, false, never>;
+}
+
+declare class KitLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitLoaderModule, [typeof KitLoaderComponent], [typeof KitSvgIconModule], [typeof KitLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitLoaderModule>;
+}
+
+interface KitSwitchItem {
+    /**
+     * this is going to be used as an item value to identify what item has been selected
+     */
+    value: string;
+    /**
+     * in case of using item without icon this will be shown within an item
+     */
+    title?: string;
+    /**
+     * an icon name from KitSvgIcon list; so this will be shown instead of title in case of use
+     */
+    icon?: KitSvgIcon;
+    /**
+     * a function which is going to be used in order to decide whether an item needs to be disabled
+     */
+    disabled?: Predicate<KitSwitchItem>;
+}
+
+declare enum KitSwitchMode {
+    SINGLE = "single",
+    MULTI = "multiple"
+}
+interface KitSwitchItemSelection {
+    selected: boolean;
+    item: KitSwitchItem;
+    mode: KitSwitchMode;
+}
+declare enum KitSwitchState {
+    REGULAR = "regular",
+    DANGER = "danger"
+}
+declare class KitSwitchComponent {
+    /**
+     * items list which is going to be rendered as switch buttons
+     * each of them should have uniq value but not uniq title
+     */
+    items: KitSwitchItem[];
+    /**
+     * defines whether it will be possible to choose several options at time
+     */
+    mode: KitSwitchMode;
+    /**
+     * a label which will be shown above the switch group
+     */
+    label?: string;
+    /**
+     * defines whether the entire group will be disabled and will no have an ability to be changed
+     */
+    disabled?: boolean;
+    /**
+     * defines what values have to be selected
+     * in case of "single" mode it should be only one value
+     */
+    selection?: string[];
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a particular state for the component
+     */
+    state: KitSwitchState;
+    /**
+     * emits when an items has been selected
+     */
+    selected: EventEmitter<KitSwitchItemSelection>;
+    /**
+     * occurs when an item has been selected
+     *
+     * @param selected false if a previous value comes
+     * @param item an item which is selected currently or a previous one
+     */
+    onItemSelect(selected: boolean, item: KitSwitchItem): void;
+    /**
+     * returns true if "selection" input contains a value for an item
+     *
+     * @param item an item for which need to check whether it needs to be selected
+     */
+    isItemSelected(item: KitSwitchItem): boolean;
+    /**
+     * returns "true" in case the mode is set to "single"
+     *
+     * @private
+     */
+    private isSingleMode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSwitchComponent, "kit-switch", never, { "items": { "alias": "items"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "selected": "selected"; }, never, never, false, never>;
+}
+
+declare class KitInputMessageComponent {
+    /**
+     * An icon which will be used to the left of the info message
+     */
+    icon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    message: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitInputMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitInputMessageComponent, "kit-input-message", never, { "icon": { "alias": "icon"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitInputMessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitInputMessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitInputMessageModule, [typeof KitInputMessageComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule], [typeof KitInputMessageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitInputMessageModule>;
+}
+
+declare enum KitTooltipPosition {
+    TOP = "top",
+    BOTTOM = "bottom",
+    RIGHT = "right",
+    LEFT = "left"
+}
+
+declare class KitInputLabelComponent {
+    /**
+     * Defines the text content of the label
+     */
+    text?: string;
+    /**
+     * Associates the label with a component by a template reference
+     */
+    for?: ElementRef;
+    /**
+     * Defines the tooltip text
+     */
+    tooltip?: string;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitTooltipPosition: typeof KitTooltipPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitInputLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitInputLabelComponent, "kit-input-label", never, { "text": { "alias": "text"; "required": false; }; "for": { "alias": "for"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitTooltipDirective extends TooltipDirective implements OnInit {
+    readonly kitTooltipPosition: InputSignal<KitTooltipPosition>;
+    readonly kitTooltipFilter: InputSignal<string>;
+    readonly kitTooltipTemplateRef: InputSignal<TemplateRef<HTMLElement> | undefined>;
+    readonly kitTooltipVisible: InputSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    private getShowOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitTooltipDirective, "[kitTooltip]", never, { "kitTooltipPosition": { "alias": "kitTooltipPosition"; "required": false; "isSignal": true; }; "kitTooltipFilter": { "alias": "kitTooltipFilter"; "required": false; "isSignal": true; }; "kitTooltipTemplateRef": { "alias": "kitTooltipTemplateRef"; "required": false; "isSignal": true; }; "kitTooltipVisible": { "alias": "kitTooltipVisible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KitInputLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitInputLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitInputLabelModule, [typeof KitInputLabelComponent], [typeof i2$1.CommonModule, typeof i3.LabelModule, typeof KitSvgIconModule, typeof KitTooltipDirective], [typeof KitInputLabelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitInputLabelModule>;
+}
+
+declare class KitSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitSwitchModule, [typeof KitSwitchComponent], [typeof i2.ButtonGroupModule, typeof i2.ButtonModule, typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof KitInputMessageModule, typeof KitInputLabelModule], [typeof KitSwitchComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitSwitchModule>;
+}
+
+declare enum KitTextboxState {
+    DEFAULT = "default",
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success"
+}
+declare enum KitTextboxSize {
+    REGULAR = "regular",
+    SMALL = "small"
+}
+
+declare class KitTextboxComponent implements ControlValueAccessor {
+    /**
+     * Defines a value that is going to be applied as an input placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines a value that is going to be applied as an input label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as a default input value
+     */
+    defaultValue?: string;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a state whether the textbox will be disabled or not
+     */
+    disabled: boolean;
+    /**
+     * Defines the maximum length of the textbox value
+     */
+    maxlength?: number;
+    /**
+     * Defines the state of the textbox
+     */
+    state: KitTextboxState;
+    /**
+     * Defines the size of the textbox
+     */
+    size: KitTextboxSize;
+    /**
+     * Defines the icon which will be used with the input field
+     */
+    icon?: KitSvgIcon;
+    /**
+     * An action which is emitted when input field lost focus
+     */
+    blured: EventEmitter<void>;
+    /**
+     * An action which is emitted when input value changed
+     */
+    changed: EventEmitter<string>;
+    readonly textboxStateIcon: Record<KitTextboxState, KitSvgIcon>;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: string) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (_: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    /**
+     * Function that is called when input field lost focus
+     */
+    onInputBlur(): void;
+    /**
+     * Function that is called when input value changed
+     */
+    onInputChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTextboxComponent, "kit-textbox", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "state": { "alias": "state"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "blured": "blured"; "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitTextboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitTextboxModule, [typeof KitTextboxComponent], [typeof i2$1.CommonModule, typeof i3$1.TextBoxModule, typeof KitInputLabelModule, typeof KitInputMessageModule, typeof KitSvgIconModule], [typeof KitTextboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitTextboxModule>;
+}
+
+declare enum KitNumericTextboxState {
+    DEFAULT = "default",
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success"
+}
+declare enum KitNumericTextboxSize {
+    REGULAR = "regular",
+    SMALL = "small"
+}
+
+declare class KitNumericTextboxComponent implements ControlValueAccessor {
+    /**
+     * Defines a value that is going to be applied as an input placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines a value that is going to be applied as an input label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as a default input value
+     */
+    defaultValue?: number;
+    /**
+     * Specifies the number of decimals that the user can enter when the input is focused
+     */
+    decimals?: number;
+    /**
+     * Specifies the smallest value that is valid
+     */
+    min?: number;
+    /**
+     * Specifies the greatest value that is valid
+     */
+    max?: number;
+    /**
+     * Specifies the maximum number of characters the end user can type
+     */
+    maxlength?: number;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a state whether the textbox will be disabled or not
+     */
+    disabled: boolean;
+    /**
+     * Specifies the number format
+     */
+    format?: string;
+    /**
+     * Defines the state of the textbox
+     */
+    state: KitNumericTextboxState;
+    /**
+     * Defines the icon which will be used with the input field
+     */
+    icon?: KitSvgIcon;
+    readonly size: InputSignal<KitNumericTextboxSize>;
+    /**
+     * An action which is emitted when input field lost focus
+     */
+    blured: EventEmitter<void>;
+    /**
+     * An action which is emitted when input value changed
+     */
+    changed: EventEmitter<number>;
+    readonly numericTextboxStateIcon: Record<KitNumericTextboxState, KitSvgIcon>;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: number) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    writeValue(value: number): void;
+    registerOnChange(fn: (_: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    /**
+     * Function that is called when input field lost focus
+     */
+    onInputBlur(): void;
+    /**
+     * Function that is called when input value changed
+     */
+    onInputChange(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNumericTextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitNumericTextboxComponent, "kit-numeric-textbox", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "decimals": { "alias": "decimals"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "format": { "alias": "format"; "required": false; }; "state": { "alias": "state"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "blured": "blured"; "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitNumericTextboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNumericTextboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitNumericTextboxModule, [typeof KitNumericTextboxComponent], [typeof i2$1.CommonModule, typeof i3$1.NumericTextBoxModule, typeof KitInputMessageModule, typeof KitSvgIconModule, typeof KitInputLabelModule], [typeof KitNumericTextboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitNumericTextboxModule>;
+}
+
+declare enum KitDropdownSize {
+    DEFAULT = "default",
+    SMALL = "small"
+}
+
+interface KitDropdownItem<T, U = unknown> {
+    text: string;
+    value: T;
+    data?: U;
+    disabled?: Predicate<KitDropdownItem<T>>;
+}
+declare class KitDropdownComponent<T> implements ControlValueAccessor {
+    private changeDetectorRef;
+    /**
+     * an items list which is going to be rendered as dropdown items
+     */
+    items: KitDropdownItem<T>[];
+    /**
+     * an item which needs to be selected as a default value
+     */
+    selectedItem?: T;
+    /**
+     * an informative text that will be above the dropdown
+     */
+    label?: string;
+    /**
+     * defines whether the component will be in disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a state whether the component will be invalid
+     */
+    invalid?: boolean;
+    /**
+     * An item that is going to be presented as a default value.
+     * Using as a placeholder
+     */
+    defaultItem?: KitDropdownItem<T>;
+    /**
+     * Defines dropdown popup list height. By default, listHeight is 200px.
+     */
+    listHeight: number;
+    /**
+     * Whether the default item will be hidden. "true" by default
+     */
+    hideDefaultItem: boolean;
+    /**
+     * Defines the icon which going to be the icon for the dropdown toggle button
+     */
+    toggleIcon: KitSvgIcon;
+    popupSettings: PopupSettings;
+    isValuePrimitive: boolean;
+    readonly footerTemplate: InputSignal<TemplateRef<HTMLTemplateElement> | undefined>;
+    readonly noDataTemplate: InputSignal<TemplateRef<HTMLTemplateElement> | undefined>;
+    /**
+     * Defines the size of the dropdown
+     */
+    readonly size: InputSignal<KitDropdownSize>;
+    /**
+     * occurs once an item in the dropdown is selected
+     */
+    selected: EventEmitter<KitDropdownItem<T>>;
+    /**
+     * Defines template for a dropdown value
+     */
+    kitDropdownValueTemplate?: TemplateRef<HTMLTemplateElement>;
+    /**
+     * Defines template for a dropdown list item
+     */
+    kitDropdownItemTemplate?: TemplateRef<HTMLElement>;
+    dropdown: DropDownListComponent | null;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly isPopupExpanded: WritableSignal<boolean>;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    /**
+     * Build an object with appropriate options, based on hiding default item state
+     */
+    buildPopupSettings(): PopupSettings;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: T) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    onItemDisabled(): ItemDisabledFn;
+    /**
+     * Function that is called when dropdown list item selected
+     */
+    onItemSelect(item: KitDropdownItem<T>): void;
+    writeValue(value: T): void;
+    registerOnChange(fn: (_: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    reset(value: T): void;
+    onOpen(): void;
+    onClose(): void;
+    getCssClasses(): Record<string, boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDropdownComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDropdownComponent<any>, "kit-dropdown", never, { "items": { "alias": "items"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "defaultItem": { "alias": "defaultItem"; "required": false; }; "listHeight": { "alias": "listHeight"; "required": false; }; "hideDefaultItem": { "alias": "hideDefaultItem"; "required": false; }; "toggleIcon": { "alias": "toggleIcon"; "required": false; }; "popupSettings": { "alias": "popupSettings"; "required": false; }; "isValuePrimitive": { "alias": "isValuePrimitive"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; "isSignal": true; }; "noDataTemplate": { "alias": "noDataTemplate"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, ["kitDropdownValueTemplate", "kitDropdownItemTemplate"], never, false, never>;
+}
+
+declare class KitDropdownItemTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDropdownItemTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitDropdownItemTemplateDirective, "[kitDropdownItemTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitTruncateTextComponent {
+    readonly tooltip: Signal<TooltipDirective>;
+    readonly anchor: Signal<ElementRef<HTMLDivElement>>;
+    readonly content: Signal<ElementRef<HTMLSpanElement>>;
+    onMouseEnter(): void;
+    onMouseOver(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTruncateTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTruncateTextComponent, "kit-truncate-text", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class KitDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitDropdownModule, [typeof KitDropdownComponent], [typeof i4.DropDownListModule, typeof i2$1.CommonModule, typeof KitInputMessageModule, typeof i5.ReactiveFormsModule, typeof i5.FormsModule, typeof KitSvgIconModule, typeof KitInputLabelModule, typeof KitDropdownItemTemplateDirective, typeof KitTruncateTextComponent], [typeof KitDropdownComponent, typeof KitDropdownItemTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitDropdownModule>;
+}
+
+declare enum KitTextareaState {
+    DEFAULT = "default",
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success"
+}
+
+declare class KitTextareaComponent implements ControlValueAccessor, OnChanges {
+    /**
+     * Defines a value that is going to be applied as a textarea placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines a value that is going to be applied as a textarea label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as a default textarea value
+     */
+    defaultValue?: string;
+    /**
+     * Defines a value that will determine the maximum number of characters in the textarea field
+     */
+    maxlength?: number;
+    /**
+     * Defines a value that is going to be applied as a minimal number of visible text lines in
+     * the textarea field
+     */
+    minLines?: number;
+    /**
+     * Defines a value that is going to be applied as a maximal number of visible text lines in
+     * the textarea field
+     */
+    maxLines?: number;
+    /**
+     * Defines a state whether the textarea will be disabled or not
+     */
+    disabled: boolean;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a particular state for the component
+     */
+    state: KitTextareaState;
+    /**
+     * Defines the icon which will be used with the input field
+     */
+    icon?: KitSvgIcon;
+    /**
+     * Defines whether the textarea will be in the readonly mode
+     */
+    readonly: boolean;
+    tooltip?: string;
+    /**
+     * Defines a value that is going to be applied as a minimal textarea height
+     */
+    minHeight?: number;
+    /**
+     * Defines a value that is going to be applied as a maximal textarea height
+     */
+    maxHeight?: number;
+    /**
+     * An action which is emitted when textarea field received focus
+     */
+    focused: EventEmitter<void>;
+    /**
+     * An action which is emitted when textarea field lost focus
+     */
+    blured: EventEmitter<void>;
+    /**
+     * An action which is emitted when textarea value changed
+     */
+    changed: EventEmitter<string>;
+    readonly textareaStateIcon: Record<KitTextareaState, KitSvgIcon>;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    ngOnChanges(): void;
+    /**
+     * Function that should be called every time values of minLines and maxLines changes
+     */
+    calculateLineHeight(): void;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: string) => void;
+    /**
+     * Function that should be called when textarea lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (_: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    /**
+     * Function that is called when textarea field received focus
+     */
+    onTextareaFocus(): void;
+    /**
+     * Function that is called when textarea field lost focus
+     */
+    onTextareaBlur(): void;
+    /**
+     * Function that is called when textarea value changed
+     */
+    onTextareaChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTextareaComponent, "kit-textarea", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minLines": { "alias": "minLines"; "required": false; }; "maxLines": { "alias": "maxLines"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "state": { "alias": "state"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "focused": "focused"; "blured": "blured"; "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitTextareaAutoresizeDirective {
+    private elementRef;
+    constructor(elementRef: ElementRef);
+    onInput(): void;
+    ngOnInit(): void;
+    resize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextareaAutoresizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitTextareaAutoresizeDirective, "[autoresize]", never, {}, {}, never, never, false, never>;
+}
+
+declare class KitTextareaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextareaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitTextareaModule, [typeof KitTextareaComponent, typeof KitTextareaAutoresizeDirective], [typeof i2$1.CommonModule, typeof KitInputMessageModule, typeof KitSvgIconModule, typeof KitInputLabelModule, typeof KitTooltipDirective], [typeof KitTextareaComponent, typeof KitTextareaAutoresizeDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitTextareaModule>;
+}
+
+declare enum KitTextLabelState {
+    REGULAR = "regular",
+    DANGER = "danger"
+}
+declare class KitTextLabelComponent {
+    /**
+     * Defines a value that is going to be applied as a label top text
+     */
+    label: string;
+    /**
+     * Defines a value that is going to be applied as a label main text
+     */
+    value: string;
+    /**
+     * Defines whether the message will be displayed as HTML (including rendering HTML tags)
+     */
+    htmlMode: boolean;
+    /**
+     * Defines a value that is going to be applied as a label top text in case when no value passed
+     */
+    noValueMessage?: string;
+    /**
+     * Defines a value which going to be as a label info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a particular state for the component
+     */
+    state: KitTextLabelState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTextLabelComponent, "kit-text-label", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "htmlMode": { "alias": "htmlMode"; "required": false; }; "noValueMessage": { "alias": "noValueMessage"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitTextLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTextLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitTextLabelModule, [typeof KitTextLabelComponent], [typeof i2$1.CommonModule, typeof KitInputMessageModule, typeof KitInputLabelModule], [typeof KitTextLabelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitTextLabelModule>;
+}
+
+declare enum KitUnitsTextboxDropdownPosition {
+    LEFT = "left",
+    RIGHT = "right"
+}
+declare enum KitUnitsTextboxType {
+    TEXT = "text",
+    NUMBER = "number"
+}
+
+declare class KitUnitsTextboxComponent<T> {
+    /**
+     * Defines a value that is going to be applied as a textbox placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines a value that is going to be applied as a textbox label
+     */
+    label?: string;
+    /**
+     * Defines whether the textbox will be in disabled state
+     */
+    disabledTextBox?: boolean;
+    /**
+     * Defines whether the dropdown list will be in disabled state
+     */
+    disabledDropdown?: boolean;
+    /**
+     * An items list which is going to be rendered as dropdown items
+     */
+    dropdownItems: KitDropdownItem<T>[];
+    /**
+     * An item which needs to be selected as a default value of the dropdown list
+     */
+    selectedDropdownItem?: T;
+    /**
+     * Defines a value that is going to be applied as a default textbox value
+     */
+    textBoxValue: string | number;
+    /**
+     * Defines a value that is going to be applied as a textbox form control
+     */
+    textBoxFormControl: AbstractControl;
+    /**
+     * Defines a value that is going to be applied as a dropdown list form control
+     */
+    dropdownFormControl: AbstractControl;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a value which used to set position of the dropdown list
+     */
+    dropdownPosition: KitUnitsTextboxDropdownPosition;
+    /**
+     * Defines a value which used to set type ot he textbox field
+     */
+    textboxType: KitUnitsTextboxType;
+    /**
+     * Specifies the number of decimals that the user can enter when the numeric input is focused
+     */
+    decimals?: number;
+    /**
+     * Specifies the smallest numeric textbox value that is valid
+     */
+    min?: number;
+    /**
+     * Specifies the greatest numeric textbox value that is valid
+     */
+    max?: number;
+    /**
+     * Specifies the maximum number of characters the end user can type
+     */
+    maxlength?: number;
+    /**
+     * Specifies the number format of the numeric textbox
+     */
+    format?: string;
+    /**
+     * Defines a state whether the component will be invalid
+     */
+    invalid: boolean;
+    /**
+     * An action which is emitted when textbox field lost focus
+     */
+    blured: EventEmitter<void>;
+    /**
+     * Occurs once an item in the dropdown is selected
+     */
+    selected: EventEmitter<KitDropdownItem<T>>;
+    /**
+     * An action which is emitted when input value changed
+     */
+    changed: EventEmitter<string | number>;
+    /**
+     * Settings for popup that will be opened as dropdown options list
+     */
+    readonly dropdownPopupSettings: PopupSettings;
+    /**
+     * Defines textbox types
+     */
+    readonly KitUnitsTextboxType: typeof KitUnitsTextboxType;
+    /**
+     * Defines dropdown positioning types
+     */
+    readonly KitUnitsTextboxDropdownPosition: typeof KitUnitsTextboxDropdownPosition;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    onItemDisabled(): ItemDisabledFn;
+    /**
+     * Function that is called when input value changed
+     */
+    onInputChange(value: string | number): void;
+    /**
+     * Function that is called when dropdown list item selected
+     */
+    onItemSelect(item: KitDropdownItem<T>): void;
+    /**
+     * Function that is called when input field lost focus
+     */
+    onInputBlur(): void;
+    /**
+     * Function that is called when dropdown lost focus
+     */
+    onDropdownBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUnitsTextboxComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitUnitsTextboxComponent<any>, "kit-units-textbox", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabledTextBox": { "alias": "disabledTextBox"; "required": false; }; "disabledDropdown": { "alias": "disabledDropdown"; "required": false; }; "dropdownItems": { "alias": "dropdownItems"; "required": false; }; "selectedDropdownItem": { "alias": "selectedDropdownItem"; "required": false; }; "textBoxValue": { "alias": "textBoxValue"; "required": false; }; "textBoxFormControl": { "alias": "textBoxFormControl"; "required": false; }; "dropdownFormControl": { "alias": "dropdownFormControl"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; "textboxType": { "alias": "textboxType"; "required": false; }; "decimals": { "alias": "decimals"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "format": { "alias": "format"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; }, { "blured": "blured"; "selected": "selected"; "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitUnitsTextboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUnitsTextboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitUnitsTextboxModule, [typeof KitUnitsTextboxComponent], [typeof i2$1.CommonModule, typeof i3$1.TextBoxModule, typeof i3$1.NumericTextBoxModule, typeof i4.DropDownListModule, typeof KitInputMessageModule, typeof i5.FormsModule, typeof i5.ReactiveFormsModule, typeof KitSvgIconModule, typeof KitInputLabelModule], [typeof KitUnitsTextboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitUnitsTextboxModule>;
+}
+
+declare class KitDatetimepickerComponent implements ControlValueAccessor {
+    private cdr;
+    /**
+     * Defines a value that is going to be applied as a datetimepicker label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as a datetimepicker placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a state whether the component will be invalid
+     */
+    invalid?: boolean;
+    /**
+     * Defines a value that is going to be applied as a datetimepicker format
+     */
+    format: string;
+    /**
+     * Defines a value that is going to be applied as a default datetimepicker value
+     */
+    defaultDate?: Date;
+    /**
+     * Specifies the smallest valid date
+     */
+    min?: Date;
+    /**
+     * Specifies the biggest valid date
+     */
+    max?: Date;
+    /**
+     * Defines the text of the Apply button in the popup footer of the component, "Apply" by default
+     */
+    applyButtonText: string;
+    /**
+     * Defines the text of the Cancel button in the popup footer of the component, "Cancel" by default
+     */
+    cancelButtonText: string;
+    /**
+     * An action which is emitted when datetimepicker value changed
+     */
+    changed: EventEmitter<Date>;
+    /**
+     * Defines a reference of the DateTimePicker component
+     */
+    datetimepicker: DateTimePickerComponent;
+    /**
+     * An icon which will be used in a datetimepicker toggle button
+     */
+    readonly icon: KitSvgIcon;
+    /**
+     * Settings for datetimepicker popup that will be opened
+     */
+    readonly datetimepickerPopupSettings: PopupSettings;
+    readonly nowButtonText: string;
+    constructor(cdr: ChangeDetectorRef);
+    /**
+     * Function used to toggle visibility of the datetimepicker popup
+     */
+    onPopupToggle(): void;
+    /**
+     * Function that is called when datetimepicker lost focus
+     */
+    onBlur(): void;
+    /**
+     * Function that should be called every time datetimepicker value changes
+     */
+    onValueChange(value: Date): void;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: Date) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (_: Date) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDatetimepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDatetimepickerComponent, "kit-datetimepicker", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "format": { "alias": "format"; "required": false; }; "defaultDate": { "alias": "defaultDate"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "applyButtonText": { "alias": "applyButtonText"; "required": false; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitDatetimepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDatetimepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitDatetimepickerModule, [typeof KitDatetimepickerComponent], [typeof i2$1.CommonModule, typeof i3$2.DateInputsModule, typeof KitSvgIconModule, typeof KitInputMessageModule, typeof KitInputLabelModule], [typeof KitDatetimepickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitDatetimepickerModule>;
+}
+
+declare enum KitNotificationType {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success"
+}
+interface KitNotification {
+    id: number;
+    type: KitNotificationType;
+    message: string;
+    closable: boolean;
+    autoHideTime: number | null;
+}
+
+declare class KitNotificationService {
+    readonly notifications: WritableSignal<KitNotification[]>;
+    private notificationIdCounter;
+    addNotification(type: KitNotificationType, message?: string, closable?: boolean, autoHideTime?: number | null): void;
+    removeNotification(id: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitNotificationService>;
+}
+
+declare class KitNotificationComponent implements OnInit, OnDestroy {
+    private readonly renderer;
+    private readonly el;
+    private readonly notificationService;
+    appendTo: string;
+    readonly notifications: Signal<KitNotification[]>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    private appendedElement;
+    constructor(renderer: Renderer2, el: ElementRef, notificationService: KitNotificationService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    removeNotification(id: number): void;
+    private appendToTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitNotificationComponent, "kit-notification", never, { "appendTo": { "alias": "appendTo"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface KitLocationStepperItemDate {
+    value: string;
+    description?: string;
+}
+interface KitLocationStepperItem {
+    title: string;
+    icon: KitSvgIcon;
+    name?: string;
+    description?: string;
+    dates?: KitLocationStepperItemDate[];
+    cssClass?: string;
+    subItems?: KitLocationStepperItem[];
+    toolTipText?: string;
+}
+declare class KitLocationStepperComponent {
+    /**
+     * An items list to be shown as steps
+     */
+    items: KitLocationStepperItem[];
+    toolTipPosition: KitTooltipPosition;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitLocationStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitLocationStepperComponent, "kit-location-stepper", never, { "items": { "alias": "items"; "required": false; }; "toolTipPosition": { "alias": "toolTipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitLocationStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitLocationStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitLocationStepperModule, [typeof KitLocationStepperComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof KitTooltipDirective], [typeof KitLocationStepperComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitLocationStepperModule>;
+}
+
+interface KitAutocompleteItem<T> {
+    text: string;
+    value: T;
+    getText?(): string;
+}
+declare class KitAutocompleteComponent<T> implements ControlValueAccessor {
+    private elementRef;
+    /**
+     * Defines a value that is going to be applied as an input label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as an input placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines an items list which is going to be an autocomplete items data
+     */
+    items: KitAutocompleteItem<T>[];
+    /**
+     * An item which is going to be an autocomplete selected value
+     */
+    selectedValue: T | null;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Defines whether the loader will be visible or not
+     */
+    loaderVisible: boolean;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a state whether the component will be invalid
+     */
+    invalid?: boolean;
+    /**
+     * Specifies whether the autocomplete allows user-defined values
+     */
+    readonly allowCustom: InputSignal<boolean>;
+    /**
+     * Specifies whether the autocomplete popup will be closed if no filter data found
+     */
+    readonly closePopupIfDataNotFound: InputSignal<boolean>;
+    /**
+     * An action which is emitted each time the user types in the input field
+     */
+    readonly filterChanged: OutputEmitterRef<string>;
+    /**
+     * An action which is emitted each time when value is changed and component is blurred
+     */
+    readonly valueChanged: OutputEmitterRef<string>;
+    /**
+     * An action which is emitted once an item in the dropdown is selected
+     */
+    readonly selectionChanged: OutputEmitterRef<T | null>;
+    /**
+     * An action which is emitted when input lost focus
+     */
+    blured: EventEmitter<void>;
+    /**
+     * An action which is emitted when input field got focus
+     */
+    focused: EventEmitter<void>;
+    private combobox;
+    /**
+     * Settings for popup that will be opened as dropdown options list
+     */
+    readonly dropdownPopupSettings: PopupSettings;
+    constructor(elementRef: ElementRef);
+    /**
+     * Callback function that return dropdown list item text
+     */
+    getOptionText(item: KitAutocompleteItem<T>): string;
+    onValueChange(value: string): void;
+    onFilterChange(value: string): void;
+    onSelectionChange(item: KitAutocompleteItem<T> | null): void;
+    /**
+     * Function that is called when input field lost focus
+     */
+    onBlur(): void;
+    /**
+     * Function that is called when input field get focus
+     */
+    onFocus(): void;
+    /**
+     * Toggles the visibility of the popup
+     */
+    togglePopup(): void;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: T | null) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    writeValue(value: T): void;
+    registerOnChange(fn: (_: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitAutocompleteComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitAutocompleteComponent<any>, "kit-autocomplete", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "items": { "alias": "items"; "required": false; }; "selectedValue": { "alias": "selectedValue"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loaderVisible": { "alias": "loaderVisible"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "allowCustom": { "alias": "allowCustom"; "required": false; "isSignal": true; }; "closePopupIfDataNotFound": { "alias": "closePopupIfDataNotFound"; "required": false; "isSignal": true; }; }, { "filterChanged": "filterChanged"; "valueChanged": "valueChanged"; "selectionChanged": "selectionChanged"; "blured": "blured"; "focused": "focused"; }, never, never, false, never>;
+}
+
+declare class KitAutocompleteDirective<T> {
+    private kitAutocompleteComponent;
+    constructor(kitAutocompleteComponent: KitAutocompleteComponent<T>);
+    togglePopup(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitAutocompleteDirective<any>, [{ host: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitAutocompleteDirective<any>, "[kitAutocomplete]", ["kitAutocomplete"], {}, {}, never, never, false, never>;
+}
+
+declare class KitAutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitAutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitAutocompleteModule, [typeof KitAutocompleteComponent, typeof KitAutocompleteDirective], [typeof i2$1.CommonModule, typeof i4.DropDownsModule, typeof i5.FormsModule, typeof i5.ReactiveFormsModule, typeof i3$1.InputsModule, typeof KitInputMessageModule, typeof KitLoaderModule, typeof KitSvgIconModule, typeof KitInputLabelModule], [typeof KitAutocompleteComponent, typeof KitAutocompleteDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitAutocompleteModule>;
+}
+
+declare enum KitCheckboxState {
+    REGULAR = "regular",
+    DANGER = "danger"
+}
+type CheckboxValueFn = (value: boolean) => void;
+declare class KitCheckboxComponent implements ControlValueAccessor {
+    /**
+     * Defines a label for checkbox; exact this text will be displayed next to the checkbox
+     */
+    label?: string;
+    /**
+     * States the component is disabled
+     */
+    disabled: boolean;
+    /**
+     * Defines a default value
+     */
+    checked: boolean;
+    /**
+     * Defines whether checkbox be in readonly state
+     */
+    readonly: boolean;
+    /**
+     * Defines a particular state for the component
+     */
+    state: KitCheckboxState;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Occurs as soon as input checked state is changed
+     */
+    changed: EventEmitter<boolean>;
+    readonly checkIcon: KitSvgIcon;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: boolean) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: (value: boolean) => void;
+    onInputStateChange(event: Event): void;
+    handleClick(event: MouseEvent): void;
+    registerOnChange(fn: CheckboxValueFn): void;
+    registerOnTouched(fn: CheckboxValueFn): void;
+    writeValue(value: boolean): void;
+    setDisabledState(disabled: boolean): void;
+    setCssClasses(checkbox: HTMLInputElement): Record<string, boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCheckboxComponent, "kit-checkbox", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "state": { "alias": "state"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCheckboxModule, [typeof KitCheckboxComponent], [typeof i3.LabelModule, typeof i3$1.CheckBoxModule, typeof i2$1.CommonModule, typeof KitInputMessageModule, typeof KitSvgIconModule, typeof i5.FormsModule], [typeof KitCheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCheckboxModule>;
+}
+
+declare class KitToggleComponent implements ControlValueAccessor {
+    /**
+     * Defines a label text which will be displayed next to the toggle
+     */
+    label?: string;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled: boolean;
+    /**
+     * Defines whether the component will be in readonly state
+     */
+    readonly: boolean;
+    /**
+     * Defines a default value
+     */
+    defaultChecked: boolean;
+    /**
+     * Defines the left label of the toggle
+     */
+    leftLabel?: string;
+    /**
+     * Defines the right label of the toggle
+     */
+    rightLabel?: string;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Occurs as soon as toggle state is changed
+     */
+    changed: EventEmitter<boolean>;
+    /**
+     * Function that is called when toggle state changed
+     */
+    onInputStateChange(checked: boolean): void;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: boolean) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    registerOnChange(fn: (_: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(value: boolean): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitToggleComponent, "kit-toggle", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; }; "leftLabel": { "alias": "leftLabel"; "required": false; }; "rightLabel": { "alias": "rightLabel"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitToggleModule, [typeof KitToggleComponent], [typeof i2$1.CommonModule, typeof i3$1.SwitchModule, typeof KitInputMessageModule, typeof KitInputLabelModule], [typeof KitToggleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitToggleModule>;
+}
+
+declare enum KitPillType {
+    DEFAULT = "default",
+    DASHED = "dashed"
+}
+declare enum KitPillTheme {
+    DEFAULT = "default",
+    BLUE = "blue",
+    MAIN = "main"
+}
+
+declare class KitPillComponent {
+    /**
+     * Defines if the pill will be removable. If set to true pill renders a remove button
+     */
+    removable: boolean;
+    /**
+     * Defines if the pill will be selectable
+     */
+    selectable: boolean;
+    /**
+     * Defines the selected state of the pill
+     */
+    selected: boolean;
+    /**
+     * Defines the pill type
+     */
+    type: KitPillType;
+    /**
+     * Defines the color theme of the pill
+     */
+    readonly theme: InputSignal<KitPillTheme>;
+    /**
+     * Defines the icon which will be used in a pill with icon
+     */
+    icon?: KitSvgIcon;
+    /**
+     * Defines the icon type
+     */
+    iconType?: KitSvgIconType;
+    /**
+     * An action which is emitted when the pill is clicked
+     */
+    clicked: EventEmitter<boolean>;
+    /**
+     * An action which is emitted when the close button is clicked
+     */
+    removed: EventEmitter<void>;
+    readonly closeIcon: KitSvgIcon;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    get cssClasses(): Record<string, boolean>;
+    onComponentClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitPillComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitPillComponent, "kit-pill", never, { "removable": { "alias": "removable"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "type": { "alias": "type"; "required": false; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; }, { "clicked": "clicked"; "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+interface KitToastrModuleConfig {
+    preventDuplicates: boolean;
+    countDuplicates: boolean;
+}
+declare class KitToastrModule {
+    static forRoot(config?: Partial<KitToastrModuleConfig>): ModuleWithProviders<ToastrModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitToastrModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitToastrModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitToastrModule>;
+}
+
+declare enum KitToastrType {
+    ERROR = "toast-error",
+    INFO = "toast-info",
+    SUCCESS = "toast-success",
+    WARNING = "toast-warning"
+}
+declare enum KitToastrPosition {
+    TOP_CENTER = "toast-top-center",
+    TOP_LEFT = "toast-top-left",
+    TOP_RIGHT = "toast-top-right",
+    BOTTOM_CENTER = "toast-bottom-center",
+    BOTTOM_LEFT = "toast-bottom-left",
+    BOTTOM_RIGHT = "toast-bottom-right",
+    TOP_FULL_WIDTH = "toast-top-full-width",
+    BOTTOM_FULL_WIDTH = "toast-bottom-full-width"
+}
+interface KitToastrConfig {
+    type: KitToastrType;
+    message: string;
+    dismissible?: boolean;
+    title?: string;
+    position?: KitToastrPosition;
+    overlay?: boolean;
+    timeout?: number;
+    closeButton?: boolean;
+    progressbar?: boolean;
+    disableTimeout?: boolean;
+    toastClass?: string;
+}
+type KitToastr = ActiveToast<void>;
+declare class KitToastrService {
+    private toastrService;
+    private rendererFactory2;
+    private renderer2;
+    constructor(toastrService: ToastrService, rendererFactory2: RendererFactory2);
+    show(config: KitToastrConfig): KitToastr;
+    private getConfig;
+    private removeOverlayContainerClassIfToastsEmpty;
+    private addOverlayContainerClass;
+    private removeOverlayContainerClass;
+    private getOverlayContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitToastrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitToastrService>;
+}
+
+declare enum KitDaterangeType {
+    DEFAULT = "default",
+    BUTTON = "button"
+}
+interface KitDaterangeValue {
+    start: Date | null;
+    end: Date | null;
+}
+declare class KitDaterangeComponent {
+    type: KitDaterangeType;
+    /**
+     * Defines a value that is going to be applied as a daterange button label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as a daterange start input label
+     */
+    startLabel?: string;
+    /**
+     * Defines a value that is going to be applied as a daterange end input label
+     */
+    endLabel?: string;
+    /**
+     * Defines a value that is going to be applied as a daterange start input placeholder
+     */
+    startPlaceholder?: string;
+    /**
+     * Defines a value that is going to be applied as a daterange end input placeholder
+     */
+    endPlaceholder?: string;
+    /**
+     * Defines a value that is going to be applied as a daterange format
+     */
+    format: string;
+    /**
+     * Defines a value that is going to be applied as a default daterange start date value
+     */
+    defaultStartDate?: Date;
+    /**
+     * Defines a value that is going to be applied as a default daterange end date value
+     */
+    defaultEndDate?: Date;
+    /**
+     * Specifies the smallest valid date
+     */
+    min?: Date;
+    /**
+     * Specifies the biggest valid date
+     */
+    max?: Date;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Defines a state whether the component will be invalid
+     */
+    invalid: boolean;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines a value that is going to be applied as a start date form control
+     */
+    startDateControl: AbstractControl;
+    /**
+     * Defines a value that is going to be applied as an end date form control
+     */
+    endDateControl: AbstractControl;
+    /**
+     * An action which is emitted when start date changed
+     */
+    startDateChanged: EventEmitter<Date>;
+    /**
+     * An action which is emitted when daterange popup closed
+     */
+    closed: EventEmitter<KitDaterangeValue>;
+    /**
+     * An action which is emitted when end date changed
+     */
+    endDateChanged: EventEmitter<Date>;
+    popup: DateRangePopupComponent;
+    /**
+     * An icon which will be used in a daterange input icon
+     */
+    readonly icon: KitSvgIcon;
+    readonly KitDaterangeType: typeof KitDaterangeType;
+    openCalendarPopup(): void;
+    onStartDateChange(value: Date): void;
+    onEndDateChange(value: Date): void;
+    onBlur(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDaterangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDaterangeComponent, "kit-daterange", never, { "type": { "alias": "type"; "required": false; }; "label": { "alias": "label"; "required": false; }; "startLabel": { "alias": "startLabel"; "required": false; }; "endLabel": { "alias": "endLabel"; "required": false; }; "startPlaceholder": { "alias": "startPlaceholder"; "required": false; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; }; "format": { "alias": "format"; "required": false; }; "defaultStartDate": { "alias": "defaultStartDate"; "required": false; }; "defaultEndDate": { "alias": "defaultEndDate"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "startDateControl": { "alias": "startDateControl"; "required": false; }; "endDateControl": { "alias": "endDateControl"; "required": false; }; }, { "startDateChanged": "startDateChanged"; "closed": "closed"; "endDateChanged": "endDateChanged"; }, never, never, false, never>;
+}
+
+declare class KitDaterangeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDaterangeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitDaterangeModule, [typeof KitDaterangeComponent], [typeof i2$1.CommonModule, typeof i3$2.DateInputsModule, typeof KitSvgIconModule, typeof KitInputMessageModule, typeof KitInputLabelModule], [typeof KitDaterangeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitDaterangeModule>;
+}
+
+interface KitCtaPanelItem {
+    title: string;
+    buttonText?: string;
+    icon?: KitSvgIcon;
+    link?: string | string[];
+    copyItem?: KitCtaPanelCopyItem;
+    action?(): void;
+}
+interface KitCtaPanelCopyItem {
+    textToCopy: string;
+    tooltipTextBefore?: string;
+    tooltipTextAfter?: string;
+}
+declare enum KitCtaPanelItemType {
+    BUTTON = "button",
+    LINK = "link"
+}
+
+declare class KitCtaPanelItemComponent {
+    item?: KitCtaPanelItem;
+    type: KitCtaPanelItemType;
+    clicked: EventEmitter<void>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitCtaPanelItemType: typeof KitCtaPanelItemType;
+    onButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCtaPanelItemComponent, "kit-cta-panel-item", never, { "item": { "alias": "item"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "clicked": "clicked"; }, never, never, false, never>;
+}
+
+declare enum KitCopyTextState {
+    NOT_COPIED = "not-copied",
+    COPIED = "copied"
+}
+declare class KitCopyTextComponent {
+    private document;
+    /**
+     Defines a value that is going to be the text to be copied
+     */
+    textToCopy: string | null;
+    /**
+     Defines a value that is going to be displayed on hover as a hint before copying
+     */
+    tooltipTextBefore: string | null;
+    /**
+     Defines a value that is going to be displayed on hover as a hint after copying
+     */
+    tooltipTextAfter: string | null;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly CopyTextState: typeof KitCopyTextState;
+    readonly copyTextState$: BehaviorSubject<KitCopyTextState>;
+    constructor(document: Document);
+    copyText(): void;
+    private setState;
+    private handleCopyStateChange;
+    private copyTextToClipboard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCopyTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCopyTextComponent, "kit-copy-text", never, { "textToCopy": { "alias": "textToCopy"; "required": false; }; "tooltipTextBefore": { "alias": "tooltipTextBefore"; "required": false; }; "tooltipTextAfter": { "alias": "tooltipTextAfter"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitCopyTextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCopyTextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCopyTextModule, [typeof KitCopyTextComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule], [typeof KitCopyTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCopyTextModule>;
+}
+
+declare class KitCtaPanelItemModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelItemModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCtaPanelItemModule, [typeof KitCtaPanelItemComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof i3$3.RouterModule, typeof KitCopyTextModule], [typeof KitCtaPanelItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCtaPanelItemModule>;
+}
+
+declare class KitCtaPanelActionComponent {
+    disabled: boolean;
+    confirmText: string;
+    quitText: string;
+    quitClicked: EventEmitter<void>;
+    confirmClicked: EventEmitter<void>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitButtonKind: typeof KitButtonKind;
+    readonly KitButtonType: typeof KitButtonType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCtaPanelActionComponent, "kit-cta-panel-action", never, { "disabled": { "alias": "disabled"; "required": false; }; "confirmText": { "alias": "confirmText"; "required": false; }; "quitText": { "alias": "quitText"; "required": false; }; }, { "quitClicked": "quitClicked"; "confirmClicked": "confirmClicked"; }, never, never, false, never>;
+}
+
+declare class KitCtaPanelActionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelActionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCtaPanelActionModule, [typeof KitCtaPanelActionComponent], [typeof i2$1.CommonModule, typeof KitButtonModule], [typeof KitCtaPanelActionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCtaPanelActionModule>;
+}
+
+declare abstract class AbstractKitCtaPanelConfirmationComponent {
+    isConfirmation: boolean;
+    onOpenButtonClick(): void;
+    onQuitButtonClick(): void;
+    protected hideConfirmation(): void;
+    protected showConfirmation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractKitCtaPanelConfirmationComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractKitCtaPanelConfirmationComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+interface KitCtaPanelConfirmation<T> {
+    title: string;
+    description?: string;
+    icon: KitSvgIcon;
+    checkboxLabel?: string;
+    dropdownLabel?: string;
+    defaultDropdownItem?: KitDropdownItem<T>;
+    dropdownItems?: KitDropdownItem<T>[];
+}
+interface KitCtaPanelConfirmationValue<T> {
+    reason: T;
+    checkbox: boolean;
+}
+
+declare class KitCtaPanelConfirmationComponent<T> {
+    private formBuilder;
+    data?: KitCtaPanelConfirmation<T>;
+    confirmButtonDisabled: boolean;
+    dropdownListHeight: number;
+    quitText: string;
+    confirmText: string;
+    quitClicked: EventEmitter<void>;
+    confirmClicked: EventEmitter<KitCtaPanelConfirmationValue<T>>;
+    readonly form: UntypedFormGroup;
+    constructor(formBuilder: UntypedFormBuilder);
+    onConfirmButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelConfirmationComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCtaPanelConfirmationComponent<any>, "kit-cta-panel-confirmation", never, { "data": { "alias": "data"; "required": false; }; "confirmButtonDisabled": { "alias": "confirmButtonDisabled"; "required": false; }; "dropdownListHeight": { "alias": "dropdownListHeight"; "required": false; }; "quitText": { "alias": "quitText"; "required": false; }; "confirmText": { "alias": "confirmText"; "required": false; }; }, { "quitClicked": "quitClicked"; "confirmClicked": "confirmClicked"; }, never, never, false, never>;
+}
+
+declare class KitCtaPanelConfirmationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelConfirmationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCtaPanelConfirmationModule, [typeof KitCtaPanelConfirmationComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof KitDropdownModule, typeof i5.FormsModule, typeof i5.ReactiveFormsModule, typeof KitSvgIconModule, typeof KitDropdownModule, typeof KitCtaPanelActionModule, typeof KitCheckboxModule], [typeof KitCtaPanelConfirmationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCtaPanelConfirmationModule>;
+}
+
+declare class KitCtaPanelAbstractConfirmationComponent {
+    confirmButtonDisabled: boolean;
+    quitText: string | null;
+    confirmText: string | null;
+    quitClicked: EventEmitter<void>;
+    confirmClicked: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelAbstractConfirmationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCtaPanelAbstractConfirmationComponent, "kit-cta-panel-abstract-confirmation", never, { "confirmButtonDisabled": { "alias": "confirmButtonDisabled"; "required": false; }; "quitText": { "alias": "quitText"; "required": false; }; "confirmText": { "alias": "confirmText"; "required": false; }; }, { "quitClicked": "quitClicked"; "confirmClicked": "confirmClicked"; }, never, [".confirmation-head", ".confirmation-main"], false, never>;
+}
+
+declare class KitCtaPanelAbstractConfirmationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCtaPanelAbstractConfirmationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCtaPanelAbstractConfirmationModule, [typeof KitCtaPanelAbstractConfirmationComponent], [typeof KitCtaPanelActionModule, typeof KitSvgIconModule, typeof i2$1.CommonModule], [typeof KitCtaPanelAbstractConfirmationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCtaPanelAbstractConfirmationModule>;
+}
+
+declare class KitNoteComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNoteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitNoteComponent, "kit-note", never, {}, {}, never, [".content", ".footer-content", ".footer-actions"], false, never>;
+}
+
+declare class KitNoteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNoteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitNoteModule, [typeof KitNoteComponent], never, [typeof KitNoteComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitNoteModule>;
+}
+
+declare enum KitQueryParamsName {
+    FILTER = "filter"
+}
+type KitQueryParams = Record<string, string | string[]>;
+declare class KitQueryParamsService {
+    private activatedRoute;
+    constructor(activatedRoute: ActivatedRoute);
+    getQueryParamsByName(name: KitQueryParamsName): KitQueryParams[] | null;
+    private buildParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitQueryParamsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitQueryParamsService>;
+}
+
+interface KitRadioButton<T> {
+    label: string;
+    value: T;
+    readonly?: boolean;
+    disabled?: boolean;
+    checked?: boolean;
+    icon?: KitSvgIcon;
+}
+
+declare enum KitRadioButtonType {
+    DEFAULT = "default",
+    ICON_LIST = "icon-list"
+}
+
+declare class KitRadioButtonComponent<T> implements ControlValueAccessor {
+    items: KitRadioButton<T>[];
+    label: string | null;
+    name: string;
+    readonly: boolean;
+    disabled: boolean;
+    type: KitRadioButtonType;
+    changed: EventEmitter<KitRadioButton<T>>;
+    readonly kitRadioButtonType: typeof KitRadioButtonType;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitSvgIconType: typeof KitSvgIconType;
+    get isIconListType(): boolean;
+    buildLabelId(index: number): string;
+    handleClick(event: MouseEvent, clickedItem: KitRadioButton<T>): void;
+    onChange(value: T): void;
+    onTouched(): void;
+    writeValue(value: T): void;
+    registerOnChange(fn: (_: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    onRadioValueChange(item: KitRadioButton<T>): void;
+    private buildUniqName;
+    private getFirstPartOfUUID;
+    private needToPrevent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitRadioButtonComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitRadioButtonComponent<any>, "kit-radio-button", never, { "items": { "alias": "items"; "required": false; }; "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitRadioButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitRadioButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitRadioButtonModule, [typeof KitRadioButtonComponent], [typeof i2$1.CommonModule, typeof i3$1.RadioButtonModule, typeof KitInputLabelModule, typeof KitSvgIconModule], [typeof KitRadioButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitRadioButtonModule>;
+}
+
+declare const buildRandomUUID: () => string;
+
+declare enum KitNavigationTabsType {
+    TEXT = "text",
+    BUTTON = "button"
+}
+
+type KitNavigationTabsItemLink = string | number;
+interface KitNavigationTabsItem {
+    title: string;
+    link: KitNavigationTabsItemLink[] | string | null;
+    icon?: KitSvgIcon;
+    iconType?: KitSvgIconType;
+    disabled?: Predicate<KitNavigationTabsItem>;
+}
+
+declare class KitNavigationTabsComponent {
+    /**
+     * Items which are going to be rendered as tabs navigation items
+     */
+    items: KitNavigationTabsItem[];
+    /**
+     * Defines the type of tabs
+     */
+    type: KitNavigationTabsType;
+    getRouterLink(item: KitNavigationTabsItem): string | KitNavigationTabsItemLink[] | null;
+    getItemIconCssClass(item: KitNavigationTabsItem): KitSvgIconType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitNavigationTabsComponent, "kit-navigation-tabs", never, { "items": { "alias": "items"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitNavigationTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitNavigationTabsModule, [typeof KitNavigationTabsComponent], [typeof i2$1.CommonModule, typeof i3$3.RouterModule, typeof KitSvgIconModule], [typeof KitNavigationTabsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitNavigationTabsModule>;
+}
+
+declare class KitDialogComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDialogComponent, "kit-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitDialogService {
+    private readonly dialogService;
+    private readonly _dialogRef;
+    get isDialogOpen(): boolean;
+    get dialogInstance(): DialogRef['content']['instance'] | null;
+    get dialogRef(): DialogRef | null;
+    constructor(dialogService: DialogService);
+    openDialog(settings: DialogSettings): void;
+    closeDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitDialogService>;
+}
+
+declare class KitDialogActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDialogActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDialogActionsComponent, "kit-dialog-actions", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class KitTimepickerComponent implements ControlValueAccessor {
+    /**
+     * Defines a value that is going to be applied as a timepicker label
+     */
+    label: string | null;
+    /**
+     * Defines a value that is going to be applied as a timepicker placeholder
+     */
+    placeholder: string | null;
+    /**
+     * Defines a value that is going to be applied as a default timepicker value
+     */
+    defaultValue: Date | null;
+    /**
+     * Defines whether 24-hour time format will be applied to timepicker component
+     */
+    longFormatEnabled: boolean;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled: boolean;
+    /**
+     * Defines a state whether the component will be invalid
+     */
+    invalid: boolean;
+    /**
+     * Specifies the smallest valid time value
+     */
+    min: Date | null;
+    /**
+     * Specifies the biggest valid time value
+     */
+    max: Date | null;
+    /**
+     * Defines the text of the Apply button in the popup footer of the component, "Apply" by default
+     */
+    applyButtonText: string;
+    /**
+     * Defines the text of the Cancel button in the popup footer of the component, "Cancel" by default
+     */
+    cancelButtonText: string;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * An action which is emitted when timepicker popup opened
+     */
+    popupOpened: EventEmitter<void>;
+    /**
+     * An action which is emitted when timepicker popup closed
+     */
+    popupClosed: EventEmitter<void>;
+    /**
+     * An action which is emitted when timepicker value changed
+     */
+    changed: EventEmitter<Date>;
+    /**
+     * An action which is emitted when timepicker input field lost focus
+     */
+    blured: EventEmitter<void>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly longTimeFormat: string;
+    readonly shortTimeFormat: string;
+    readonly timepickerPopupSettings: PopupSettings;
+    onChange(value: Date): void;
+    onTouched(): void;
+    onInputBlur(): void;
+    onInputChange(value: Date): void;
+    writeValue(value: Date): void;
+    registerOnChange(fn: (_: Date) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTimepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTimepickerComponent, "kit-timepicker", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "longFormatEnabled": { "alias": "longFormatEnabled"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "applyButtonText": { "alias": "applyButtonText"; "required": false; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; }, { "popupOpened": "popupOpened"; "popupClosed": "popupClosed"; "changed": "changed"; "blured": "blured"; }, never, never, false, never>;
+}
+
+declare class KitTimepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTimepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitTimepickerModule, [typeof KitTimepickerComponent], [typeof i3$2.TimePickerModule, typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof KitInputLabelModule, typeof i3$2.DateTimePickerModule, typeof KitInputMessageModule], [typeof KitTimepickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitTimepickerModule>;
+}
+
+declare enum KitSkeletonShape {
+    TEXT = "text",
+    CIRCLE = "circle",
+    RECTANGLE = "rectangle"
+}
+declare enum KitSkeletonAnimation {
+    PULSE = "pulse",
+    WAVE = "wave"
+}
+declare class KitSkeletonComponent {
+    /**
+     Defines the width of the skeleton component
+     */
+    width: string | number | null;
+    /**
+     Defines the height of the skeleton component
+     */
+    height: string | number | null;
+    /**
+     Defines the shape of the skeleton
+     */
+    shape: KitSkeletonShape;
+    /**
+     Defines the animation of the skeleton
+     */
+    animation: KitSkeletonAnimation | false;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSkeletonComponent, "kit-skeleton", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitSkeletonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSkeletonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitSkeletonModule, [typeof KitSkeletonComponent], [typeof i2$1.CommonModule, typeof i3$4.IndicatorsModule], [typeof KitSkeletonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitSkeletonModule>;
+}
+
+interface KitFileUploadFileRestrictions {
+    allowedExtensions?: string[];
+    maxFileSize?: number;
+}
+interface KitFileUploadFileRestrictionsMessages {
+    allowedExtensions?: string;
+    maxFileSize?: string;
+}
+type KitFileUploadFile = FileInfo;
+
+declare class KitFileUploadComponent {
+    /**
+     * Defines the URL of the endpoint for the upload request
+     */
+    saveUrl: string;
+    /**
+     * Defines the initial list of files
+     */
+    files: KitFileUploadFile[];
+    /**
+     * Defines a label for "Select files" button
+     */
+    selectFilesLabel?: string;
+    /**
+     * Defines a label for dropzone
+     */
+    dropzoneLabel?: string;
+    /**
+     * Defines the restrictions for selected files
+     */
+    restrictions?: KitFileUploadFileRestrictions;
+    /**
+     * Defines a list of error messages for selected files
+     */
+    restrictionsErrorMessages?: KitFileUploadFileRestrictionsMessages;
+    /**
+     * Defines whether the component will have an action button
+     */
+    hasActionButton: boolean;
+    /**
+     * Defines an action button label
+     */
+    actionButtonLabel?: string;
+    /**
+     * An action which is emitted when download file button clicked
+     */
+    fileDownloaded: EventEmitter<KitFileUploadFile>;
+    /**
+     * An action which is emitted when files are selected
+     */
+    filesSelected: EventEmitter<KitFileUploadFile[]>;
+    /**
+     * An action which is emitted when action button clicked
+     */
+    actionButtonClicked: EventEmitter<void>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitSvgIconType: typeof KitSvgIconType;
+    readonly KitButtonKind: typeof KitButtonKind;
+    readonly kitFileUploadValidationErrorMap: Record<string, () => string>;
+    onFileDownload(file: KitFileUploadFile): void;
+    onFilesSelect(files: KitFileUploadFile[]): void;
+    onActionButtonClick(): void;
+    getValidationError(error: string): string;
+    getTypedFiles(files: KitFileUploadFile[]): KitFileUploadFile[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitFileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitFileUploadComponent, "kit-file-upload", never, { "saveUrl": { "alias": "saveUrl"; "required": false; }; "files": { "alias": "files"; "required": false; }; "selectFilesLabel": { "alias": "selectFilesLabel"; "required": false; }; "dropzoneLabel": { "alias": "dropzoneLabel"; "required": false; }; "restrictions": { "alias": "restrictions"; "required": false; }; "restrictionsErrorMessages": { "alias": "restrictionsErrorMessages"; "required": false; }; "hasActionButton": { "alias": "hasActionButton"; "required": false; }; "actionButtonLabel": { "alias": "actionButtonLabel"; "required": false; }; }, { "fileDownloaded": "fileDownloaded"; "filesSelected": "filesSelected"; "actionButtonClicked": "actionButtonClicked"; }, never, never, false, never>;
+}
+
+declare class KitFileUploadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitFileUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitFileUploadModule, [typeof KitFileUploadComponent], [typeof i2$1.CommonModule, typeof i3$5.UploadModule, typeof KitSvgIconModule, typeof i5.FormsModule, typeof KitButtonModule], [typeof KitFileUploadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitFileUploadModule>;
+}
+
+declare class KitPermissionDirective implements OnInit {
+    private templateRef;
+    private viewContainer;
+    /**
+     * Defines the permissions that a user must have in order for the content to be visible
+     */
+    kitPermission: string[];
+    /**
+     * Defines the permissions assigned to the user
+     */
+    kitPermissionUser: string[];
+    constructor(templateRef: TemplateRef<HTMLElement>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    private updateView;
+    private hasPermissions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitPermissionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitPermissionDirective, "[kitPermission]", never, { "kitPermission": { "alias": "kitPermission"; "required": false; }; "kitPermissionUser": { "alias": "kitPermissionUser"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitPermissionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitPermissionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitPermissionModule, [typeof KitPermissionDirective], never, [typeof KitPermissionDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitPermissionModule>;
+}
+
+interface KitNavigationMenuItem {
+    title: string;
+    link?: string;
+    cssClass?: string;
+    icon?: KitSvgIcon;
+    iconType?: KitSvgIconType;
+    expanded?: boolean;
+    active?: boolean;
+    items?: KitNavigationMenuItem[];
+}
+interface KitNavigationMenuAppItem {
+    name: string;
+    url: string | null;
+}
+
+declare class KitNavigationMenuService {
+    private readonly collapsed;
+    private readonly selected;
+    getCollapsedState(): WritableSignal<boolean>;
+    setCollapsedState(collapsed: boolean): void;
+    setSelectedState(hasSelectedMenu: boolean, hasSelectedApps: boolean): void;
+    getSelectedState(): WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitNavigationMenuService>;
+}
+
+declare class KitNavigationMenuComponent implements OnInit {
+    private router;
+    private kitNavigationMenuService;
+    /**
+     * An items list which is going to be rendered as menu items
+     */
+    readonly menuItems: ModelSignal<KitNavigationMenuItem[]>;
+    /**
+     * An items list which is going to be rendered as apps menu items
+     */
+    readonly appsMenuItems: InputSignal<KitNavigationMenuAppItem[]>;
+    logoPath: string;
+    readonly selectedItem: WritableSignal<KitNavigationMenuItem | null>;
+    readonly selectedAppsItems: WritableSignal<KitNavigationMenuAppItem[] | null>;
+    readonly collapsed: WritableSignal<boolean>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitSvgIconType: typeof KitSvgIconType;
+    readonly KitTooltipPosition: typeof KitTooltipPosition;
+    constructor(router: Router, kitNavigationMenuService: KitNavigationMenuService);
+    ngOnInit(): void;
+    handleClick(item: KitNavigationMenuItem): void;
+    handleLogoClick(): void;
+    onAppsMenuButtonClick(): void;
+    private setExpandedStateOnRouterChange;
+    private updateNavigationState;
+    private collapseAllItems;
+    private toggleItem;
+    private updateMenuState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitNavigationMenuComponent, "kit-navigation-menu", never, { "menuItems": { "alias": "menuItems"; "required": false; "isSignal": true; }; "appsMenuItems": { "alias": "appsMenuItems"; "required": false; "isSignal": true; }; "logoPath": { "alias": "logoPath"; "required": false; }; }, { "menuItems": "menuItemsChange"; }, never, never, false, never>;
+}
+
+declare class KitNavigationMenuSubmenuComponent {
+    private readonly document;
+    menuItem: KitNavigationMenuItem | null;
+    appsMenuItems: KitNavigationMenuAppItem[] | null;
+    logoPath: string;
+    logoClicked: EventEmitter<void>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly rootPath: string;
+    constructor(document: Document);
+    handleClick(item: KitNavigationMenuItem): void;
+    isAppItemActive(url: string | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationMenuSubmenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitNavigationMenuSubmenuComponent, "kit-navigation-menu-submenu", never, { "menuItem": { "alias": "menuItem"; "required": false; }; "appsMenuItems": { "alias": "appsMenuItems"; "required": false; }; "logoPath": { "alias": "logoPath"; "required": false; }; }, { "logoClicked": "logoClicked"; }, never, never, false, never>;
+}
+
+declare class KitNavigationMenuSubmenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationMenuSubmenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitNavigationMenuSubmenuModule, [typeof KitNavigationMenuSubmenuComponent], [typeof i2$1.CommonModule, typeof i3$3.RouterModule, typeof KitSvgIconModule], [typeof KitNavigationMenuSubmenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitNavigationMenuSubmenuModule>;
+}
+
+declare class KitNavigationMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitNavigationMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitNavigationMenuModule, [typeof KitNavigationMenuComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof i3$3.RouterModule, typeof KitNavigationMenuSubmenuModule, typeof KitTooltipDirective], [typeof KitNavigationMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitNavigationMenuModule>;
+}
+
+declare enum KitBadgeTheme {
+    SUCCESS = "success",
+    DEFAULT = "default",
+    DANGER = "danger",
+    PROCESSING = "processing",
+    WARNING = "warning"
+}
+
+declare class KitBadgeDirective implements OnDestroy {
+    private elementRef;
+    private renderer;
+    /**
+     * Defines the content of the badge
+     */
+    readonly kitBadgeText: InputSignal<string | number | undefined>;
+    /**
+     * Defines the theme color of the badge
+     */
+    readonly kitBadgeTheme: InputSignal<KitBadgeTheme>;
+    /**
+     * Defines whether the badge will be visible
+     */
+    readonly kitBadgeVisible: InputSignal<boolean>;
+    private badgeElement;
+    constructor(elementRef: ElementRef, renderer: Renderer2);
+    ngOnDestroy(): void;
+    private createBadge;
+    private updateBadge;
+    private removeBadge;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitBadgeDirective, "[kitBadge]", never, { "kitBadgeText": { "alias": "kitBadgeText"; "required": false; "isSignal": true; }; "kitBadgeTheme": { "alias": "kitBadgeTheme"; "required": false; "isSignal": true; }; "kitBadgeVisible": { "alias": "kitBadgeVisible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare enum KitAvatarSize {
+    LARGE = "large",
+    DEFAULT = "default",
+    SMALL = "small"
+}
+
+declare class KitAvatarComponent {
+    /**
+     * Defines the name that is going to be used to set initials to the avatar
+     */
+    name?: string;
+    /**
+     * Defines the image source of the avatar
+     */
+    imageSrc?: string;
+    /**
+     * Defines the size of the avatar
+     */
+    size: KitAvatarSize;
+    readonly userIcon: KitSvgIcon;
+    getInitialsByName(name: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitAvatarComponent, "kit-avatar", never, { "name": { "alias": "name"; "required": false; }; "imageSrc": { "alias": "imageSrc"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitAvatarModule, [typeof KitAvatarComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule], [typeof KitAvatarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitAvatarModule>;
+}
+
+interface KitMultiselectItem<T> {
+    text: string;
+    value: T;
+    disabled?: Predicate<KitMultiselectItem<T>>;
+}
+
+declare class KitMultiselectComponent<T> implements ControlValueAccessor {
+    private elementRef;
+    private readonly translateService;
+    /**
+     * An items list which is going to be rendered as multiselect items
+     */
+    items: KitMultiselectItem<T>[];
+    /**
+     * An items which need to be selected as a default value
+     */
+    selectedItems?: T[];
+    /**
+     * Defines a value that is going to be applied as a multiselect label
+     */
+    label?: string;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Defines a value that is going to be applied as a multiselect placeholder
+     */
+    placeholder?: string;
+    /**
+     * Determines whether to close the popup of the multiSelect after the item selection, false by default
+     */
+    autoClose: boolean;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    readonly shouldAddAllAsOption: InputSignal<boolean>;
+    readonly allOptionLabel: InputSignal<string | undefined>;
+    /**
+     * An action which is emitted when value is changed
+     */
+    changed: EventEmitter<T[]>;
+    readonly multiselect: Signal<MultiSelectComponent>;
+    /**
+     * Settings for the multiselect popup
+     */
+    readonly popupSettings: PopupSettings;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly allOption: Signal<KitMultiselectItem<T>>;
+    private readonly destroy$;
+    get canAddAllAsOption(): boolean;
+    get isAllAsOptionAdded(): boolean;
+    get hasSelectedAllOption(): boolean;
+    get allEnabledItems(): T[];
+    constructor(elementRef: ElementRef, translateService: TranslateService);
+    ngOnInit(): void;
+    ngOnChanges({ items, selectedItems, shouldAddAllAsOption }: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onItemDisabled(): ItemDisabledFn;
+    onValueChange(value: T[]): void;
+    /**
+     * Function that should be called every time the form control value changes
+     */
+    onChange: (value: T[]) => void;
+    /**
+     * Function that should be called when input lost focus and changed form control state to "touched"
+     */
+    onTouched: () => void;
+    writeValue(value: T[]): void;
+    registerOnChange(fn: (_: T[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    private addAllAsOption;
+    private removeAllAsOption;
+    private subscribeToValueChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitMultiselectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitMultiselectComponent<any>, "kit-multiselect", never, { "items": { "alias": "items"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "shouldAddAllAsOption": { "alias": "shouldAddAllAsOption"; "required": false; "isSignal": true; }; "allOptionLabel": { "alias": "allOptionLabel"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitMultiselectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitMultiselectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitMultiselectModule, [typeof KitMultiselectComponent], [typeof i2$1.CommonModule, typeof i4.MultiSelectModule, typeof i4.DropDownListModule, typeof i5.FormsModule, typeof KitSvgIconModule, typeof KitInputMessageModule, typeof KitInputLabelModule, typeof i8.TranslateModule], [typeof KitMultiselectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitMultiselectModule>;
+}
+
+interface KitPopupAlign {
+    horizontal: KitPopupAlignHorizontal;
+    vertical: KitPopupAlignVertical;
+}
+declare enum KitPopupAlignHorizontal {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}
+declare enum KitPopupAlignVertical {
+    TOP = "top",
+    CENTER = "center",
+    BOTTOM = "bottom"
+}
+declare enum KitPopupPositionMode {
+    ABSOLUTE = "absolute",
+    FIXED = "fixed"
+}
+
+declare class KitPopupComponent {
+    private readonly popupService;
+    popupTemplate: TemplateRef<unknown>;
+    readonly anchor: InputSignal<ElementRef | HTMLElement>;
+    readonly content: InputSignal<TemplateRef<unknown>>;
+    readonly closeOnOutsideClick: InputSignal<boolean>;
+    readonly showFooter: InputSignal<boolean>;
+    readonly cancelButtonLabel: InputSignal<string>;
+    readonly applyButtonLabel: InputSignal<string>;
+    readonly isApplyButtonDisabled: InputSignal<boolean>;
+    readonly positionMode: InputSignal<KitPopupPositionMode>;
+    readonly popupClass: InputSignal<string>;
+    readonly closePopupOnCancel: InputSignal<boolean>;
+    readonly onCancel: OutputEmitterRef<void>;
+    readonly onApply: OutputEmitterRef<void>;
+    readonly onOpen: OutputEmitterRef<void>;
+    readonly onClose: OutputEmitterRef<void>;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitButtonType: typeof KitButtonType;
+    private popupRef;
+    get popupHTMLElement(): HTMLElement | null;
+    get isPopupOpen(): boolean;
+    get anchorElement(): HTMLElement;
+    constructor(popupService: PopupService);
+    documentClick(event: Event): void;
+    ngOnDestroy(): void;
+    toggle(options?: PopupSettings$1): void;
+    close(): void;
+    cancel(): void;
+    apply(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitPopupComponent, "kit-popup", never, { "anchor": { "alias": "anchor"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; "cancelButtonLabel": { "alias": "cancelButtonLabel"; "required": false; "isSignal": true; }; "applyButtonLabel": { "alias": "applyButtonLabel"; "required": false; "isSignal": true; }; "isApplyButtonDisabled": { "alias": "isApplyButtonDisabled"; "required": false; "isSignal": true; }; "positionMode": { "alias": "positionMode"; "required": false; "isSignal": true; }; "popupClass": { "alias": "popupClass"; "required": false; "isSignal": true; }; "closePopupOnCancel": { "alias": "closePopupOnCancel"; "required": false; "isSignal": true; }; }, { "onCancel": "onCancel"; "onApply": "onApply"; "onOpen": "onOpen"; "onClose": "onClose"; }, never, never, true, never>;
+}
+
+declare enum KitDatepickerSize {
+    REGULAR = "regular",
+    SMALL = "small"
+}
+
+declare class KitDatepickerComponent implements ControlValueAccessor {
+    private elementRef;
+    private document;
+    /**
+     * Defines a value that is going to be applied as a datepicker placeholder
+     */
+    placeholder?: string;
+    /**
+     * Defines a value that is going to be applied as a datepicker label
+     */
+    label?: string;
+    /**
+     * Defines a value that is going to be applied as a default datepicker value
+     */
+    defaultDate?: Date;
+    /**
+     * Defines whether the component will be in disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Defines a value that is going to be applied as a datepicker format
+     */
+    format: string;
+    /**
+     * Specifies the smallest valid date
+     */
+    min?: Date;
+    /**
+     * Specifies the biggest valid date
+     */
+    max?: Date;
+    /**
+     * Defines an icon which will be used to the left of the info message
+     */
+    messageIcon?: KitSvgIcon;
+    /**
+     * Defines a value which going to be an info message text
+     */
+    messageText?: string;
+    /**
+     * Defines the size of the datepicker input field
+     */
+    readonly size: InputSignal<KitDatepickerSize>;
+    /**
+     * An action which is emitted when datepicker value changed
+     */
+    changed: EventEmitter<Date>;
+    /**
+     * Defines a reference of the DatePicker component
+     */
+    datepicker: DatePickerComponent;
+    /**
+     * Defines settings for datepicker popup
+     */
+    readonly datepickerPopupSettings: PopupSettings;
+    /**
+     * An icon which will be used in a datepicker toggle button
+     */
+    readonly calendarIcon: KitSvgIcon;
+    constructor(elementRef: ElementRef, document: Document);
+    documentClick(event: Event): void;
+    onValueChange(value: Date): void;
+    onPopupToggle(): void;
+    onBlur(): void;
+    onChange: (value: Date) => void;
+    onTouched: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (_: Date) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDatepickerComponent, "kit-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "defaultDate": { "alias": "defaultDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "format": { "alias": "format"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "messageText": { "alias": "messageText"; "required": false; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, false, never>;
+}
+
+declare class KitDatepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDatepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitDatepickerModule, [typeof KitDatepickerComponent], [typeof i2$1.CommonModule, typeof i3$2.DateInputsModule, typeof KitInputLabelModule, typeof KitInputMessageModule, typeof KitSvgIconModule], [typeof KitDatepickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitDatepickerModule>;
+}
+
+interface KitProfileMenuItem {
+    title: string;
+    icon?: KitSvgIcon;
+    iconType?: KitSvgIconType;
+    link?: string;
+    cssClass?: string;
+    action?(): void;
+}
+
+declare class KitProfileMenuComponent {
+    /**
+     * Defines a list of menu items
+     */
+    menuItems: KitProfileMenuItem[];
+    /**
+     * Defines username that going to be displayed next to avatar and used in avatar as initials
+     */
+    userName?: string;
+    /**
+     * Defines company name that going to be displayed next to avatar
+     */
+    companyName?: string;
+    /**
+     * Defines the image source of the avatar
+     */
+    avatarImageSrc?: string;
+    popup: KitPopupComponent;
+    readonly KitAvatarSize: typeof KitAvatarSize;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitPopupAlignHorizontal: typeof KitPopupAlignHorizontal;
+    readonly KitSvgIconType: typeof KitSvgIconType;
+    onClick(item: KitProfileMenuItem): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitProfileMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitProfileMenuComponent, "kit-profile-menu", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "userName": { "alias": "userName"; "required": false; }; "companyName": { "alias": "companyName"; "required": false; }; "avatarImageSrc": { "alias": "avatarImageSrc"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KitTabComponent {
+    /**
+     * Defines the tab title
+     */
+    readonly title: InputSignal<string>;
+    /**
+     * Defines the icon which will be used with the tab title
+     */
+    icon?: KitSvgIcon;
+    /**
+     * Defines the icon type
+     */
+    iconType: KitSvgIconType;
+    /**
+     * Defines which tab will be selected when tabs are initially loaded
+     */
+    selected: boolean;
+    /**
+     * Defines which tab will be disabled
+     */
+    readonly disabled: InputSignal<boolean>;
+    /**
+     * Defines a reference to the tab title
+     */
+    kitTitleTemplate: TemplateRef<HTMLElement> | null;
+    /**
+     * Defines a reference to the tab content
+     */
+    kitTabContent: TemplateRef<HTMLElement> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTabComponent, "kit-tab", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["kitTitleTemplate", "kitTabContent"], never, false, never>;
+}
+
+declare enum KitTabsType {
+    TEXT = "text",
+    BUTTON = "button",
+    SEGMENTED = "segmented"
+}
+declare enum KitTabsSize {
+    LARGE = "large",
+    SMALL = "small"
+}
+
+interface KitTabsSelectEvent {
+    index: number;
+    title: string;
+    preventDefault(): void;
+}
+
+declare class KitTabsComponent implements OnInit, OnDestroy {
+    /**
+     * Defines the type of tabs
+     */
+    type: KitTabsType;
+    size: KitTabsSize;
+    /**
+     * Enables the tab animation
+     */
+    animate: boolean;
+    /**
+     * An action which is emitted when tab is selected
+     */
+    tabSelected: EventEmitter<KitTabsSelectEvent>;
+    /**
+     * Defines the reference to the tabs content
+     */
+    readonly tabs: Signal<readonly KitTabComponent[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    interceptInputKeys: (event: KeyboardEvent) => void;
+    onTabSelect(event: SelectEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTabsComponent, "kit-tabs", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, { "tabSelected": "tabSelected"; }, ["tabs"], never, false, never>;
+}
+
+declare class KitTitleTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTitleTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitTitleTemplateDirective, "[kitTitleTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitTabContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitTabContentDirective, "[kitTabContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitTabsModule, [typeof KitTabsComponent, typeof KitTabComponent], [typeof i2$1.CommonModule, typeof i4$1.LayoutModule, typeof KitSvgIconModule, typeof KitTitleTemplateDirective, typeof KitTabContentDirective], [typeof KitTabsComponent, typeof KitTabComponent, typeof KitTitleTemplateDirective, typeof KitTabContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitTabsModule>;
+}
+
+type KitCardLink = (string | number)[] | string | null;
+interface KitCard {
+    title: string;
+    titleIcon: KitSvgIcon;
+    label: string;
+    count: number;
+    buttonLabel: string;
+    link?: KitCardLink;
+    items?: KitCardItem[];
+    titleIconType?: KitSvgIconType;
+    buttonDisabled?: boolean;
+}
+interface KitCardItem {
+    label: string;
+    link: KitCardLink;
+    count?: number;
+    icon?: KitSvgIcon;
+    iconType?: KitSvgIconType;
+    tooltip?: string;
+    disabled?: boolean;
+}
+
+declare enum KitCardTheme {
+    DEFAULT = "default",
+    GREEN = "green",
+    PINK = "pink",
+    PURPLE = "purple",
+    ORANGE = "orange",
+    TEAL = "teal",
+    GREY = "grey"
+}
+
+declare class KitCardComponent {
+    /**
+     * Defines card data
+     */
+    data: KitCard | null;
+    /**
+     * Defines card color theme
+     */
+    theme: KitCardTheme;
+    /**
+     * Defines whether the items list will be expanded
+     */
+    itemsExpanded: boolean;
+    /**
+     * An action which is emitted when action button clicked
+     */
+    buttonClicked: EventEmitter<void>;
+    /**
+     * An action which is emitted when toggle button clicked
+     */
+    toggleClicked: EventEmitter<boolean>;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly KitButtonType: typeof KitButtonType;
+    readonly KitButtonKind: typeof KitButtonKind;
+    readonly KitTooltipPosition: typeof KitTooltipPosition;
+    toggleList(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCardComponent, "kit-card", never, { "data": { "alias": "data"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "itemsExpanded": { "alias": "itemsExpanded"; "required": false; }; }, { "buttonClicked": "buttonClicked"; "toggleClicked": "toggleClicked"; }, never, never, false, never>;
+}
+
+declare class KitCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitCardModule, [typeof KitCardComponent], [typeof i2$1.CommonModule, typeof KitSvgIconModule, typeof KitButtonModule, typeof i3$3.RouterLink, typeof KitTooltipDirective, typeof i2$1.NgClass], [typeof KitCardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitCardModule>;
+}
+
+interface KitShipmentCardData {
+    latestRequiredByDate: string | null;
+    vesselName: string | null;
+    destinationPort: string | null;
+    originPort: string | null;
+    reference: string | null;
+    containerMode: string | null;
+    state: string | null;
+    type: 'Air' | 'Sea' | 'Road' | null;
+    containerActionBtnLabel: string;
+    timelineActionBtnLabel: string;
+    containerItems: KitShipmentCardActionItem[];
+    timelineItems: KitShipmentCardActionItem[];
+}
+interface KitShipmentCardActionItem {
+    label: string;
+    value: string | null;
+}
+
+declare class KitShipmentCard {
+    readonly data: InputSignal<KitShipmentCardData>;
+    readonly selected: InputSignal<boolean>;
+    readonly headLabel: InputSignal<TemplateRef<unknown> | undefined>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    containersExpanded: boolean;
+    timelineExpanded: boolean;
+    get shipmentModeIcon(): KitSvgIcon.AIR | KitSvgIcon.SHIP | KitSvgIcon.LOGISTICS;
+    get timelineItems(): KitShipmentCardActionItem[];
+    get containerItems(): KitShipmentCardActionItem[];
+    showContainers(event: MouseEvent): void;
+    showTimeline(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitShipmentCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitShipmentCard, "kit-shipment-card", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "headLabel": { "alias": "headLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface KitBreadcrumbsItem {
+    text: string;
+    url: string;
+}
+
+declare class KitBreadcrumbsComponent {
+    /**
+     * Defines items that will be rendered as breadcrumbs
+     */
+    items: KitBreadcrumbsItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitBreadcrumbsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitBreadcrumbsComponent, "kit-breadcrumbs", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitBreadcrumbsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitBreadcrumbsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitBreadcrumbsModule, [typeof KitBreadcrumbsComponent], [typeof i2$1.CommonModule, typeof i3$3.RouterLink], [typeof KitBreadcrumbsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitBreadcrumbsModule>;
+}
+
+declare class KitBreadcrumbsService {
+    private readonly router;
+    private readonly translateService;
+    readonly breadcrumbs: WritableSignal<KitBreadcrumbsItem[]>;
+    private dataHandlers;
+    constructor(router: Router, translateService: TranslateService);
+    private initializeBreadcrumbs;
+    registerHandler(type: string, key: string, handler: (param: string) => string): void;
+    private updateBreadcrumbs;
+    private collectBreadcrumbs;
+    private replaceRouteParams;
+    private isDynamicBreadcrumb;
+    private getDynamicBreadcrumbText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitBreadcrumbsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitBreadcrumbsService>;
+}
+
+declare class KitGridColumnComponent {
+    /**
+     * Defines the field to which the column is bound
+     */
+    field: string;
+    /**
+     * Defines the title of the column
+     */
+    title: string;
+    /**
+     * Defines the column title icon
+     */
+    titleIcon?: KitSvgIcon;
+    /**
+     * Defines the column title icon type
+     */
+    titleIconType: KitSvgIconType;
+    /**
+     * Defines whether the column can be sorted by clicking on its title
+     */
+    sortable: boolean;
+    /**
+     * Defines the width of the column (in pixels)
+     */
+    width?: number;
+    /**
+     * Set the visibility of the column
+     */
+    hidden: boolean;
+    /**
+     * Defines the column cell template
+     */
+    cellTemplate?: TemplateRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridColumnComponent, "kit-grid-column", never, { "field": { "alias": "field"; "required": false; }; "title": { "alias": "title"; "required": false; }; "titleIcon": { "alias": "titleIcon"; "required": false; }; "titleIconType": { "alias": "titleIconType"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "width": { "alias": "width"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, {}, ["cellTemplate"], never, false, never>;
+}
+
+declare enum KitGridSortSettingsMode {
+    SINGLE = "single",
+    MULTIPLE = "multiple"
+}
+
+interface KitDataResult<T> {
+    data: T[];
+    total: number;
+}
+interface KitDataState {
+    skip?: number;
+    take?: number;
+    sort?: KitSortDescriptor[];
+    filter?: KitCompositeFilterDescriptor;
+}
+type KitCompositeFilterDescriptor = CompositeFilterDescriptor;
+type KitFilterDescriptor = FilterDescriptor;
+type KitSortDescriptor = SortDescriptor;
+
+interface KitGridSortSettings {
+    mode: KitGridSortSettingsMode;
+}
+interface KitGridDataStateChangeEvent {
+    skip: number;
+    take: number;
+    sort?: KitSortDescriptor[];
+}
+type KitGridPageChangeEvent = PageChangeEvent;
+type KitGridDetailExpandEvent = DetailExpandEvent;
+type KitGridDetailCollapseEvent = DetailCollapseEvent;
+type KitGridCellClickEvent = CellClickEvent;
+interface KitPDFOptions extends PDFOptions {
+    fileName?: string;
+    allPages?: boolean;
+    scale?: number;
+    paperSize?: PaperSize;
+}
+
+declare enum KitSortDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+declare enum KitFilterLogic {
+    AND = "and",
+    OR = "or"
+}
+declare enum KitFilterOperator {
+    EQ = "eq",
+    NEQ = "neq",
+    IS_NULL = "isnull",
+    IS_NOT_NULL = "isnotnull",
+    LT = "lt",
+    LTE = "lte",
+    GT = "gt",
+    GTE = "gte",
+    STARTS_WITH = "startswith",
+    ENDS_WITH = "endswith",
+    CONTAINS = "contains",
+    DOES_NOT_CONTAIN = "doesnotcontain",
+    IS_EMPTY = "isempty",
+    IS_NOT_EMPTY = "isnotempty"
+}
+
+declare class KitGridComponent<T> {
+    private readonly translateService;
+    /**
+     * Sets the data of the grid. Allows user to implement data operations manually
+     */
+    data?: T[] | KitDataResult<T>;
+    /**
+     * Sets the data of the grid. Allows user to implement data operations automatically
+     */
+    gridDataBinding?: T[];
+    /**
+     * Enables the sorting of the grid columns
+     */
+    sortable: KitGridSortSettings | boolean;
+    /**
+     * The descriptors by which the data will be sorted
+     */
+    sort: KitSortDescriptor[];
+    /**
+     * Enables the pager of the grid
+     */
+    pageable: boolean;
+    /**
+     * Defines the page size
+     */
+    pageSize?: number;
+    /**
+     * Defines the number of records to be skipped by the pager
+     */
+    skip: number;
+    /**
+     * Specifies if the loading indicator of the grid will be displayed
+     */
+    loading: boolean;
+    /**
+     * Function to determine if the detail template should be visible
+     */
+    detailTemplateShowIf: (dataItem: T) => boolean;
+    /**
+     * Function to determine if the caret of detail template should be disabled
+     */
+    detailTemplateExpandDisableIf: (dataItem: T) => boolean;
+    /**
+     * Flag to show or hide the footer row
+     */
+    showFooter: boolean;
+    /**
+     * Title to display in the first column of the footer row
+     */
+    footerTitle: string;
+    /**
+     * Data to display in the footer row
+     */
+    footerData?: Partial<Record<keyof T, T[keyof T]>>;
+    pdfOptions: KitPDFOptions;
+    pagerButtonCount: number;
+    showPageSize: boolean;
+    readonly pagerInfoText: InputSignal<string>;
+    readonly resizable: InputSignal<boolean>;
+    readonly gridDetailTemplate: InputSignal<TemplateRef<HTMLElement> | undefined>;
+    /**
+     * An action which is emitted when the page of the grid is changed
+     */
+    pageChanged: EventEmitter<KitGridPageChangeEvent>;
+    /**
+     * An action which is emitted once the sorting of the grid is changed
+     */
+    sortChanged: EventEmitter<KitSortDescriptor[]>;
+    /**
+     * An action which is emitted when the data state of the grid is changed
+     */
+    dataStateChanged: EventEmitter<KitGridDataStateChangeEvent>;
+    /**
+     * An action which is emitted when the master row is expanded
+     */
+    detailExpanded: EventEmitter<KitGridDetailExpandEvent>;
+    /**
+     * An action which is emitted when the master row is collapsed
+     */
+    detailCollapsed: EventEmitter<KitGridDetailCollapseEvent>;
+    /**
+     * An action which is emitted when user clicks a cell
+     */
+    cellClicked: EventEmitter<KitGridCellClickEvent>;
+    excelExport: EventEmitter<ExcelExportEvent>;
+    gridComponent: GridComponent | null;
+    readonly columnsContent: Signal<readonly KitGridColumnComponent[]>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitSortDirection: typeof KitSortDirection;
+    readonly columns: WritableSignal<KitGridColumnComponent[] | undefined>;
+    expandedRows: T[];
+    constructor(translateService: TranslateService);
+    onDataStateChange(event: KitGridDataStateChangeEvent): void;
+    onSortChange(event: KitSortDescriptor[]): void;
+    getSortingDirection(columnField: string): string | null;
+    isColumnSortable(column: KitGridColumnComponent): boolean;
+    onDetailExpand(event: KitGridDetailExpandEvent): void;
+    onDetailCollapse(event: KitGridDetailCollapseEvent): void;
+    onPageChange(event: KitGridPageChangeEvent): void;
+    onCellClick(event: KitGridCellClickEvent): void;
+    getCssRowClass: (context: RowClassArgs) => Record<string, boolean>;
+    getPagerSettings(): boolean | PagerSettings;
+    saveAsPDF(): void;
+    saveAsExcel(): void;
+    private collapseAllRows;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridComponent<any>, "kit-grid", never, { "data": { "alias": "data"; "required": false; }; "gridDataBinding": { "alias": "gridDataBinding"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "pageable": { "alias": "pageable"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "skip": { "alias": "skip"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "detailTemplateShowIf": { "alias": "detailTemplateShowIf"; "required": false; }; "detailTemplateExpandDisableIf": { "alias": "detailTemplateExpandDisableIf"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "footerTitle": { "alias": "footerTitle"; "required": false; }; "footerData": { "alias": "footerData"; "required": false; }; "pdfOptions": { "alias": "pdfOptions"; "required": false; }; "pagerButtonCount": { "alias": "pagerButtonCount"; "required": false; }; "showPageSize": { "alias": "showPageSize"; "required": false; }; "pagerInfoText": { "alias": "pagerInfoText"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "gridDetailTemplate": { "alias": "gridDetailTemplate"; "required": false; "isSignal": true; }; }, { "pageChanged": "pageChanged"; "sortChanged": "sortChanged"; "dataStateChanged": "dataStateChanged"; "detailExpanded": "detailExpanded"; "detailCollapsed": "detailCollapsed"; "cellClicked": "cellClicked"; "excelExport": "excelExport"; }, ["columnsContent"], never, false, never>;
+}
+
+declare class KitGridCellTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridCellTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitGridCellTemplateDirective, "[kitGridCellTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitGridDetailTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridDetailTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitGridDetailTemplateDirective, "[kitGridDetailTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitGridModule, [typeof KitGridComponent, typeof KitGridColumnComponent], [typeof i2$1.CommonModule, typeof i4$2.GridModule, typeof KitSvgIconModule, typeof KitGridCellTemplateDirective, typeof KitGridDetailTemplateDirective, typeof i4$2.ExcelModule, typeof i4$2.PDFModule], [typeof KitGridComponent, typeof KitGridColumnComponent, typeof KitGridCellTemplateDirective, typeof KitGridDetailTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitGridModule>;
+}
+
+declare class KitTileLayoutItemComponent {
+    template: TemplateRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTileLayoutItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTileLayoutItemComponent, "kit-tilelayout-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+type KitTileLayoutColumnsConfig = Record<number, number>;
+
+declare class KitTileLayoutComponent implements AfterContentInit {
+    tileItems: QueryList<KitTileLayoutItemComponent>;
+    /**
+     * Configuration object for the number of columns at different screen widths.
+     * Example: { 1440: 5, 1024: 3, 0: 2 }
+     */
+    columnsConfig: KitTileLayoutColumnsConfig;
+    columns: number;
+    ngAfterContentInit(): void;
+    onResize(): void;
+    setColumnsBasedOnScreenSize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTileLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTileLayoutComponent, "kit-tilelayout", never, { "columnsConfig": { "alias": "columnsConfig"; "required": false; }; }, {}, ["tileItems"], never, false, never>;
+}
+
+declare class KitTileLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTileLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitTileLayoutModule, [typeof KitTileLayoutComponent, typeof KitTileLayoutItemComponent], [typeof i2$1.CommonModule, typeof i4$1.TileLayoutModule], [typeof KitTileLayoutComponent, typeof KitTileLayoutItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitTileLayoutModule>;
+}
+
+declare class KitScrollNavigationSectionComponent implements OnChanges {
+    title: string;
+    buttonState?: KitButtonState;
+    buttonIcon?: KitSvgIcon;
+    tooltipText?: string;
+    badgeCount?: number;
+    propertyChanged?: EventEmitter<void>;
+    sectionTemplate: TemplateRef<HTMLElement> | null;
+    sectionContent: ElementRef | null;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitScrollNavigationSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitScrollNavigationSectionComponent, "kit-scroll-navigation-section", never, { "title": { "alias": "title"; "required": false; }; "buttonState": { "alias": "buttonState"; "required": false; }; "buttonIcon": { "alias": "buttonIcon"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "badgeCount": { "alias": "badgeCount"; "required": false; }; }, { "propertyChanged": "propertyChanged"; }, never, ["*"], true, never>;
+}
+
+interface KitCollapsedListItem {
+    text: string;
+    value: string;
+    icon?: KitSvgIcon;
+    state?: KitButtonState;
+    tooltipText?: string;
+    badgeCount?: number;
+}
+
+declare enum KitCollapsedListDropdownAlign {
+    INLINE = "inline",
+    END = "end"
+}
+
+declare class KitCollapsedListComponent<T extends KitCollapsedListItem> implements AfterViewInit, OnChanges, OnDestroy {
+    readonly itemList: InputSignal<T[]>;
+    readonly lineHeight: InputSignal<number>;
+    readonly dropdownDefaultValueText: InputSignal<string>;
+    readonly gap: InputSignal<number>;
+    readonly disableActions: InputSignal<boolean>;
+    readonly itemTemplate: InputSignal<TemplateRef<HTMLTemplateElement> | undefined>;
+    readonly dropdownFooterTemplate: InputSignal<TemplateRef<HTMLTemplateElement> | undefined>;
+    readonly dropdownItemTemplate: InputSignal<TemplateRef<HTMLTemplateElement> | undefined>;
+    readonly dropdownNoDataTemplate: InputSignal<TemplateRef<HTMLTemplateElement> | undefined>;
+    readonly appendTo: InputSignal<PopupSettings['appendTo']>;
+    readonly alwaysShowDropdown: InputSignal<boolean>;
+    readonly dropdownAlign: InputSignal<KitCollapsedListDropdownAlign>;
+    readonly onSelectItem: OutputEmitterRef<T>;
+    readonly wrapper: Signal<ElementRef<HTMLElement>>;
+    readonly measureItem: Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly dropdown: Signal<ElementRef<HTMLElement> | undefined>;
+    readonly defaultSelectedItem: Signal<KitCollapsedListItem>;
+    readonly shouldShowDropdown: WritableSignal<boolean>;
+    readonly dropdownItems: WritableSignal<KitCollapsedListItem[]>;
+    readonly visibleItems: WritableSignal<T[]>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitDropdownSize: typeof KitDropdownSize;
+    protected _selectedItem: WritableSignal<KitCollapsedListItem>;
+    private resizeObserver;
+    readonly dropdownSelectedItem: Signal<KitCollapsedListItem>;
+    ngAfterViewInit(): void;
+    ngOnChanges({ itemList, gap, dropdownDefaultValueText }: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get selectedItem(): KitCollapsedListItem;
+    get popupSettings(): PopupSettings;
+    setSelectedItem(item: T): void;
+    selectionChange(item: T): void;
+    initResizeObserver(): void;
+    private resize;
+    private calculateResizeParams;
+    private setResizeParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitCollapsedListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitCollapsedListComponent<any>, "kit-collapsed-list", never, { "itemList": { "alias": "itemList"; "required": true; "isSignal": true; }; "lineHeight": { "alias": "lineHeight"; "required": false; "isSignal": true; }; "dropdownDefaultValueText": { "alias": "dropdownDefaultValueText"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "disableActions": { "alias": "disableActions"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "dropdownFooterTemplate": { "alias": "dropdownFooterTemplate"; "required": false; "isSignal": true; }; "dropdownItemTemplate": { "alias": "dropdownItemTemplate"; "required": false; "isSignal": true; }; "dropdownNoDataTemplate": { "alias": "dropdownNoDataTemplate"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "alwaysShowDropdown": { "alias": "alwaysShowDropdown"; "required": false; "isSignal": true; }; "dropdownAlign": { "alias": "dropdownAlign"; "required": false; "isSignal": true; }; }, { "onSelectItem": "onSelectItem"; }, never, never, true, never>;
+}
+
+declare class KitScrollNavigationComponent implements AfterViewInit {
+    readonly isNavigationBtnDisabled: InputSignal<boolean>;
+    readonly dropdownDefaultText: InputSignal<string>;
+    sections: QueryList<KitScrollNavigationSectionComponent> | null;
+    content: ElementRef | null;
+    collapsedList: KitCollapsedListComponent<KitCollapsedListItem> | null;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitButtonState: typeof KitButtonState;
+    readonly kitButtonIconPosition: typeof KitButtonIconPosition;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    readonly kitBadgeTheme: typeof KitBadgeTheme;
+    readonly kitCollapsedListDropdownAlign: typeof KitCollapsedListDropdownAlign;
+    protected readonly collapsedListItems: WritableSignal<KitCollapsedListItem[]>;
+    private disableScrollUpdates;
+    get currentVisibleItem(): KitCollapsedListItem | null;
+    ngAfterViewInit(): void;
+    onSectionScroll(): void;
+    scrollToSection(selectedItem: KitCollapsedListItem): void;
+    private updateListItems;
+    private handleSectionChanges;
+    private setLastSectionMinHeight;
+    private calculateLastSectionMinHeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitScrollNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitScrollNavigationComponent, "kit-scroll-navigation", never, { "isNavigationBtnDisabled": { "alias": "isNavigationBtnDisabled"; "required": false; "isSignal": true; }; "dropdownDefaultText": { "alias": "dropdownDefaultText"; "required": false; "isSignal": true; }; }, {}, ["sections"], never, true, never>;
+}
+
+declare class KitEntitySectionComponent {
+    readonly isActive: InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitEntitySectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitEntitySectionComponent, "kit-entity-section", never, { "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; }, {}, never, ["[header]", "[content]"], true, never>;
+}
+
+declare class KitEntitySectionContainerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitEntitySectionContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitEntitySectionContainerComponent, "kit-entity-section-container", never, {}, {}, never, ["[title]", "*"], true, never>;
+}
+
+declare class KitEntityTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitEntityTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitEntityTitleComponent, "kit-entity-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class KitEntityTitleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitEntityTitleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitEntityTitleModule, [typeof KitEntityTitleComponent], [typeof i2$1.CommonModule], [typeof KitEntityTitleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitEntityTitleModule>;
+}
+
+declare enum KitTimelineTheme {
+    PURPLE = "purple",
+    GREEN = "green",
+    BLUE = "blue",
+    GREY = "grey",
+    TEAL = "teal",
+    PINK = "pink",
+    SUCCESS = "success",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+declare enum KitTimelineType {
+    CONFIRMED = "confirmed",
+    DEPARTURE = "departure",
+    ARRIVAL = "arrival"
+}
+
+interface KitTimelineItem {
+    title: string;
+    subTitle: string;
+    date: KitTimelineItemDate[];
+    theme?: KitTimelineTheme;
+    textBadge?: string;
+    countBadge?: number;
+    transportationType?: string;
+    originalPort?: string;
+    destinationPort?: string;
+    transitMode?: string;
+    icon?: KitSvgIcon;
+    iconType?: KitSvgIconType;
+}
+interface KitTimelineItemDate {
+    label: string;
+    value: string;
+}
+
+declare class KitTimelineComponent {
+    /**
+     * Defines a list of items which will be rendered as timeline cards
+     */
+    items: KitTimelineItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTimelineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTimelineComponent, "kit-timeline", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KitTimelineCardComponent {
+    item: KitTimelineItem | null;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTimelineCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTimelineCardComponent, "kit-timeline-card", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KitFileCardMessagesComponent {
+    /**
+     * Defines a value to use as "Create Date" label
+     */
+    createDate: string;
+    /**
+     * Defines a value to use as "Created By" label
+     */
+    createdBy: string;
+    /**
+     * Defines a value to use as "View" button label
+     */
+    viewButtonLabel: string;
+    /**
+     * Defines a value to use as "Download" button label
+     */
+    downloadButtonLabel: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitFileCardMessagesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitFileCardMessagesComponent, "kit-file-card-custom-messages", never, { "createDate": { "alias": "createDate"; "required": false; }; "createdBy": { "alias": "createdBy"; "required": false; }; "viewButtonLabel": { "alias": "viewButtonLabel"; "required": false; }; "downloadButtonLabel": { "alias": "downloadButtonLabel"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class KitFileCardComponent {
+    /**
+     * Defines a value that will be used as a card title
+     */
+    title: string;
+    /**
+     * Defines a value that will be used as the card type css class
+     */
+    type?: string;
+    /**
+     * Defines a value that will be used as a card label
+     */
+    label: string;
+    /**
+     * Defines a value that will be used to render card icon
+     */
+    fileType: string;
+    /**
+     * Defines a value that will be used as a card date
+     */
+    date: string;
+    /**
+     * Defines a value that will be used as a card name
+     */
+    name: string;
+    /**
+     * An action which is emitted when view button clicked
+     */
+    viewButtonClicked: EventEmitter<void>;
+    /**
+     * An action which is emitted when download button clicked
+     */
+    downloadButtonClicked: EventEmitter<void>;
+    customMessages: KitFileCardMessagesComponent | null;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonIconPosition: typeof KitButtonIconPosition;
+    readonly dateFormat: string;
+    readonly createDateLabel: string;
+    readonly createdByLabel: string;
+    readonly downloadButtonLabel: string;
+    readonly viewButtonLabel: string;
+    getFileIconByExtension(extension: string): string | null;
+    hasViewFileButton(fileType: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitFileCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitFileCardComponent, "kit-file-card", never, { "title": { "alias": "title"; "required": false; }; "type": { "alias": "type"; "required": false; }; "label": { "alias": "label"; "required": false; }; "fileType": { "alias": "fileType"; "required": false; }; "date": { "alias": "date"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "viewButtonClicked": "viewButtonClicked"; "downloadButtonClicked": "downloadButtonClicked"; }, ["customMessages"], ["*"], false, never>;
+}
+
+declare class KitFileCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitFileCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitFileCardModule, [typeof KitFileCardComponent, typeof KitFileCardMessagesComponent], [typeof i2$1.CommonModule, typeof KitButtonModule, typeof KitSvgIconModule, typeof i2$1.DatePipe], [typeof KitFileCardComponent, typeof KitFileCardMessagesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitFileCardModule>;
+}
+
+declare enum KitDataFieldState {
+    DEFAULT = "default",
+    WARNING = "warning"
+}
+
+declare class KitDataFieldComponent {
+    readonly label: InputSignal<string>;
+    readonly value: InputSignal<string | number | null | undefined>;
+    readonly state: InputSignal<KitDataFieldState>;
+    readonly tooltipText: InputSignal<string | undefined>;
+    readonly icon: InputSignal<KitSvgIcon | undefined>;
+    readonly iconType: InputSignal<KitSvgIconType | undefined>;
+    readonly defaultValue: string;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitDataFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitDataFieldComponent, "kit-data-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "tooltipText": { "alias": "tooltipText"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconType": { "alias": "iconType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KitSearchBarComponent {
+    placeholder: string;
+    searchButtonLabel: string;
+    closeButtonLabel: string;
+    readonly searchString: InputSignal<string | undefined>;
+    changed: EventEmitter<string>;
+    searchButtonClick: EventEmitter<void>;
+    closeButtonClick: EventEmitter<void>;
+    searchTextboxElementRef: ElementRef;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    readonly KitButtonIconPosition: typeof KitButtonIconPosition;
+    readonly kitTextboxSize: typeof KitTextboxSize;
+    readonly searchVisible: WritableSignal<boolean>;
+    constructor();
+    onSearchChange(value: string): void;
+    onSearchButtonClick(): void;
+    clearSearch(): void;
+    onCloseButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSearchBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSearchBarComponent, "kit-search-bar", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "searchButtonLabel": { "alias": "searchButtonLabel"; "required": false; }; "closeButtonLabel": { "alias": "closeButtonLabel"; "required": false; }; "searchString": { "alias": "searchString"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "searchButtonClick": "searchButtonClick"; "closeButtonClick": "closeButtonClick"; }, never, never, false, never>;
+}
+
+declare class KitSearchBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSearchBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KitSearchBarModule, [typeof KitSearchBarComponent], [typeof i2$1.CommonModule, typeof KitButtonModule, typeof KitTextboxModule, typeof KitSvgIconModule], [typeof KitSearchBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KitSearchBarModule>;
+}
+
+interface GlobalSearchResult {
+    name: string;
+    items: GlobalSearchLineItem[];
+    total: number;
+    categoryLink: string[];
+}
+interface GlobalSearchLineItem {
+    title: string | null;
+    subtitle: string | null;
+    link?: string[];
+    dates: {
+        firstDate: {
+            label: string | null;
+            value: string | null;
+        };
+        secondDate: {
+            label: string | null;
+            value: string | null;
+        };
+    } | null;
+    routePath: {
+        from: string | null;
+        to: string | null;
+        type: 'Air' | 'Road' | 'Sea' | 'Rail' | null;
+        containerMode?: string | null;
+    } | null;
+    status?: string;
+    additionalContent: MatchResult[];
+}
+interface GlobalSearchPrompt {
+    label: string;
+    link: string[];
+    permission: string;
+}
+interface MatchResult {
+    path: string;
+    key: string;
+    value: unknown;
+    translateKey: string;
+}
+
+declare class KitGlobalSearchComponent implements OnInit {
+    private readonly router;
+    private readonly store;
+    readonly searchFn: InputSignal<(searchText: string) => Observable<(GlobalSearchResult | null)[]>>;
+    readonly displayedLineItemsNumber: InputSignal<number>;
+    readonly prompts: InputSignal<GlobalSearchPrompt[]>;
+    readonly textbox: Signal<TextBoxComponent>;
+    readonly anchor: Signal<ElementRef>;
+    readonly popup: Signal<KitPopupComponent | undefined>;
+    readonly container: Signal<ViewContainerRef>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitTextboxSize: typeof KitTextboxSize;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    readonly kitPillTheme: typeof KitPillTheme;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly dateFormat: string;
+    readonly popupClass: string;
+    readonly searchResults: WritableSignal<(GlobalSearchResult | null)[]>;
+    searchValue: string;
+    readonly showPropmts: WritableSignal<boolean>;
+    readonly userPermissions$: Observable<string[]>;
+    documentClick(event: Event): void;
+    constructor(router: Router, store: Store);
+    ngOnInit(): void;
+    get isPopupOpen(): boolean;
+    clearSearch(): void;
+    openPopup(): void;
+    navigate(link: string[] | undefined): void;
+    onSelectPrompt(prompt: GlobalSearchPrompt): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGlobalSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGlobalSearchComponent, "kit-global-search", never, { "searchFn": { "alias": "searchFn"; "required": true; "isSignal": true; }; "displayedLineItemsNumber": { "alias": "displayedLineItemsNumber"; "required": false; "isSignal": true; }; "prompts": { "alias": "prompts"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const mapGlobalSearchResult: <T>(store: Store, requiredPermission: string, dataFetcher: () => Observable<{
+    total: number;
+    data: T[];
+}>, categoryName: string, categoryLink: string[], itemMapper: (item: T) => GlobalSearchLineItem) => Observable<GlobalSearchResult | null>;
+declare const findMatches: <T extends object>(obj: T, translatePrefix: string, excludedKeys?: string[], search?: string) => MatchResult[];
+
+declare class KitEmptySectionComponent {
+    text: string;
+    readonly KitSvgIcon: typeof KitSvgIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitEmptySectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitEmptySectionComponent, "kit-empty-section", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KitSortableComponent<T> {
+    /**
+     * An items list which is going to be rendered as sortable items
+     */
+    items: T[];
+    /**
+     * Defines the number of columns of the component
+     */
+    columnCount?: number;
+    /**
+     * Defines the css class which is applied to each item
+     */
+    itemClass?: string;
+    /**
+     * Defines the css class which is applied to the active item.
+     */
+    activeItemClass?: string;
+    zone?: string;
+    emptyItemClass?: string;
+    readonly onDragEnd: OutputEmitterRef<DataMoveEvent>;
+    readonly itemTemplate: Signal<TemplateRef<HTMLElement> | undefined>;
+    get columnsCount(): number | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSortableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSortableComponent<any>, "kit-sortable", never, { "items": { "alias": "items"; "required": false; }; "columnCount": { "alias": "columnCount"; "required": false; }; "itemClass": { "alias": "itemClass"; "required": false; }; "activeItemClass": { "alias": "activeItemClass"; "required": false; }; "zone": { "alias": "zone"; "required": false; }; "emptyItemClass": { "alias": "emptyItemClass"; "required": false; }; }, { "onDragEnd": "onDragEnd"; }, ["itemTemplate"], never, true, never>;
+}
+
+declare const kitDataStateToODataString: (state: KitDataState, utcDates?: boolean) => string;
+
+declare class KitPageLayoutComponent implements AfterContentInit {
+    private readonly kitNavigationMenuService;
+    readonly sidebarContainer: Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly topBarContainer: Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly isMenuCollapsed: WritableSignal<boolean>;
+    readonly hasMenuSelected: WritableSignal<boolean>;
+    hasSidebar: boolean;
+    hasTopBar: boolean;
+    constructor(kitNavigationMenuService: KitNavigationMenuService);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitPageLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitPageLayoutComponent, "kit-page-layout", never, {}, {}, never, ["[sidebar]", "[topBar]", "[content]"], true, never>;
+}
+
+declare const KIT_BASE_PATH: InjectionToken<string>;
+
+declare class KitTranslateService {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    registerTranslations(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitTranslateService>;
+}
+
+declare abstract class AbstractPayloadAction<T> {
+    readonly payload: T;
+    constructor(payload: T);
+}
+
+interface KitFilterValue {
+    logic: KitFilterLogic;
+    filters: KitFilterDescriptor[];
+}
+interface KitFilterItem {
+    title: string;
+    field: string;
+    readonly?: boolean;
+    type?: KitFilterType;
+    value: KitFilterValue | null;
+}
+declare enum KitFilterType {
+    CHECKBOX = "checkbox",
+    RADIO = "radio",
+    DATE = "date",
+    TEXT = "text",
+    NUMERIC = "numeric",
+    NULL = "null",
+    GUID = "guid"
+}
+interface KitFilterListOption<T = string> {
+    title: string;
+    value: T;
+    checked: boolean;
+}
+interface KitFilterListConfigValue<T> {
+    items: KitFilterListOption<T>[];
+    translateKeyPrefix: string;
+    guidField?: string;
+}
+type KitFilterListConfig = Record<string, KitFilterListConfigValue<string | boolean | number>>;
+
+type KitGridColumnType = 'date' | 'number' | 'boolean' | 'string' | 'dateTime' | 'dateLocal' | 'dateTimeLocal' | 'time';
+interface KitGridColumnConfig {
+    field: string;
+    title: string;
+    sortable: boolean;
+    hidden: boolean;
+    type: KitGridColumnType;
+    width?: number;
+    filterType?: KitFilterType;
+    excelFormat?: string;
+}
+interface KitGridDataState {
+    skip: number;
+    take: number;
+    sort: KitSortDescriptor[];
+    filter: KitFilterItem[];
+    columns: KitGridColumnConfig[];
+    search?: string;
+}
+
+declare class SetGridSkip extends AbstractPayloadAction<number> {
+    static readonly type: string;
+}
+declare class SetGridTake extends AbstractPayloadAction<number> {
+    static readonly type: string;
+}
+declare class SetGridSearch extends AbstractPayloadAction<string | undefined> {
+    static readonly type: string;
+}
+declare class SetGridSort extends AbstractPayloadAction<KitSortDescriptor[]> {
+    static readonly type: string;
+}
+declare class SetGridColumns extends AbstractPayloadAction<KitGridColumnConfig[]> {
+    static readonly type: string;
+}
+declare class AddGridFilter extends AbstractPayloadAction<KitFilterItem> {
+    static readonly type: string;
+}
+declare class RemoveGridFilter extends AbstractPayloadAction<string> {
+    static readonly type: string;
+}
+declare class UpdateGridFilter extends AbstractPayloadAction<KitFilterItem> {
+    static readonly type: string;
+}
+declare class SetGridFilters extends AbstractPayloadAction<KitFilterItem[]> {
+    static readonly type: string;
+}
+
+declare const KIT_GRID_STATE_TOKEN: StateToken<KitGridDataState>;
+declare class KitGridState {
+    setGridSkip(ctx: StateContext<KitGridDataState>, action: SetGridSkip): void;
+    setGridTake(ctx: StateContext<KitGridDataState>, action: SetGridTake): void;
+    setGridSearch(ctx: StateContext<KitGridDataState>, action: SetGridSearch): void;
+    removeGridSearch(ctx: StateContext<KitGridDataState>): void;
+    setGridSort(ctx: StateContext<KitGridDataState>, action: SetGridSort): void;
+    setGridColumns(ctx: StateContext<KitGridDataState>, action: SetGridColumns): void;
+    addGridFilter(ctx: StateContext<KitGridDataState>, action: AddGridFilter): Observable<KitFilterItem[]>;
+    removeGridFilter(ctx: StateContext<KitGridDataState>, action: RemoveGridFilter): Observable<KitFilterItem[]>;
+    updateGridFilter(ctx: StateContext<KitGridDataState>, action: UpdateGridFilter): Observable<KitFilterItem[]>;
+    setGridFilters(ctx: StateContext<KitGridDataState>, action: SetGridFilters): Observable<KitFilterItem[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitGridState>;
+}
+
+type KitGridColumns = Record<string, KitGridColumn>;
+interface KitGridColumn {
+    name: string;
+    type: 'number' | 'string' | 'date' | 'boolean';
+}
+interface KitGridDataResult<T> {
+    results: KitDataResult<T>;
+    loading: boolean;
+}
+
+declare const kitBuildGridColumn: (field: string, title: string, type: KitGridColumnType, sortable?: boolean, hidden?: boolean, width?: number, filterType?: KitFilterType, excelFormat?: string) => KitGridColumnConfig;
+declare const kitBuildGridDataResults: <T>(data: T[], loading: boolean, total?: number) => KitGridDataResult<T>;
+declare const kitBuildSortString: (sort?: KitSortDescriptor[]) => string | undefined;
+
+declare class KitGridUrlStateService {
+    private readonly activatedRoute;
+    private readonly router;
+    constructor(activatedRoute: ActivatedRoute, router: Router);
+    getGridStateFromUrl(): KitGridDataState;
+    setGridStateToUrl(state: KitGridDataState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridUrlStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitGridUrlStateService>;
+}
+
+interface ApiResponseState<T> {
+    loading: boolean;
+    data: T;
+    total?: number;
+}
+
+interface KitGridViewsFetchPayload {
+    group: string;
+    defaultItems?: KitGridView[];
+}
+interface KitViewsState {
+    views: KitGridView[];
+    config: KitGridView | null;
+    selectedView: KitGridView | null;
+}
+declare enum KitGridViewType {
+    SYSTEM = "system",
+    USER = "user",
+    CONFIG = "config"
+}
+interface KitGridViewState {
+    sort?: KitSortDescriptor[];
+    filter?: KitFilterItem[];
+    columns?: KitGridViewColumn[];
+    config?: KitGridView[];
+}
+interface KitGridView {
+    title: string;
+    group: string | null;
+    type: KitGridViewType;
+    hidden?: boolean;
+    viewState?: KitGridViewState;
+}
+interface KitGridViewColumn {
+    field: string;
+    hidden: boolean;
+}
+
+interface KitGridViewListItem extends KitCollapsedListItem, KitGridView {
+}
+
+declare class KitGridViewsComponent implements OnInit, OnDestroy {
+    private readonly store;
+    private readonly activatedRoute;
+    private readonly router;
+    private readonly destroyRef;
+    private readonly titleCasePipe;
+    private readonly kitDialogService;
+    private readonly translateService;
+    private readonly viewContainerRef;
+    private readonly kitGridUrlStateService;
+    readonly viewGroup: InputSignal<string>;
+    readonly viewConfigGroup: InputSignal<string>;
+    readonly defaultColumns: InputSignal<KitGridColumnConfig[]>;
+    readonly defaultViewName: InputSignal<string>;
+    readonly defaultSorting: InputSignal<KitSortDescriptor[]>;
+    readonly systemViews: InputSignal<KitGridView[]>;
+    readonly viewChanged: OutputEmitterRef<void>;
+    readonly anchor: Signal<ElementRef | undefined>;
+    readonly collapsedList: Signal<KitCollapsedListComponent<KitGridViewListItem> | undefined>;
+    readonly createNewViewPopup: Signal<KitPopupComponent | undefined>;
+    readonly isViewSaving: WritableSignal<boolean>;
+    readonly createNewViewName: WritableSignal<string>;
+    readonly viewsState$: Observable<ApiResponseState<KitViewsState>>;
+    readonly views$: Observable<KitGridView[]>;
+    readonly views: Signal<KitGridView[]>;
+    readonly collapsedListItems: WritableSignal<KitGridViewListItem[]>;
+    readonly viewsAutocompleteItems$: Observable<KitAutocompleteItem<string>[]>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    readonly gridViewType: typeof KitGridViewType;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitButtonIconPosition: typeof KitButtonIconPosition;
+    readonly kitTextboxState: typeof KitTextboxState;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    readonly kitCollapsedListDropdownAlign: typeof KitCollapsedListDropdownAlign;
+    readonly selectedView: Signal<KitGridView | null>;
+    readonly collapsedListDropdownText: WritableSignal<string>;
+    readonly skipQueryParamsUpdate: WritableSignal<boolean>;
+    readonly needToResetQueryParams: WritableSignal<boolean>;
+    constructor(store: Store, activatedRoute: ActivatedRoute, router: Router, destroyRef: DestroyRef, titleCasePipe: TitleCasePipe, kitDialogService: KitDialogService, translateService: TranslateService, viewContainerRef: ViewContainerRef, kitGridUrlStateService: KitGridUrlStateService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get isViewNameValid(): boolean;
+    get inputMessage(): string;
+    get defaultGridState(): KitGridDataState;
+    onSelectView(selectedView: KitGridViewListItem): void;
+    openViewsManagerModal(): void;
+    onViewCreate(): void;
+    onCreateViewPopupToggle(): void;
+    resetQueryParams(): void;
+    private fetchViews;
+    private handleViewsOnRouteChange;
+    private handelCollapsedListItems;
+    private handleSelectedView;
+    private handleViewChange;
+    private updateGridState;
+    private getCollapsedListItem;
+    private navigateToView;
+    private buildGridState;
+    private buildUrlParamsFromView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridViewsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridViewsComponent, "kit-grid-views", never, { "viewGroup": { "alias": "viewGroup"; "required": true; "isSignal": true; }; "viewConfigGroup": { "alias": "viewConfigGroup"; "required": true; "isSignal": true; }; "defaultColumns": { "alias": "defaultColumns"; "required": true; "isSignal": true; }; "defaultViewName": { "alias": "defaultViewName"; "required": true; "isSignal": true; }; "defaultSorting": { "alias": "defaultSorting"; "required": true; "isSignal": true; }; "systemViews": { "alias": "systemViews"; "required": true; "isSignal": true; }; }, { "viewChanged": "viewChanged"; }, never, never, true, never>;
+}
+
+declare class FetchGridViews extends AbstractPayloadAction<KitGridViewsFetchPayload> {
+    static readonly type: string;
+}
+declare class AddGridView extends AbstractPayloadAction<KitGridView> {
+    static readonly type: string;
+}
+declare class RemoveGridView extends AbstractPayloadAction<KitGridView> {
+    static readonly type: string;
+}
+declare class SetGridViews extends AbstractPayloadAction<KitGridView[]> {
+    static readonly type: string;
+}
+declare class FetchGridViewsConfig extends AbstractPayloadAction<string> {
+    static readonly type: string;
+}
+declare class UpdateGridViewsConfig extends AbstractPayloadAction<KitGridView> {
+    static readonly type: string;
+}
+declare class SetSelectedView extends AbstractPayloadAction<KitGridView> {
+    static readonly type: string;
+}
+
+interface SettingView {
+    key: string;
+    value?: string;
+    group: string | null;
+}
+interface SettingValue {
+    value?: string;
+    group: string | null;
+}
+
+declare class KitSettingsApiService {
+    private readonly httpClient;
+    private readonly basePath;
+    constructor(httpClient: HttpClient, basePath: string);
+    getSettingsByGroup(group: string): Observable<SettingView[]>;
+    setSettingByKey(key: string, settingValue: SettingValue): Observable<SettingValue>;
+    deleteSettingByGroupAndKey(key: string, group: string): Observable<null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSettingsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitSettingsApiService>;
+}
+
+declare class KitGridViewsState {
+    private readonly settingsService;
+    constructor(settingsService: KitSettingsApiService);
+    fetchGridViews(ctx: StateContext<ApiResponseState<KitViewsState>>, action: FetchGridViews): Observable<KitGridView[]>;
+    addGridView(ctx: StateContext<ApiResponseState<KitViewsState>>, action: AddGridView): Observable<SettingValue>;
+    removeGridView(ctx: StateContext<ApiResponseState<KitViewsState>>, action: RemoveGridView): Observable<null>;
+    setGridViews(ctx: StateContext<ApiResponseState<KitViewsState>>, action: SetGridViews): Observable<KitGridView[]>;
+    fetchGridViewsConfig(ctx: StateContext<ApiResponseState<KitViewsState>>, action: FetchGridViewsConfig): Observable<KitGridView[]>;
+    updateGridViewsConfig(ctx: StateContext<ApiResponseState<KitViewsState>>, action: UpdateGridViewsConfig): Observable<SettingValue>;
+    setSelectedView(ctx: StateContext<ApiResponseState<KitViewsState>>, action: SetSelectedView): Observable<KitGridView>;
+    static getViews(): (gridViewsState: ApiResponseState<KitViewsState>) => KitGridView[];
+    private hasUserView;
+    static selectedView(state: ApiResponseState<KitViewsState>): KitGridView | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridViewsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitGridViewsState>;
+}
+
+declare const kitEncodeViewNameToUrl: (name: string) => string;
+
+declare enum KitUserSettingKeys {
+    ExpandNotesPanel = "expandNotesPanel"
+}
+
+declare class KitUserSettingsComponent {
+    private readonly store;
+    private readonly kitBreadcrumbsService;
+    readonly breadcrumbs: WritableSignal<KitBreadcrumbsItem[]>;
+    readonly userSettings$: Observable<Record<string, string>>;
+    readonly userSettingsKeys: typeof KitUserSettingKeys;
+    constructor(store: Store, kitBreadcrumbsService: KitBreadcrumbsService);
+    toggleExpandedNotesPanelState(isExpanded: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUserSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitUserSettingsComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class FetchUserSettings {
+    static readonly type: string;
+}
+declare class SetUserSettingByKey extends AbstractPayloadAction<{
+    key: string;
+    value: string;
+}> {
+    static readonly type: string;
+}
+
+declare class KitUserSettingsState {
+    private readonly settingsService;
+    constructor(settingsService: KitSettingsApiService);
+    fetchUserSetting(ctx: StateContext<FetchUserSettings>): Observable<Record<string, string>>;
+    setSettingByKey(ctx: StateContext<SetUserSettingByKey>, action: SetUserSettingByKey): Observable<SettingValue>;
+    static getSettingByKey(key: KitUserSettingKeys): (state: Record<string, string>) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUserSettingsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitUserSettingsState>;
+}
+
+interface KitFilterSelectorItem {
+    title: string;
+    field: string;
+    disabled?: boolean;
+    filterType?: KitFilterType;
+}
+
+declare class KitGridFiltersComponent {
+    private readonly store;
+    private readonly kitGridUrlStateService;
+    readonly excludedColumns: InputSignal<string[]>;
+    readonly columns: InputSignal<KitGridColumnConfig[]>;
+    readonly filterListConfig: InputSignal<KitFilterListConfig>;
+    readonly useLocalTimeZone: InputSignal<boolean>;
+    readonly nullLabel: InputSignal<string>;
+    readonly notNullLabel: InputSignal<string>;
+    readonly kitFilterType: typeof KitFilterType;
+    readonly filters: Signal<KitFilterItem[]>;
+    readonly filterSelectorItems: Signal<KitFilterSelectorItem[]>;
+    constructor(store: Store, kitGridUrlStateService: KitGridUrlStateService);
+    addFilter(item: KitFilterSelectorItem): void;
+    removeFilter(field: string): void;
+    applyFilter(filter: KitFilterItem, values: KitFilterValue): void;
+    buildFilterSelectorItem(item: KitGridColumnConfig, filters: KitFilterItem[]): KitFilterSelectorItem;
+    private isFilterSelectorItemDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridFiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridFiltersComponent, "kit-grid-filters", never, { "excludedColumns": { "alias": "excludedColumns"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "filterListConfig": { "alias": "filterListConfig"; "required": true; "isSignal": true; }; "useLocalTimeZone": { "alias": "useLocalTimeZone"; "required": false; "isSignal": true; }; "nullLabel": { "alias": "nullLabel"; "required": false; "isSignal": true; }; "notNullLabel": { "alias": "notNullLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const kitBuildFilterListOptions: <T extends object>(enumObject: T) => KitFilterListOption[];
+declare const kitBuildFilterBooleanOptions: (trueLabelKey: string, falseLabelKey: string) => KitFilterListOption<boolean>[];
+declare const kitBuildOdataFilter: (filter?: KitCompositeFilterDescriptor) => string;
+declare const kitBuildFilters: (filters: KitFilterItem[]) => KitCompositeFilterDescriptor;
+
+declare class KitFilterCheckboxComponent implements OnInit, OnChanges {
+    readonly filter: InputSignal<KitFilterItem>;
+    readonly translateKeyPrefix: InputSignal<string>;
+    readonly items: ModelSignal<KitFilterListOption[]>;
+    readonly showPopupOnInit: InputSignal<boolean>;
+    readonly guidField: InputSignal<string>;
+    readonly filterRemoved: OutputEmitterRef<void>;
+    readonly filterChanged: OutputEmitterRef<KitFilterValue>;
+    readonly anchor: Signal<ElementRef>;
+    readonly popup: Signal<KitPopupComponent | undefined>;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    readonly selectedValues: WritableSignal<{
+        title: string;
+        value: string;
+    }[]>;
+    readonly kitPillTheme: typeof KitPillTheme;
+    readonly allSelected: WritableSignal<boolean>;
+    get isPopupOpen(): boolean;
+    get checkedItems(): KitFilterListOption[];
+    get displayedValues(): string[];
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges({ filter }: SimpleChanges): void;
+    removeFilter(): void;
+    applyButtonDisabled(): boolean;
+    clearAllFilters(): void;
+    applyFilter(): void;
+    onPopupToggle(): void;
+    close(): void;
+    buildTranslateKey(value: string): string;
+    toggleAll(isChecked: boolean): void;
+    onChange(): void;
+    private initializeSelectedValues;
+    private updateItemsState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitFilterCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitFilterCheckboxComponent, "kit-filter-checkbox", never, { "filter": { "alias": "filter"; "required": true; "isSignal": true; }; "translateKeyPrefix": { "alias": "translateKeyPrefix"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "showPopupOnInit": { "alias": "showPopupOnInit"; "required": false; "isSignal": true; }; "guidField": { "alias": "guidField"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "filterRemoved": "filterRemoved"; "filterChanged": "filterChanged"; }, never, never, true, never>;
+}
+
+declare enum GridExportOptions {
+    PDF = "pdf",
+    CSV = "csv",
+    EXCEL = "excel",
+    XML = "xml"
+}
+
+type KitKendoDrawPdf<T> = NonNullable<KitGridComponent<T>['gridComponent']>['drawPDF'];
+
+type KitGridCellDataItem = Record<string, string | number | null>;
+type KitGridCellTranslationMap = Record<string, (value: string) => string>;
+interface KitGridCellDateFormatConfig {
+    dateFormat: string;
+    dateTimeFormat: string;
+}
+declare const KIT_GRID_CELL_DATE_FORMAT_CONFIG: InjectionToken<KitGridCellDateFormatConfig>;
+
+declare class KitGridCellService {
+    private readonly translateService;
+    private readonly decimalPipe;
+    private readonly datePipe;
+    private readonly dateFormatConfig?;
+    readonly dateFormat: string;
+    readonly dateTimeFormat: string;
+    constructor(translateService: TranslateService, decimalPipe: DecimalPipe, datePipe: DatePipe, dateFormatConfig?: KitGridCellDateFormatConfig | undefined);
+    createCellValue<T>(columnType: string, columnField: string, dataItem: T, translationMap?: KitGridCellTranslationMap, defaultValue?: string | number): string | number;
+    private getNestedGridCellValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridCellService, [null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitGridCellService>;
+}
+
+declare class KitGridExportComponent<T> {
+    private readonly translateService;
+    private readonly notificationService;
+    private readonly gridCellService;
+    private readonly store;
+    readonly getExportedData: InputSignal<() => Observable<{
+        data: T[];
+        total: number;
+    }>>;
+    readonly translationMap: InputSignal<Record<string, (value: string) => string>>;
+    readonly exportedFileName: InputSignal<string>;
+    readonly drawPdf: InputSignal<(KitKendoDrawPdf<T>) | undefined>;
+    readonly gridHasData: InputSignal<boolean>;
+    readonly visibleColumns: InputSignal<KitGridColumnConfig[] | undefined>;
+    readonly popup: Signal<KitPopupComponent | undefined>;
+    readonly anchor: Signal<ElementRef>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitRadioButtonType: typeof KitRadioButtonType;
+    gridExportOptions: KitRadioButton<GridExportOptions>[];
+    isGridExporting: WritableSignal<boolean>;
+    constructor(translateService: TranslateService, notificationService: KitNotificationService, gridCellService: KitGridCellService, store: Store);
+    get exportedColumns(): KitGridColumnConfig[];
+    onPopupToggle(): void;
+    onExport({ value }: KitRadioButton<GridExportOptions>): Promise<void>;
+    private onExportPDF;
+    private onExportExcel;
+    private getExportedExcelRows;
+    private timeStringToExcelFraction;
+    private onExportCSV;
+    private onExportXML;
+    private convertToXML;
+    private wrapWithElement;
+    private sanitizeXml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridExportComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridExportComponent<any>, "kit-grid-export", never, { "getExportedData": { "alias": "getExportedData"; "required": true; "isSignal": true; }; "translationMap": { "alias": "translationMap"; "required": true; "isSignal": true; }; "exportedFileName": { "alias": "exportedFileName"; "required": true; "isSignal": true; }; "drawPdf": { "alias": "drawPdf"; "required": true; "isSignal": true; }; "gridHasData": { "alias": "gridHasData"; "required": true; "isSignal": true; }; "visibleColumns": { "alias": "visibleColumns"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KitGridCellComponent {
+    column: KitGridColumn;
+    dataItem: KitGridCellDataItem;
+    readonly dateformat: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridCellComponent, "kit-grid-cell", never, { "column": { "alias": "column"; "required": false; }; "dataItem": { "alias": "dataItem"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KitGridSearchComponent implements AfterViewInit {
+    private readonly store;
+    private readonly kitGridUrlStateService;
+    readonly kitSearchBarComponent: Signal<KitSearchBarComponent>;
+    readonly gridState$: Observable<KitGridDataState>;
+    constructor(store: Store, kitGridUrlStateService: KitGridUrlStateService);
+    ngAfterViewInit(): void;
+    closeButtonClick(): void;
+    closeSearch(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridSearchComponent, "kit-grid-search", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitGridColumnManagerComponent {
+    private readonly kitDialogService;
+    private readonly store;
+    private readonly translateService;
+    private readonly viewContainerRef;
+    readonly dialogContent: Signal<TemplateRef<unknown>>;
+    readonly updatedColumns: WritableSignal<KitGridColumnConfig[]>;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitButtonIconPosition: typeof KitButtonIconPosition;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly hasUnsavedChanges: WritableSignal<boolean>;
+    constructor(kitDialogService: KitDialogService, store: Store, translateService: TranslateService, viewContainerRef: ViewContainerRef);
+    openColumnsDialog(): void;
+    onColumnVisibilityChange(event: boolean, column: KitGridColumnConfig): void;
+    applyChanges(): void;
+    close(): void;
+    checkChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridColumnManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridColumnManagerComponent, "kit-grid-column-manager", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitGridDetailsButtonComponent {
+    readonly link: InputSignal<string>;
+    readonly kitTooltipPosition: typeof KitTooltipPosition;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitSvgIconType: typeof KitSvgIconType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitGridDetailsButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitGridDetailsButtonComponent, "kit-grid-details-button", never, { "link": { "alias": "link"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const KIT_DATE_FORMAT: string;
+declare const KIT_DATETIME_FORMAT_LONG: string;
+
+declare class KitEntityGridComponent<T> {
+    private readonly store;
+    private readonly kitBreadcrumbsService;
+    private readonly kitGridUrlStateService;
+    readonly gridData: InputSignal<KitGridDataResult<T> | null>;
+    readonly title: InputSignal<string>;
+    readonly gridColumns: InputSignal<KitGridColumnConfig[]>;
+    readonly defaultViewName: InputSignal<string>;
+    readonly viewGroup: InputSignal<string>;
+    readonly viewGroupConfig: InputSignal<string>;
+    readonly pdfOptions: InputSignal<KitPDFOptions>;
+    readonly getExportedData: InputSignal<() => Observable<{
+        data: T[];
+        total: number;
+    }>>;
+    readonly defaultSorting: InputSignal<KitSortDescriptor[]>;
+    readonly filterExcludedColumns: InputSignal<string[]>;
+    readonly systemViews: InputSignal<KitGridView[]>;
+    readonly translationMap: InputSignal<KitGridCellTranslationMap>;
+    readonly isDetailTemplateVisible: InputSignal<() => boolean>;
+    readonly detailTemplateExpandDisableIf: InputSignal<(context: T) => boolean>;
+    readonly gridHasData: InputSignal<boolean>;
+    readonly isLoading: InputSignal<boolean>;
+    readonly pagerInfoText: InputSignal<string>;
+    readonly showBreadcrumbs: InputSignal<boolean>;
+    readonly gridViewChanged: OutputEmitterRef<void>;
+    readonly kitGridComponent: Signal<KitGridComponent<T> | undefined>;
+    readonly gridExportComponent: Signal<KitGridExportComponent<T> | undefined>;
+    readonly columns: Signal<readonly KitGridColumnComponent[]>;
+    readonly gridDetailTemplate: Signal<TemplateRef<HTMLElement> | undefined>;
+    readonly drawPdf: Signal<KitKendoDrawPdf<T> | undefined>;
+    readonly filters$: Observable<KitFilterItem[]>;
+    readonly gridState$: Observable<KitGridDataState>;
+    pageSize: number;
+    readonly sortable: KitGridSortSettings;
+    readonly breadcrumbs: Signal<KitBreadcrumbsItem[]>;
+    readonly filtersVisible: WritableSignal<boolean>;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitButtonKind: typeof KitButtonKind;
+    readonly kitButtonIconPosition: typeof KitButtonIconPosition;
+    readonly kitBadgeTheme: typeof KitBadgeTheme;
+    isExporting: WritableSignal<boolean>;
+    constructor(store: Store, kitBreadcrumbsService: KitBreadcrumbsService, kitGridUrlStateService: KitGridUrlStateService);
+    onPageSizeChanged(event: KitGridPageChangeEvent): void;
+    onFiltersToggle(): void;
+    onGridViewChange(): void;
+    onDataStateChange(event: KitGridDataStateChangeEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitEntityGridComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitEntityGridComponent<any>, "kit-entity-grid", never, { "gridData": { "alias": "gridData"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "gridColumns": { "alias": "gridColumns"; "required": true; "isSignal": true; }; "defaultViewName": { "alias": "defaultViewName"; "required": true; "isSignal": true; }; "viewGroup": { "alias": "viewGroup"; "required": true; "isSignal": true; }; "viewGroupConfig": { "alias": "viewGroupConfig"; "required": true; "isSignal": true; }; "pdfOptions": { "alias": "pdfOptions"; "required": true; "isSignal": true; }; "getExportedData": { "alias": "getExportedData"; "required": true; "isSignal": true; }; "defaultSorting": { "alias": "defaultSorting"; "required": false; "isSignal": true; }; "filterExcludedColumns": { "alias": "filterExcludedColumns"; "required": false; "isSignal": true; }; "systemViews": { "alias": "systemViews"; "required": false; "isSignal": true; }; "translationMap": { "alias": "translationMap"; "required": false; "isSignal": true; }; "isDetailTemplateVisible": { "alias": "isDetailTemplateVisible"; "required": false; "isSignal": true; }; "detailTemplateExpandDisableIf": { "alias": "detailTemplateExpandDisableIf"; "required": false; "isSignal": true; }; "gridHasData": { "alias": "gridHasData"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "pagerInfoText": { "alias": "pagerInfoText"; "required": false; "isSignal": true; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; "isSignal": true; }; }, { "gridViewChanged": "gridViewChanged"; }, ["columns", "gridDetailTemplate"], ["[filters]", "[actions]"], true, never>;
+}
+
+interface KitMainMenuItem extends KitNavigationMenuItem {
+    permission?: string;
+    items?: KitMainMenuItem[];
+}
+
+declare class KitMenuBuilderService {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    build(items: KitMainMenuItem[], permissions: string[]): KitNavigationMenuItem[];
+    private filter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitMenuBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitMenuBuilderService>;
+}
+
+declare class KitSidebarComponent implements OnInit {
+    private readonly store;
+    private readonly kitMenuBuilderService;
+    readonly menuItems: InputSignal<KitNavigationMenuItem[]>;
+    readonly menuItems$: Observable<KitNavigationMenuItem[]>;
+    readonly appsMenuItems$: Observable<KitNavigationMenuAppItem[]>;
+    constructor(store: Store, kitMenuBuilderService: KitMenuBuilderService);
+    ngOnInit(): void;
+    private fetchUserApplications;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSidebarComponent, "kit-sidebar", never, { "menuItems": { "alias": "menuItems"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface KitUserMenuItem extends KitProfileMenuItem {
+    permission?: string;
+}
+
+declare class KitTopBarComponent {
+    private readonly kitNavigationMenuService;
+    readonly userMenuItems: InputSignal<KitUserMenuItem[]>;
+    readonly kitButtonType: typeof KitButtonType;
+    readonly kitSvgIcon: typeof KitSvgIcon;
+    readonly collapsed: WritableSignal<boolean>;
+    constructor(kitNavigationMenuService: KitNavigationMenuService);
+    toggleSidebar(collapsed: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitTopBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitTopBarComponent, "kit-top-bar", never, { "userMenuItems": { "alias": "userMenuItems"; "required": false; "isSignal": true; }; }, {}, never, ["[globalSearch]", "[topBarActions]"], true, never>;
+}
+
+interface UserApplication {
+    name: string;
+    url: string | null;
+}
+interface UserApplications {
+    applications: UserApplication[];
+}
+interface CurrentUser {
+    id: number;
+    userName: string | null;
+    email: string | null;
+    firstName: string | null;
+    lastName: string | null;
+    name: string | null;
+    companyName: string;
+    timeZoneInfoId: string;
+    namedTimeZone: string;
+    companyType?: UserCompanyType;
+}
+type UserCompanyType = 'DC' | 'Client' | 'OriginAgent' | 'DestinationAgent' | 'Vendor' | 'Integration' | 'SystemAdmin' | 'ReportAdmin' | 'SS_SysAdmin' | 'SS_ReportAdmin';
+
+declare class KitUserApiService {
+    private readonly httpClient;
+    private readonly basePath;
+    constructor(httpClient: HttpClient, basePath: string);
+    getUserInfo(): Observable<CurrentUser>;
+    getUserApplicationList(): Observable<UserApplications>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUserApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitUserApiService>;
+}
+
+declare const KIT_USER_STATE_TOKEN: StateToken<ApiResponseState<CurrentUser>>;
+declare class KitUserState {
+    private readonly kitUserApiService;
+    constructor(kitUserApiService: KitUserApiService);
+    fetchUser(ctx: StateContext<ApiResponseState<CurrentUser>>): Observable<CurrentUser>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUserState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitUserState>;
+}
+
+declare class FetchUserApplications {
+    static readonly type: string;
+}
+
+declare class KitUserApplicationsState {
+    private readonly kitUserApiService;
+    constructor(kitUserApiService: KitUserApiService);
+    fetchUserApplications(ctx: StateContext<FetchUserApplications>): Observable<UserApplications>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUserApplicationsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitUserApplicationsState>;
+}
+
+declare class FetchUserPermissions {
+    static readonly type: string;
+}
+
+interface UserPermissions {
+    permissions: string[];
+}
+
+declare class KitPermissionsApiService {
+    private readonly httpClient;
+    private readonly basePath;
+    constructor(httpClient: HttpClient, basePath: string);
+    getUserPermissions(): Observable<UserPermissions>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitPermissionsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitPermissionsApiService>;
+}
+
+declare const KIT_USER_PERMISSIONS_STATE_TOKEN: StateToken<UserPermissions>;
+declare class KitUserPermissionsState {
+    private readonly kitPermissionsApiService;
+    constructor(kitPermissionsApiService: KitPermissionsApiService);
+    fetchUserPermissions(ctx: StateContext<FetchUserPermissions>): Observable<UserPermissions>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitUserPermissionsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KitUserPermissionsState>;
+}
+
+interface KitSchedulerEvent<T = unknown> extends SchedulerEvent {
+    data: T;
+}
+type KitScheduleEventClickEvent = EventClickEvent;
+type KitScheduleSlotClickEvent = SlotClickEvent;
+
+declare class KitSchedulerComponent<T> {
+    readonly events: InputSignal<KitSchedulerEvent<T>[]>;
+    readonly selectedDate: InputSignal<Date | undefined>;
+    readonly min: InputSignal<Date | undefined>;
+    readonly max: InputSignal<Date | undefined>;
+    readonly eventClicked: OutputEmitterRef<KitScheduleEventClickEvent>;
+    readonly slotClicked: OutputEmitterRef<KitScheduleSlotClickEvent>;
+    readonly scheduler: Signal<SchedulerComponent | undefined>;
+    readonly weekEventTemplate: Signal<TemplateRef<HTMLElement> | undefined>;
+    readonly monthEventTemplate: Signal<TemplateRef<HTMLElement> | undefined>;
+    onEventClick(event: KitScheduleEventClickEvent): void;
+    onSlotClick(event: KitScheduleSlotClickEvent): void;
+    getEventsForDate(date: Date, events: KitSchedulerEvent[]): KitSchedulerEvent[];
+    onSchedulerClick(event: Event): void;
+    navigateToView(viewIndex: number): void;
+    private formatDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSchedulerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KitSchedulerComponent<any>, "kit-scheduler", never, { "events": { "alias": "events"; "required": false; "isSignal": true; }; "selectedDate": { "alias": "selectedDate"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, { "eventClicked": "eventClicked"; "slotClicked": "slotClicked"; }, ["weekEventTemplate", "monthEventTemplate"], ["[toolbar]"], true, never>;
+}
+
+declare class KitSchedulerWeekEventTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSchedulerWeekEventTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitSchedulerWeekEventTemplateDirective, "[kitSchedulerWeekEventTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KitSchedulerMonthEventTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KitSchedulerMonthEventTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KitSchedulerMonthEventTemplateDirective, "[kitSchedulerMonthEventTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+export { AbstractKitCtaPanelConfirmationComponent, AddGridFilter, FetchUserPermissions, FetchUserSettings, KIT_BASE_PATH, KIT_DATETIME_FORMAT_LONG, KIT_DATE_FORMAT, KIT_GRID_CELL_DATE_FORMAT_CONFIG, KIT_GRID_STATE_TOKEN, KIT_USER_PERMISSIONS_STATE_TOKEN, KIT_USER_STATE_TOKEN, KitAutocompleteComponent, KitAutocompleteDirective, KitAutocompleteModule, KitAvatarComponent, KitAvatarModule, KitAvatarSize, KitBadgeDirective, KitBadgeTheme, KitBreadcrumbsComponent, KitBreadcrumbsModule, KitBreadcrumbsService, KitButtonComponent, KitButtonIconPosition, KitButtonKind, KitButtonModule, KitButtonState, KitButtonType, KitCardComponent, KitCardModule, KitCardTheme, KitCheckboxComponent, KitCheckboxModule, KitCheckboxState, KitCollapsedListComponent, KitCollapsedListDropdownAlign, KitCopyTextComponent, KitCopyTextModule, KitCtaPanelAbstractConfirmationComponent, KitCtaPanelAbstractConfirmationModule, KitCtaPanelActionComponent, KitCtaPanelActionModule, KitCtaPanelConfirmationComponent, KitCtaPanelConfirmationModule, KitCtaPanelItemComponent, KitCtaPanelItemModule, KitCtaPanelItemType, KitDataFieldComponent, KitDataFieldState, KitDatepickerComponent, KitDatepickerModule, KitDatepickerSize, KitDaterangeComponent, KitDaterangeModule, KitDaterangeType, KitDatetimepickerComponent, KitDatetimepickerModule, KitDialogActionsComponent, KitDialogComponent, KitDialogService, KitDropdownComponent, KitDropdownItemTemplateDirective, KitDropdownModule, KitDropdownSize, KitEmptySectionComponent, KitEntityGridComponent, KitEntitySectionComponent, KitEntitySectionContainerComponent, KitEntityTitleComponent, KitEntityTitleModule, KitFileCardComponent, KitFileCardMessagesComponent, KitFileCardModule, KitFileUploadComponent, KitFileUploadModule, KitFilterCheckboxComponent, KitFilterLogic, KitFilterOperator, KitFilterType, KitGlobalSearchComponent, KitGridCellComponent, KitGridCellService, KitGridCellTemplateDirective, KitGridColumnComponent, KitGridColumnManagerComponent, KitGridComponent, KitGridDetailTemplateDirective, KitGridDetailsButtonComponent, KitGridExportComponent, KitGridFiltersComponent, KitGridModule, KitGridSearchComponent, KitGridSortSettingsMode, KitGridState, KitGridUrlStateService, KitGridViewType, KitGridViewsComponent, KitGridViewsState, KitInputLabelComponent, KitInputLabelModule, KitInputMessageComponent, KitInputMessageModule, KitLoaderComponent, KitLoaderModule, KitLocationStepperComponent, KitLocationStepperModule, KitMultiselectComponent, KitMultiselectModule, KitNavigationMenuComponent, KitNavigationMenuModule, KitNavigationMenuService, KitNavigationMenuSubmenuComponent, KitNavigationTabsComponent, KitNavigationTabsModule, KitNavigationTabsType, KitNoteComponent, KitNoteModule, KitNotificationComponent, KitNotificationService, KitNotificationType, KitNumericTextboxComponent, KitNumericTextboxModule, KitNumericTextboxSize, KitNumericTextboxState, KitPageLayoutComponent, KitPermissionDirective, KitPermissionModule, KitPillComponent, KitPillTheme, KitPillType, KitPopupAlignHorizontal, KitPopupAlignVertical, KitPopupComponent, KitPopupPositionMode, KitProfileMenuComponent, KitQueryParamsName, KitQueryParamsService, KitRadioButtonComponent, KitRadioButtonModule, KitRadioButtonType, KitSchedulerComponent, KitSchedulerMonthEventTemplateDirective, KitSchedulerWeekEventTemplateDirective, KitScrollNavigationComponent, KitScrollNavigationSectionComponent, KitSearchBarComponent, KitSearchBarModule, KitShipmentCard, KitSidebarComponent, KitSkeletonAnimation, KitSkeletonComponent, KitSkeletonModule, KitSkeletonShape, KitSortDirection, KitSortableComponent, KitSvgIcon, KitSvgIconComponent, KitSvgIconModule, KitSvgIconType, KitSvgSpriteComponent, KitSvgSpriteModule, KitSwitchComponent, KitSwitchMode, KitSwitchModule, KitSwitchState, KitTabComponent, KitTabContentDirective, KitTabsComponent, KitTabsModule, KitTabsSize, KitTabsType, KitTextLabelComponent, KitTextLabelModule, KitTextLabelState, KitTextareaAutoresizeDirective, KitTextareaComponent, KitTextareaModule, KitTextareaState, KitTextboxComponent, KitTextboxModule, KitTextboxSize, KitTextboxState, KitTileLayoutComponent, KitTileLayoutItemComponent, KitTileLayoutModule, KitTimelineCardComponent, KitTimelineComponent, KitTimelineTheme, KitTimelineType, KitTimepickerComponent, KitTimepickerModule, KitTitleTemplateDirective, KitToastrModule, KitToastrPosition, KitToastrService, KitToastrType, KitToggleComponent, KitToggleModule, KitTooltipDirective, KitTooltipPosition, KitTopBarComponent, KitTranslateService, KitTruncateTextComponent, KitUnitsTextboxComponent, KitUnitsTextboxDropdownPosition, KitUnitsTextboxModule, KitUnitsTextboxType, KitUserApplicationsState, KitUserPermissionsState, KitUserSettingKeys, KitUserSettingsComponent, KitUserSettingsState, KitUserState, RemoveGridFilter, SetGridColumns, SetGridFilters, SetGridSearch, SetGridSkip, SetGridSort, SetGridTake, UpdateGridFilter, buildRandomUUID, findMatches, kitBuildFilterBooleanOptions, kitBuildFilterListOptions, kitBuildFilters, kitBuildGridColumn, kitBuildGridDataResults, kitBuildOdataFilter, kitBuildSortString, kitDataStateToODataString, kitEncodeViewNameToUrl, mapGlobalSearchResult };
+export type { GlobalSearchLineItem, GlobalSearchPrompt, GlobalSearchResult, KitAutocompleteItem, KitBreadcrumbsItem, KitCard, KitCardItem, KitCardLink, KitCollapsedListItem, KitCompositeFilterDescriptor, KitCtaPanelConfirmation, KitCtaPanelConfirmationValue, KitCtaPanelCopyItem, KitCtaPanelItem, KitDataResult, KitDataState, KitDaterangeValue, KitDropdownItem, KitFileUploadFile, KitFileUploadFileRestrictions, KitFileUploadFileRestrictionsMessages, KitFilterDescriptor, KitFilterItem, KitFilterListConfig, KitFilterListOption, KitFilterValue, KitGridCellClickEvent, KitGridCellTranslationMap, KitGridColumn, KitGridColumnConfig, KitGridColumns, KitGridDataResult, KitGridDataState, KitGridDataStateChangeEvent, KitGridDetailCollapseEvent, KitGridDetailExpandEvent, KitGridPageChangeEvent, KitGridSortSettings, KitGridView, KitGridViewColumn, KitKendoDrawPdf, KitLocationStepperItem, KitLocationStepperItemDate, KitMainMenuItem, KitMultiselectItem, KitNavigationMenuAppItem, KitNavigationMenuItem, KitNavigationTabsItem, KitNavigationTabsItemLink, KitPDFOptions, KitPopupAlign, KitProfileMenuItem, KitQueryParams, KitRadioButton, KitScheduleEventClickEvent, KitScheduleSlotClickEvent, KitSchedulerEvent, KitShipmentCardData, KitSortDescriptor, KitSwitchItem, KitSwitchItemSelection, KitTabsSelectEvent, KitTileLayoutColumnsConfig, KitTimelineItem, KitTimelineItemDate, KitToastrConfig, KitUserMenuItem };