@meshmakers/shared-ui 3.3.34 → 3.3.390

package/types/meshmakers-shared-ui.d.ts

@@ -0,0 +1,1644 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, AfterViewInit, EventEmitter, ElementRef, OnInit, InjectionToken, PipeTransform, OnChanges, SimpleChanges, EnvironmentProviders } from '@angular/core';
+import { FormGroup, ControlValueAccessor, Validator, FormControl, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as _progress_kendo_svg_icons from '@progress/kendo-svg-icons';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+import { CommandBaseService, CommandItem, TreeItemData, TreeItemDataTyped, EntitySelectDataSource } from '@meshmakers/shared-services';
+import { TreeViewComponent, TreeItem, NodeClickEvent, TreeItemDropEvent } from '@progress/kendo-angular-treeview';
+import { Observable } from 'rxjs';
+import * as _meshmakers_shared_ui from '@meshmakers/shared-ui';
+import { State } from '@progress/kendo-data-query/dist/npm/state';
+import { PagerSettings, SelectableSettings, SelectionEvent, PageChangeEvent, CellClickEvent, DataBindingDirective } from '@progress/kendo-angular-grid';
+import { SVGIcon as SVGIcon$1 } from '@progress/kendo-svg-icons/dist/svg-icon.interface';
+import { MenuItem, ContextMenuComponent, ContextMenuSelectEvent, ContextMenuPopupEvent } from '@progress/kendo-angular-menu';
+import { DialogContentBase, DialogRef } from '@progress/kendo-angular-dialog';
+import { AutoCompleteComponent } from '@progress/kendo-angular-dropdowns';
+import { CanDeactivate } from '@angular/router';
+
+/**
+ * Mapping configuration for a single status value to its visual representation
+ */
+interface StatusIconMapping {
+    /** The Kendo SVG icon to display */
+    icon: SVGIcon;
+    /** Tooltip text shown on hover */
+    tooltip: string;
+    /** Optional CSS color for the icon (e.g., 'green', '#28a745', 'var(--success-color)') */
+    color?: string;
+}
+/**
+ * Maps enum/status values to their icon representations
+ * Key is the enum value (e.g., 'OK', 'MAINTENANCE'), value is the visual config
+ */
+type StatusMapping = Record<string, StatusIconMapping>;
+/**
+ * Configuration for a single field in a multi-field status icons column
+ */
+interface StatusFieldConfig {
+    /** The field name in the data object */
+    field: string;
+    /** Mapping of field values to icons */
+    statusMapping: StatusMapping;
+}
+interface TableColumn {
+    displayName?: string | null;
+    field: string;
+    dataType?: 'text' | 'numeric' | 'boolean' | 'date' | 'iso8601' | 'bytes' | 'statusIcons' | 'cronExpression';
+    format?: any;
+    /**
+     * Column width in pixels. If not set, the column will auto-size.
+     */
+    width?: number;
+    /**
+     * Status mapping for single-field statusIcons columns.
+     * Use this when the column displays icons for a single field.
+     */
+    statusMapping?: StatusMapping;
+    /**
+     * Configuration for multi-field statusIcons columns.
+     * Use this when multiple fields should be displayed as icons in a single column.
+     * When set, 'field' is ignored and each entry in 'statusFields' defines its own field.
+     */
+    statusFields?: StatusFieldConfig[];
+    /**
+     * Whether sorting is enabled for this column.
+     * When not set, inherits from the grid-level sortable setting.
+     * Set to false to disable sorting for computed or client-side-only columns.
+     */
+    sortable?: boolean;
+}
+type ColumnDefinition = string | TableColumn;
+type ContextMenuType = 'contextMenu' | 'actionMenu';
+
+declare class ListViewComponent extends CommandBaseService implements OnDestroy, AfterViewInit {
+    private readonly cronHumanizer;
+    protected _columns: TableColumn[];
+    private _actionCommandItems;
+    private _contextMenuCommandItems;
+    private searchSubject;
+    private destroy$;
+    protected searchValue: string;
+    private _selectedRows;
+    private _actionMenuSelectedRow;
+    private _contextMenuSelectedRow;
+    protected _actionMenuItems: MenuItem[];
+    protected _contextMenuItems: MenuItem[];
+    protected _showRowFilter: boolean;
+    /** Indicates if the data source is currently loading data */
+    protected isLoading: boolean;
+    private gridComponent?;
+    private dataBindingDirective?;
+    gridContextMenu?: ContextMenuComponent;
+    rowClicked: EventEmitter<any[]>;
+    pageSize: number;
+    skip: number;
+    rowIsClickable: boolean;
+    showRowCheckBoxes: boolean;
+    showRowSelectAllCheckBox: boolean;
+    contextMenuType: ContextMenuType;
+    leftToolbarActions: CommandItem[];
+    rightToolbarActions: CommandItem[];
+    get actionCommandItems(): CommandItem[];
+    set actionCommandItems(commandItems: CommandItem[]);
+    get contextMenuCommandItems(): CommandItem[];
+    set contextMenuCommandItems(commandItems: CommandItem[]);
+    excelExportFileName: string;
+    pdfExportFileName: string;
+    pageable: PagerSettings;
+    sortable: boolean;
+    rowFilterEnabled: boolean;
+    searchTextBoxEnabled: boolean;
+    selectable: SelectableSettings;
+    set columns(cols: ColumnDefinition[]);
+    get columns(): TableColumn[];
+    private readonly cdr;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected getDisplayName(column: TableColumn): string;
+    protected getIsDisabled(commandItem: CommandItem): boolean;
+    protected getValue(element: any, column: TableColumn): any;
+    protected getFilterType(column: TableColumn): 'text' | 'numeric' | 'boolean' | 'date';
+    /**
+     * Gets all status field configurations for a statusIcons column.
+     * Returns an array of StatusFieldConfig, whether the column uses single or multi-field configuration.
+     */
+    protected getStatusFields(column: TableColumn): StatusFieldConfig[];
+    /**
+     * Gets the status icon mapping for a specific field value in a data item.
+     */
+    protected getStatusIconMapping(dataItem: any, fieldConfig: StatusFieldConfig): StatusIconMapping | null;
+    /**
+     * Helper to get a field value from a data item, supporting nested fields.
+     */
+    private getFieldValue;
+    /**
+     * Gets the human-readable description of a cron expression.
+     */
+    protected getCronHumanReadable(expression: string): string;
+    protected onShowRowFilter(): void;
+    protected onRefresh(): void;
+    onExecuteFilter: EventEmitter<any>;
+    onRefreshData: EventEmitter<void>;
+    protected onFilter(value: string | null): Promise<void>;
+    protected readonly filterIcon: SVGIcon$1;
+    protected readonly pdfSVG: SVGIcon$1;
+    protected readonly excelSVG: SVGIcon$1;
+    protected readonly refreshIcon: SVGIcon$1;
+    protected onRowSelect(event: SelectionEvent): void;
+    protected onPageChange(_event: PageChangeEvent): void;
+    protected onContextMenuSelect(_event: ContextMenuSelectEvent): Promise<void>;
+    protected onCellClick(e: CellClickEvent): void;
+    protected onSelectOptionActionItem(event: Event, dataItem: any, menuItem: MenuItem): Promise<void>;
+    protected onContextMenu(dataItem: any, e: PointerEvent): void;
+    protected onContextMenuClosed(_event: ContextMenuPopupEvent): void;
+    protected onToolbarCommand(commandItem: CommandItem): Promise<void>;
+    private buildMenuItems;
+    protected readonly moreVerticalIcon: SVGIcon$1;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListViewComponent, "mm-list-view", never, { "pageSize": { "alias": "pageSize"; "required": false; }; "skip": { "alias": "skip"; "required": false; }; "rowIsClickable": { "alias": "rowIsClickable"; "required": false; }; "showRowCheckBoxes": { "alias": "showRowCheckBoxes"; "required": false; }; "showRowSelectAllCheckBox": { "alias": "showRowSelectAllCheckBox"; "required": false; }; "contextMenuType": { "alias": "contextMenuType"; "required": false; }; "leftToolbarActions": { "alias": "leftToolbarActions"; "required": false; }; "rightToolbarActions": { "alias": "rightToolbarActions"; "required": false; }; "actionCommandItems": { "alias": "actionCommandItems"; "required": false; }; "contextMenuCommandItems": { "alias": "contextMenuCommandItems"; "required": false; }; "excelExportFileName": { "alias": "excelExportFileName"; "required": false; }; "pdfExportFileName": { "alias": "pdfExportFileName"; "required": false; }; "pageable": { "alias": "pageable"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "rowFilterEnabled": { "alias": "rowFilterEnabled"; "required": false; }; "searchTextBoxEnabled": { "alias": "searchTextBoxEnabled"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; }, { "rowClicked": "rowClicked"; }, never, never, true, never>;
+}
+
+declare class UploadFileDialogComponent extends DialogContentBase {
+    private readonly dialogRef;
+    private readonly notificationService;
+    message: string;
+    mimeTypes: string | null;
+    fileExtensions: string | null;
+    protected fileName: i0.WritableSignal<string>;
+    protected fileSize: i0.WritableSignal<number>;
+    protected uploadProgress: i0.WritableSignal<number>;
+    protected fileInput: ElementRef | undefined;
+    protected selectedFile: File | null;
+    protected uploadSuccess: boolean;
+    protected uploadError: boolean;
+    constructor();
+    onFileChange(event: any): void;
+    onFileDrop(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    uploadFile(file: File | null): void;
+    removeFile(): void;
+    onOk(): void;
+    onCancel(): void;
+    protected readonly upload: {
+        name: string;
+        content: string;
+        viewBox: string;
+    };
+    protected readonly deleteIcon: {
+        name: string;
+        content: string;
+        viewBox: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFileDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadFileDialogComponent, "mm-upload-file-dialog", never, { "message": { "alias": "message"; "required": false; }; "mimeTypes": { "alias": "mimeTypes"; "required": false; }; "fileExtensions": { "alias": "fileExtensions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputDialogComponent extends DialogContentBase {
+    private readonly dialogRef;
+    buttonOkText: string;
+    message: string;
+    placeholder: string;
+    protected inputValue: any | null;
+    constructor();
+    protected onOk(): void;
+    protected onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDialogComponent, "mm-input-dialog", never, { "buttonOkText": { "alias": "buttonOkText"; "required": false; }; "message": { "alias": "message"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "inputValue": { "alias": "inputValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class HierarchyDataSource {
+    protected expandAllByDefault: boolean;
+    hasChildren(item: TreeItemData): boolean;
+    isExpanded(item: TreeItemData): boolean;
+    abstract fetchChildren(item: TreeItemData): Promise<TreeItemData[]>;
+    abstract fetchRootNodes(): Promise<TreeItemData[]>;
+}
+
+/**
+ * Metadata for a tree drag-and-drop operation.
+ */
+interface NodeInfo {
+    /**
+     * The unique Runtime Identity of the node.
+     */
+    rtId: string;
+    /**
+     * The Content Kind Type ID (schema definition) of the node.
+     */
+    ckTypeId: string;
+}
+/**
+ * Event emitted when a tree node is successfully dropped.
+ */
+interface NodeDroppedEvent<T> {
+    /**
+     * The specific node being moved.
+     */
+    sourceItem: NodeInfo & {
+        dataItem: TreeItemDataTyped<T>;
+    };
+    /**
+     * The original parent from which the node was dragged.
+     */
+    sourceParent?: NodeInfo | undefined;
+    /**
+     * The new target node where the item was dropped.
+     *
+     * If dropping *into* a folder, this is the folder.
+     * If dropping *between* items, this may be the new sibling or parent.
+     */
+    destinationItem?: NodeInfo | undefined;
+    /**
+     * List of items to refresh after drop.
+     */
+    refreshItems: NodeInfo[];
+}
+
+declare class TreeComponent implements OnInit, AfterViewInit, OnDestroy {
+    private readonly cdRef;
+    private _timeoutCache;
+    private readonly _rootNodes;
+    private _isViewInitialized;
+    protected expandedKeys: any[];
+    protected treeView: TreeViewComponent;
+    ngOnInit(): Promise<void>;
+    ngAfterViewInit(): void;
+    /**
+     * Check if the TreeComponent is fully initialized and ready for operations
+     */
+    get isReady(): boolean;
+    dataSource: HierarchyDataSource | null;
+    nodeSelected: EventEmitter<any>;
+    nodeClick: EventEmitter<any>;
+    nodeDoubleClick: EventEmitter<any>;
+    nodeDrop: EventEmitter<NodeDroppedEvent<any>>;
+    expand: EventEmitter<any>;
+    collapse: EventEmitter<any>;
+    protected get rootNodes(): Observable<any[]>;
+    protected hasChildren: (item: any) => boolean;
+    protected isExpanded: (item: any, _index: string) => boolean;
+    protected fetchChildren: (item: any) => Observable<any[]>;
+    protected onNodeSelect(treeItem: TreeItem): void;
+    protected onNodeClick(event: NodeClickEvent): void;
+    protected onNodeDoubleClick(event: NodeClickEvent): void;
+    protected onExpand(event: any): void;
+    protected onCollapse(event: any): void;
+    refreshTree(): Promise<void>;
+    onNodeDrop(event: TreeItemDropEvent): Promise<void>;
+    /**
+     * Refreshes given runtime entity by reloading the data of the children.
+     */
+    refreshRuntimeEntities(nodes: {
+        rtId: string;
+        ckTypeId: string;
+        isRoot: boolean;
+    }[]): Promise<void>;
+    getExpandedKeys(): any[];
+    collapseAll(): void;
+    setExpandedKeys(keys: any[]): void;
+    private _clearTimeouts;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "mm-tree-view", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, { "nodeSelected": "nodeSelected"; "nodeClick": "nodeClick"; "nodeDoubleClick": "nodeDoubleClick"; "nodeDrop": "nodeDrop"; "expand": "expand"; "collapse": "collapse"; }, never, never, true, never>;
+}
+
+/**
+ * Interface for components that track unsaved changes.
+ * Implement this interface in components that need to warn users before navigating away
+ * when there are unsaved changes.
+ */
+interface HasUnsavedChanges {
+    /**
+     * Returns true if the component has unsaved changes.
+     */
+    hasUnsavedChanges(): boolean;
+    /**
+     * Optional method to save changes before navigating away.
+     * If implemented, the guard will offer a "Save" option in the confirmation dialog.
+     * @returns Promise resolving to true if save was successful, false otherwise.
+     */
+    saveChanges?(): Promise<boolean>;
+}
+/**
+ * Injection token for components implementing HasUnsavedChanges.
+ *
+ * Components should provide themselves using this token:
+ * ```typescript
+ * @Component({
+ *   providers: [{ provide: HAS_UNSAVED_CHANGES, useExisting: MyComponent }]
+ * })
+ * export class MyComponent implements HasUnsavedChanges { ... }
+ * ```
+ */
+declare const HAS_UNSAVED_CHANGES: InjectionToken<HasUnsavedChanges>;
+
+/**
+ * Directive that handles browser beforeunload events for components with unsaved changes.
+ *
+ * This directive should be used together with the UnsavedChangesGuard on routes.
+ * While the guard handles in-app navigation, this directive handles browser events
+ * like back/forward buttons, refresh, and tab close.
+ *
+ * Usage:
+ * 1. The host component must implement HasUnsavedChanges interface
+ * 2. The component must provide itself via the HAS_UNSAVED_CHANGES token
+ * 3. Add the directive to the component's hostDirectives
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'my-editor',
+ *   hostDirectives: [UnsavedChangesDirective],
+ *   providers: [{ provide: HAS_UNSAVED_CHANGES, useExisting: MyEditorComponent }],
+ *   ...
+ * })
+ * export class MyEditorComponent implements HasUnsavedChanges {
+ *   hasUnsavedChanges(): boolean {
+ *     return this.form.dirty;
+ *   }
+ * }
+ * ```
+ */
+declare class UnsavedChangesDirective {
+    private readonly host;
+    /**
+     * Handles browser beforeunload event (back button, refresh, close tab).
+     * Shows browser's native confirmation dialog when there are unsaved changes.
+     */
+    onBeforeUnload(event: BeforeUnloadEvent): void;
+    private hostHasUnsavedChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsavedChangesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UnsavedChangesDirective, "[mmUnsavedChanges]", never, {}, {}, never, never, true, never>;
+}
+
+interface ResponsiveFormBreakPoint {
+    maxWidth: number;
+    value: number;
+}
+interface BaseFormConfig {
+    title?: string;
+    cardWidth?: string;
+    showCard?: boolean;
+    saveButtonText?: string;
+    cancelButtonText?: string;
+    isEditMode?: boolean;
+    isViewMode?: boolean;
+    isLoading?: boolean;
+    isSaving?: boolean;
+    showLoadingOverlay?: boolean;
+    /**
+     * Indicates whether the form has unsaved changes.
+     * When true, displays a "Modified" indicator in the header and footer.
+     */
+    hasChanges?: boolean;
+}
+declare const DEFAULT_RESPONSIVE_COLSPAN: ResponsiveFormBreakPoint[];
+declare class BaseFormComponent implements HasUnsavedChanges {
+    form: FormGroup;
+    config: BaseFormConfig;
+    saveForm: EventEmitter<void>;
+    cancelForm: EventEmitter<void>;
+    protected readonly saveIcon: SVGIcon;
+    protected readonly cancelIcon: SVGIcon;
+    protected get title(): string;
+    protected get saveButtonText(): string;
+    protected get cancelButtonText(): string;
+    protected get showSaveButton(): boolean;
+    protected get saveButtonDisabled(): boolean;
+    protected onSave(): void;
+    protected onCancel(): void;
+    /**
+     * Checks if there are unsaved changes.
+     * Uses config.hasChanges if provided, otherwise falls back to form.dirty.
+     */
+    hasUnsavedChanges(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormComponent, "mm-base-form", never, { "form": { "alias": "form"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "saveForm": "saveForm"; "cancelForm": "cancelForm"; }, never, ["*", "[additionalActions]"], true, [{ directive: typeof UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class BaseTreeDetailComponent<T = any> extends CommandBaseService {
+    treeDataSource: HierarchyDataSource;
+    leftPaneSize: string;
+    leftToolbarActions: CommandItem[];
+    rightToolbarActions: CommandItem[];
+    nodeSelected: EventEmitter<TreeItemDataTyped<T>>;
+    nodeDropped: EventEmitter<NodeDroppedEvent<T>>;
+    treeComponent: TreeComponent;
+    protected isContentDisabled: boolean;
+    protected selectedNode: TreeItemDataTyped<T> | null;
+    constructor();
+    protected get hasToolbarActions(): boolean;
+    protected onNodeClick(treeItem: TreeItemDataTyped<T>): void;
+    protected onNodeDrop(event: NodeDroppedEvent<T>): void;
+    protected onToolbarCommand(commandItem: CommandItem): Promise<void>;
+    protected getIsDisabled(commandItem: CommandItem): boolean;
+    /**
+     * Wait for the tree component to be ready
+     */
+    waitForTreeReady(): Promise<boolean>;
+    /**
+     * Refresh the tree by reloading root nodes
+     */
+    refreshTree(): Promise<void>;
+    /**
+     * Sets the state of Tree and Details panes.
+     *
+     * @description Panes are frozen (unclickable, unselectable) when disabled.
+     */
+    setEnabledState(enabled: boolean): void;
+    /**
+     * Refreshes given runtime entity on a tree.
+     */
+    refreshRuntimeEntities(nodes: {
+        ckTypeId: string;
+        rtId: string;
+        isRoot: boolean;
+    }[]): Promise<void>;
+    getExpandedKeys(): any[];
+    collapseAll(): void;
+    setExpandedKeys(keys: any[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTreeDetailComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTreeDetailComponent<any>, "mm-base-tree-detail", never, { "treeDataSource": { "alias": "treeDataSource"; "required": false; }; "leftPaneSize": { "alias": "leftPaneSize"; "required": false; }; "leftToolbarActions": { "alias": "leftToolbarActions"; "required": false; }; "rightToolbarActions": { "alias": "rightToolbarActions"; "required": false; }; }, { "nodeSelected": "nodeSelected"; "nodeDropped": "nodeDropped"; }, never, ["[slot=detail-panel]"], true, never>;
+}
+
+declare class ProgressValue {
+    statusText: string | null;
+    progressValue: number;
+    constructor();
+}
+
+interface ProgressWindowData {
+    title: string;
+    isDeterminate: boolean;
+    progress: Observable<ProgressValue>;
+    isCancelOperationAvailable: boolean;
+    cancelOperation: () => void;
+}
+type ProgressWindowResult = object;
+declare class ProgressWindowComponent extends DialogContentBase implements OnDestroy, AfterViewInit {
+    private readonly dialogRef;
+    private progressSubscription?;
+    isDeterminate: boolean;
+    progress: Observable<ProgressValue>;
+    isCancelOperationAvailable: boolean;
+    cancelOperation?: () => void;
+    statusText: string | null;
+    progressValue: number;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onCancelClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressWindowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressWindowComponent, "mm-progress-window", never, { "isDeterminate": { "alias": "isDeterminate"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "isCancelOperationAvailable": { "alias": "isCancelOperationAvailable"; "required": false; }; "cancelOperation": { "alias": "cancelOperation"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ProgressWindowService {
+    private readonly dialogService;
+    /**
+     * Opens a progress window dialog
+     * @param config Configuration for the progress window
+     * @returns DialogRef for the progress window
+     */
+    showProgress(config: ProgressWindowConfig): DialogRef;
+    /**
+     * Shows a determinate progress window (with percentage)
+     * @param title Window title
+     * @param progress Observable that emits progress updates
+     * @param options Additional options
+     * @returns DialogRef for the progress window
+     */
+    showDeterminateProgress(title: string, progress: Observable<ProgressValue>, options?: Partial<ProgressWindowOptions>): DialogRef;
+    /**
+     * Shows an indeterminate progress window (spinning/pulsing animation)
+     * @param title Window title
+     * @param progress Observable that emits progress updates (statusText only)
+     * @param options Additional options
+     * @returns DialogRef for the progress window
+     */
+    showIndeterminateProgress(title: string, progress: Observable<ProgressValue>, options?: Partial<ProgressWindowOptions>): DialogRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressWindowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressWindowService>;
+}
+interface ProgressWindowConfig {
+    title: string;
+    progress: Observable<ProgressValue>;
+    isDeterminate?: boolean;
+    isCancelOperationAvailable?: boolean;
+    cancelOperation?: () => void;
+    width?: number;
+    height?: number | string;
+    allowClose?: boolean;
+}
+interface ProgressWindowOptions {
+    isCancelOperationAvailable?: boolean;
+    cancelOperation?: () => void;
+    width?: number;
+    height?: number | string;
+    allowClose?: boolean;
+}
+
+interface FetchResult {
+    get data(): any;
+    get totalCount(): number;
+}
+declare class FetchResultBase implements FetchResult {
+    private readonly _data;
+    private readonly _totalCount;
+    constructor(_data: any, _totalCount: number);
+    get data(): any;
+    get totalCount(): number;
+}
+declare class FetchResultTyped<TDto> implements FetchResult {
+    private readonly _data;
+    private readonly _totalCount;
+    constructor(_data: (TDto | null)[], _totalCount: number);
+    get data(): (TDto | null)[];
+    get totalCount(): number;
+}
+
+interface FetchDataOptions {
+    state: State;
+    textSearch: string | null;
+    /** When true, bypass cache and fetch fresh data from the server */
+    forceRefresh?: boolean;
+}
+declare abstract class DataSourceBase {
+    readonly listViewComponent: ListViewComponent;
+    readonly fetchAgainEvent: EventEmitter<void>;
+    private readonly _isLoading$;
+    /** Observable indicating if the data source is currently loading data */
+    readonly isLoading$: Observable<boolean>;
+    /** Current loading state */
+    get isLoading(): boolean;
+    protected constructor(listViewComponent: ListViewComponent);
+    /** Set the loading state (called by MmListViewDataBindingDirective) */
+    setLoading(loading: boolean): void;
+    fetchAgain(): void;
+    abstract fetchData(queryOptions: FetchDataOptions): Observable<FetchResult | null>;
+}
+
+declare abstract class DataSourceTyped<TDto> extends DataSourceBase {
+    protected constructor(mmTableComponent: ListViewComponent);
+    abstract fetchData(queryOptions: FetchDataOptions): Observable<FetchResultTyped<TDto> | null>;
+}
+
+declare abstract class HierarchyDataSourceBase<TQueryDto> extends HierarchyDataSource {
+    abstract fetchChildren(item: TreeItemDataTyped<TQueryDto>): Promise<TreeItemDataTyped<TQueryDto>[]>;
+    abstract fetchRootNodes(): Promise<TreeItemDataTyped<TQueryDto>[]>;
+}
+
+declare class MmListViewDataBindingDirective extends DataBindingDirective implements OnInit, OnDestroy {
+    private readonly dataSource;
+    /** Observable indicating if the data source is currently loading data */
+    get isLoading$(): Observable<boolean>;
+    /** Current loading state */
+    get isLoading(): boolean;
+    private _serviceSubscription;
+    private _executeFilterSubscription;
+    private _fetchAgainSubscription;
+    private _refreshDataSubscription;
+    private _textSearchValue;
+    private _forceRefresh;
+    constructor();
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    rebind(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MmListViewDataBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MmListViewDataBindingDirective, "[mmListViewDataBinding]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PascalCasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PascalCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PascalCasePipe, "pascalCase", true>;
+}
+
+declare class BytesToSizePipe implements PipeTransform {
+    transform(value: number, decimals?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BytesToSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BytesToSizePipe, "bytesToSize", true>;
+}
+
+declare enum ImportStrategyDto {
+    InsertOnly = 0,
+    Upsert = 1
+}
+
+declare class FileUploadService {
+    private readonly dialogService;
+    showUploadDialog(title: string, message: string, mimeTypes?: string | null, fileExtensions?: string | null): Promise<File | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileUploadService>;
+}
+
+declare enum ButtonTypes {
+    Ok = 0,
+    Cancel = 1,
+    Yes = 2,
+    No = 3
+}
+declare class ConfirmationWindowResult {
+    result: ButtonTypes;
+    constructor(result: ButtonTypes);
+}
+
+declare class ConfirmationService {
+    private readonly dialogService;
+    showYesNoConfirmationDialog(title: string, message: string): Promise<boolean>;
+    showYesNoCancelConfirmationDialog(title: string, message: string): Promise<ConfirmationWindowResult | undefined>;
+    showOkCancelConfirmationDialog(title: string, message: string): Promise<boolean>;
+    showOkDialog(title: string, message: string): Promise<boolean>;
+    private openDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationService>;
+}
+
+declare class InputService {
+    private readonly dialogService;
+    showInputDialog(title: string, message: string, placeholder: string, buttonOkText?: string | null): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InputService>;
+}
+
+declare class NotificationDisplayService implements OnDestroy {
+    private readonly notificationService;
+    private readonly messageDetailsDialogService;
+    private readonly router;
+    private readonly ngZone;
+    private notificationCounter;
+    private activeNotifications;
+    private subscriptions;
+    private interactionDebounceTime;
+    private gracePeriod;
+    private notificationOpenTimes;
+    private readonly defaultSettings;
+    constructor();
+    ngOnDestroy(): void;
+    private setupNavigationListener;
+    private setupGlobalInteractionListeners;
+    private hasActiveErrorOrWarning;
+    private shouldCloseOnInteraction;
+    private clearErrorAndWarningNotifications;
+    private clearAllNotifications;
+    /**
+     * Helper method to create SVG icon HTML
+     */
+    private createSvgIcon;
+    /**
+     * Shows a success notification (auto-closes after 3 seconds)
+     */
+    showSuccess(title: string, hideAfter?: number): void;
+    /**
+     * Shows an error notification (persists until user interaction or navigation)
+     */
+    showError(title: string, details?: string, hideAfter?: number): void;
+    /**
+     * Shows a warning notification (persists until user interaction or navigation)
+     */
+    showWarning(title: string, details?: string, hideAfter?: number): void;
+    /**
+     * Shows an info notification (auto-closes after 3 seconds)
+     */
+    showInfo(title: string, hideAfter?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationDisplayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationDisplayService>;
+}
+
+/**
+ * Service that listens to MessageService events and displays them as UI notifications.
+ * This service should be initialized at app startup to ensure all messages are displayed.
+ */
+declare class MessageListenerService implements OnDestroy {
+    private readonly messageService;
+    private readonly notificationDisplay;
+    private subscription?;
+    /**
+     * Starts listening to messages from MessageService and displays them as notifications.
+     * Call this once at application startup.
+     */
+    initialize(): void;
+    /**
+     * Stops listening to messages
+     */
+    stop(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageListenerService>;
+}
+
+interface MessageDetailsDialogData {
+    title: string;
+    details: string;
+    level: 'error' | 'warning';
+}
+declare class MessageDetailsDialogComponent implements OnInit {
+    protected readonly copyIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
+    private readonly dialogRef;
+    data: MessageDetailsDialogData;
+    title: string;
+    details: string;
+    level: 'error' | 'warning';
+    ngOnInit(): void;
+    get dialogTitle(): string;
+    onClose(): void;
+    copyToClipboard(): Promise<void>;
+    private fallbackCopyToClipboard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDetailsDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageDetailsDialogComponent, "mm-message-details-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class MessageDetailsDialogService {
+    private readonly dialogService;
+    /**
+     * Opens a modal dialog to show message details with copy-to-clipboard functionality
+     */
+    showDetailsDialog(data: MessageDetailsDialogData): DialogRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDetailsDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageDetailsDialogService>;
+}
+
+/**
+ * Query options for fetching data in the dialog
+ */
+interface DialogFetchOptions {
+    /** Number of items to skip (for paging) */
+    skip: number;
+    /** Number of items to take (page size) */
+    take: number;
+    /** Text search filter */
+    textSearch: string | null;
+}
+/**
+ * Result from fetching data
+ */
+interface DialogFetchResult<T> {
+    /** Data items */
+    data: (T | null)[];
+    /** Total count of items matching the filter */
+    totalCount: number;
+}
+/**
+ * Interface for entity selection dialog data sources.
+ * Combines grid configuration, data fetching, and entity display.
+ */
+interface EntitySelectDialogDataSource<T> {
+    /**
+     * Get column definitions for the grid display
+     * @returns Array of column definitions
+     */
+    getColumns(): ColumnDefinition[];
+    /**
+     * Fetch data for the grid with paging and filtering
+     * @param options Query options including skip, take, and textSearch
+     * @returns Observable of fetch result with data and total count
+     */
+    fetchData(options: DialogFetchOptions): Observable<DialogFetchResult<T>>;
+    /**
+     * Get display text for an entity
+     * @param entity The entity to display
+     * @returns String representation of the entity
+     */
+    onDisplayEntity(entity: T): string;
+    /**
+     * Get unique identifier for an entity
+     * @param entity The entity to get ID from
+     * @returns Unique identifier for the entity
+     */
+    getIdEntity(entity: T): any;
+}
+/**
+ * Options for opening the entity select dialog
+ */
+interface EntitySelectDialogOptions<T> {
+    /** Dialog title */
+    title: string;
+    /** Allow multiple selection */
+    multiSelect?: boolean;
+    /** Pre-selected entities */
+    selectedEntities?: T[];
+    /** Dialog width (default: 800) */
+    width?: number;
+    /** Dialog height (default: 600) */
+    height?: number;
+}
+/**
+ * Result returned from the entity select dialog
+ */
+interface EntitySelectDialogResult<T> {
+    /** Selected entities (single item array for single-select) */
+    selectedEntities: T[];
+}
+
+declare class EntitySelectInputComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
+    autocomplete: AutoCompleteComponent;
+    dataSource: EntitySelectDataSource<any>;
+    placeholder: string;
+    minSearchLength: number;
+    maxResults: number;
+    debounceMs: number;
+    prefix: string;
+    dialogDataSource?: EntitySelectDialogDataSource<any>;
+    dialogTitle: string;
+    multiSelect: boolean;
+    advancedSearchLabel: string;
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    entitySelected: EventEmitter<any>;
+    entityCleared: EventEmitter<void>;
+    entitiesSelected: EventEmitter<any[]>;
+    searchFormControl: FormControl<any>;
+    filteredEntities: string[];
+    selectedEntity: any;
+    isLoading: boolean;
+    private entityMap;
+    private searchSubject;
+    private destroy$;
+    private onChange;
+    private onTouched;
+    protected readonly clearIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly searchIcon: _progress_kendo_svg_icons.SVGIcon;
+    private elRef;
+    private dialogService;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(_isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    onFilterChange(event: any): void;
+    onSelectionChange(value: any): void;
+    onFocus(): void;
+    onBlur(): void;
+    clear(): void;
+    focus(): void;
+    reset(): void;
+    private setupSearch;
+    private selectEntity;
+    openAdvancedSearch(event?: Event): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySelectInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntitySelectInputComponent, "mm-entity-select-input", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "minSearchLength": { "alias": "minSearchLength"; "required": false; }; "maxResults": { "alias": "maxResults"; "required": false; }; "debounceMs": { "alias": "debounceMs"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "dialogDataSource": { "alias": "dialogDataSource"; "required": false; }; "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "multiSelect": { "alias": "multiSelect"; "required": false; }; "advancedSearchLabel": { "alias": "advancedSearchLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "entitySelected": "entitySelected"; "entityCleared": "entityCleared"; "entitiesSelected": "entitiesSelected"; }, never, never, true, never>;
+}
+
+declare class EntitySelectDialogComponent<T> extends DialogContentBase implements OnInit, OnDestroy {
+    private readonly dialogRef;
+    private searchSubject;
+    private destroy$;
+    dataSource: EntitySelectDialogDataSource<T>;
+    multiSelect: boolean;
+    preSelectedEntities: T[];
+    columns: TableColumn[];
+    gridData: {
+        data: T[];
+        total: number;
+    };
+    selectedEntities: T[];
+    selectedKeys: any[];
+    isLoading: boolean;
+    searchValue: string;
+    pageSize: number;
+    skip: number;
+    pageable: PagerSettings;
+    get selectableSettings(): SelectableSettings;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initializeColumns;
+    private setupSearch;
+    private loadData;
+    getDisplayName(column: TableColumn): string;
+    onSearchChange(value: string | null): void;
+    onPageChange(event: PageChangeEvent): void;
+    onSelectionChange(event: SelectionEvent): void;
+    onConfirm(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySelectDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntitySelectDialogComponent<any>, "mm-entity-select-dialog", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "multiSelect": { "alias": "multiSelect"; "required": false; }; "preSelectedEntities": { "alias": "preSelectedEntities"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class EntitySelectDialogService {
+    private readonly dialogService;
+    /**
+     * Opens the entity select dialog
+     * @param dataSource The data source providing grid data and column definitions
+     * @param options Dialog configuration options
+     * @returns Promise resolving to selected entities or null if cancelled
+     */
+    open<T>(dataSource: EntitySelectDialogDataSource<T>, options: EntitySelectDialogOptions<T>): Promise<EntitySelectDialogResult<T> | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySelectDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntitySelectDialogService>;
+}
+
+/**
+ * Guard that prevents navigation when a component has unsaved changes.
+ * The component must implement the HasUnsavedChanges interface.
+ *
+ * Usage in routes:
+ * ```typescript
+ * {
+ *   path: 'edit/:id',
+ *   component: MyEditorComponent,
+ *   canDeactivate: [UnsavedChangesGuard]
+ * }
+ * ```
+ *
+ * The component must implement HasUnsavedChanges:
+ * ```typescript
+ * export class MyEditorComponent implements HasUnsavedChanges {
+ *   hasUnsavedChanges(): boolean {
+ *     return this.form.dirty;
+ *   }
+ *
+ *   async saveChanges(): Promise<boolean> {
+ *     // Save logic here
+ *     return true;
+ *   }
+ * }
+ * ```
+ */
+declare class UnsavedChangesGuard implements CanDeactivate<HasUnsavedChanges> {
+    private readonly confirmationService;
+    canDeactivate(component: HasUnsavedChanges): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsavedChangesGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnsavedChangesGuard>;
+}
+
+/**
+ * Result from checking if a name is available
+ */
+interface NameAvailabilityResult {
+    /** Whether the name is available */
+    isAvailable: boolean;
+    /** Optional message to display (e.g., "Name already exists") */
+    message?: string;
+}
+/**
+ * Interface for Save As dialog data sources.
+ * Provides name validation functionality.
+ */
+interface SaveAsDialogDataSource {
+    /**
+     * Check if a name is available (not already taken)
+     * @param name The name to check
+     * @returns Observable of availability result
+     */
+    checkNameAvailability(name: string): Observable<NameAvailabilityResult>;
+}
+/**
+ * Options for opening the Save As dialog
+ */
+interface SaveAsDialogOptions {
+    /** Dialog title */
+    title: string;
+    /** Label for the name input field */
+    nameLabel?: string;
+    /** Placeholder text for the name input */
+    placeholder?: string;
+    /** Suggested/default name */
+    suggestedName?: string;
+    /** Text for the save button */
+    saveButtonText?: string;
+    /** Text for the cancel button */
+    cancelButtonText?: string;
+    /** Minimum name length (default: 1) */
+    minLength?: number;
+    /** Maximum name length (default: 255) */
+    maxLength?: number;
+    /** Regex pattern for name validation */
+    pattern?: RegExp;
+    /** Error message when pattern doesn't match */
+    patternErrorMessage?: string;
+    /** Dialog width (default: 450) */
+    width?: number;
+    /** Data source for checking name availability (optional) */
+    dataSource?: SaveAsDialogDataSource;
+    /** Debounce time in ms for name availability check (default: 300) */
+    debounceTime?: number;
+}
+/**
+ * Result returned from the Save As dialog
+ */
+interface SaveAsDialogResult {
+    /** Whether the user confirmed (clicked Save) */
+    confirmed: boolean;
+    /** The entered name (only set if confirmed) */
+    name?: string;
+}
+
+declare class SaveAsDialogComponent extends DialogContentBase implements OnInit, OnDestroy {
+    nameControl: FormControl<string>;
+    nameLabel: string;
+    placeholder: string;
+    saveButtonText: string;
+    cancelButtonText: string;
+    minLength: number;
+    maxLength: number;
+    patternErrorMessage: string;
+    isCheckingAvailability: boolean;
+    isNameAvailable: boolean;
+    availabilityMessage: string;
+    private dataSource?;
+    private debounceMs;
+    private subscriptions;
+    private checkSubject;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupAvailabilityCheck;
+    canSave(): boolean;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SaveAsDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SaveAsDialogComponent, "mm-save-as-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class SaveAsDialogService {
+    private readonly dialogService;
+    /**
+     * Opens a Save As dialog
+     * @param options Dialog options including title, suggested name, and optional data source for validation
+     * @returns Promise that resolves with the result containing confirmed status and entered name
+     */
+    showSaveAsDialog(options: SaveAsDialogOptions): Promise<SaveAsDialogResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SaveAsDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SaveAsDialogService>;
+}
+
+/**
+ * The type of time range selection
+ */
+type TimeRangeType = 'year' | 'quarter' | 'month' | 'relative' | 'custom';
+/**
+ * The unit for relative time calculations
+ */
+type RelativeTimeUnit = 'hours' | 'days' | 'weeks' | 'months';
+/**
+ * Represents a time range with start and end dates
+ */
+interface TimeRange {
+    /** Start of the time range */
+    from: Date;
+    /** End of the time range */
+    to: Date;
+}
+/**
+ * Represents a time range as ISO 8601 strings
+ */
+interface TimeRangeISO {
+    /** Start of the time range in ISO 8601 format */
+    from: string;
+    /** End of the time range in ISO 8601 format */
+    to: string;
+}
+/**
+ * Quarter number (1-4)
+ */
+type Quarter = 1 | 2 | 3 | 4;
+/**
+ * Configuration for the time range picker
+ */
+interface TimeRangePickerConfig {
+    /** Available range types to show. Defaults to all. */
+    availableTypes?: TimeRangeType[];
+    /** Minimum selectable year. Defaults to current year - 10. */
+    minYear?: number;
+    /** Maximum selectable year. Defaults to current year + 1. */
+    maxYear?: number;
+    /** Default relative time value. Defaults to 24. */
+    defaultRelativeValue?: number;
+    /** Default relative time unit. Defaults to 'hours'. */
+    defaultRelativeUnit?: RelativeTimeUnit;
+    /** Minimum date for custom range. */
+    minDate?: Date;
+    /** Maximum date for custom range. */
+    maxDate?: Date;
+    /** Show time in custom date pickers. Defaults to false. */
+    showTime?: boolean;
+}
+/**
+ * The current selection state of the time range picker
+ */
+interface TimeRangeSelection {
+    type: TimeRangeType;
+    year?: number;
+    quarter?: Quarter;
+    month?: number;
+    relativeValue?: number;
+    relativeUnit?: RelativeTimeUnit;
+    customFrom?: Date;
+    customTo?: Date;
+}
+/**
+ * Option for dropdown selections
+ */
+interface TimeRangeOption<T = string | number> {
+    value: T;
+    label: string;
+}
+/**
+ * Labels for the time range picker UI
+ */
+interface TimeRangePickerLabels {
+    rangeType?: string;
+    year?: string;
+    quarter?: string;
+    month?: string;
+    relativeValue?: string;
+    relativeUnit?: string;
+    customFrom?: string;
+    customTo?: string;
+    typeYear?: string;
+    typeQuarter?: string;
+    typeMonth?: string;
+    typeRelative?: string;
+    typeCustom?: string;
+    unitHours?: string;
+    unitDays?: string;
+    unitWeeks?: string;
+    unitMonths?: string;
+    quarter1?: string;
+    quarter2?: string;
+    quarter3?: string;
+    quarter4?: string;
+}
+/**
+ * Default labels for the time range picker
+ */
+declare const DEFAULT_TIME_RANGE_LABELS: TimeRangePickerLabels;
+/**
+ * Utility functions for time range calculations
+ */
+declare class TimeRangeUtils {
+    /**
+     * Calculate time range for a specific year
+     */
+    static getYearRange(year: number): TimeRange;
+    /**
+     * Calculate time range for a specific quarter
+     */
+    static getQuarterRange(year: number, quarter: Quarter): TimeRange;
+    /**
+     * Calculate time range for a specific month
+     */
+    static getMonthRange(year: number, month: number): TimeRange;
+    /**
+     * Calculate time range relative to now
+     */
+    static getRelativeRange(value: number, unit: RelativeTimeUnit): TimeRange;
+    /**
+     * Calculate time range from selection
+     */
+    static getTimeRangeFromSelection(selection: TimeRangeSelection): TimeRange | null;
+    /**
+     * Convert TimeRange to ISO 8601 format
+     */
+    static toISO(range: TimeRange): TimeRangeISO;
+    /**
+     * Get current quarter (1-4)
+     */
+    static getCurrentQuarter(): Quarter;
+    /**
+     * Generate year options
+     */
+    static generateYearOptions(minYear: number, maxYear: number): TimeRangeOption<number>[];
+    /**
+     * Generate month options
+     */
+    static generateMonthOptions(): TimeRangeOption<number>[];
+    /**
+     * Generate quarter options with custom labels
+     */
+    static generateQuarterOptions(labels: TimeRangePickerLabels): TimeRangeOption<Quarter>[];
+}
+
+/**
+ * A flexible time range picker component that supports:
+ * - Year selection
+ * - Quarter selection (year + quarter)
+ * - Month selection (year + month)
+ * - Relative time (last N hours/days/weeks/months)
+ * - Custom date range
+ *
+ * @example
+ * ```html
+ * <mm-time-range-picker
+ *   [config]="{ availableTypes: ['year', 'month', 'relative'] }"
+ *   (rangeChange)="onRangeChange($event)">
+ * </mm-time-range-picker>
+ * ```
+ */
+declare class TimeRangePickerComponent implements OnInit, OnChanges {
+    /**
+     * Configuration for the picker
+     */
+    config: TimeRangePickerConfig;
+    /**
+     * Custom labels for the UI
+     */
+    labels: TimeRangePickerLabels;
+    /**
+     * Initial selection to set
+     */
+    initialSelection?: TimeRangeSelection;
+    /**
+     * Emits when the time range changes
+     */
+    rangeChange: EventEmitter<TimeRange>;
+    /**
+     * Emits when the time range changes (ISO format)
+     */
+    rangeChangeISO: EventEmitter<TimeRangeISO>;
+    /**
+     * Emits the current selection state
+     */
+    selectionChange: EventEmitter<TimeRangeSelection>;
+    protected selectedType: i0.WritableSignal<TimeRangeType>;
+    protected selectedYear: i0.WritableSignal<number>;
+    protected selectedQuarter: i0.WritableSignal<Quarter>;
+    protected selectedMonth: i0.WritableSignal<number>;
+    protected relativeValue: i0.WritableSignal<number>;
+    protected relativeUnit: i0.WritableSignal<RelativeTimeUnit>;
+    protected customFrom: i0.WritableSignal<Date>;
+    protected customTo: i0.WritableSignal<Date>;
+    protected mergedLabels: i0.Signal<{
+        rangeType?: string;
+        year?: string;
+        quarter?: string;
+        month?: string;
+        relativeValue?: string;
+        relativeUnit?: string;
+        customFrom?: string;
+        customTo?: string;
+        typeYear?: string;
+        typeQuarter?: string;
+        typeMonth?: string;
+        typeRelative?: string;
+        typeCustom?: string;
+        unitHours?: string;
+        unitDays?: string;
+        unitWeeks?: string;
+        unitMonths?: string;
+        quarter1?: string;
+        quarter2?: string;
+        quarter3?: string;
+        quarter4?: string;
+    }>;
+    protected typeOptions: i0.Signal<TimeRangeOption<TimeRangeType>[]>;
+    protected yearOptions: i0.Signal<TimeRangeOption<number>[]>;
+    protected quarterOptions: i0.Signal<TimeRangeOption<Quarter>[]>;
+    protected monthOptions: i0.Signal<TimeRangeOption<number>[]>;
+    protected relativeUnitOptions: i0.Signal<TimeRangeOption<RelativeTimeUnit>[]>;
+    protected currentRange: i0.Signal<TimeRange | null>;
+    protected minDate: i0.Signal<Date>;
+    protected maxDate: i0.Signal<Date>;
+    protected showTime: i0.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private initializeDefaults;
+    private applySelection;
+    protected onTypeChange(type: TimeRangeType): void;
+    protected onYearChange(year: number): void;
+    protected onQuarterChange(quarter: Quarter): void;
+    protected onMonthChange(month: number): void;
+    protected onRelativeValueChange(value: number): void;
+    protected onRelativeUnitChange(unit: RelativeTimeUnit): void;
+    protected onCustomFromChange(date: Date): void;
+    protected onCustomToChange(date: Date): void;
+    private emitChange;
+    protected isType(type: TimeRangeType): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeRangePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimeRangePickerComponent, "mm-time-range-picker", never, { "config": { "alias": "config"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "initialSelection": { "alias": "initialSelection"; "required": false; }; }, { "rangeChange": "rangeChange"; "rangeChangeISO": "rangeChangeISO"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * Cron Expression Builder - Type definitions and models
+ * Supports 6-field cron format: second minute hour day month weekday
+ */
+type ScheduleType = 'seconds' | 'minutes' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'custom';
+type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+interface CronBuilderConfig {
+    /** Show preset quick-select buttons */
+    showPresets?: boolean;
+    /** Show human-readable description of the cron expression */
+    showHumanReadable?: boolean;
+    /** Show next execution times */
+    showNextExecutions?: boolean;
+    /** Number of next executions to show (default: 3) */
+    maxNextExecutions?: number;
+    /** Show copy to clipboard button */
+    showCopyButton?: boolean;
+    /** Allow custom/advanced tab for direct cron editing */
+    allowCustom?: boolean;
+    /** Default schedule type to show */
+    defaultScheduleType?: ScheduleType;
+    /** Locale for human-readable output ('en' | 'de') */
+    locale?: string;
+}
+declare const DEFAULT_CRON_BUILDER_CONFIG: CronBuilderConfig;
+interface CronSchedule {
+    type: ScheduleType;
+    /** For seconds tab: interval in seconds */
+    secondInterval?: number;
+    /** For minutes tab: interval in minutes */
+    minuteInterval?: number;
+    /** For hourly tab */
+    hourInterval?: number;
+    hourMinute?: number;
+    hourSecond?: number;
+    /** For daily/weekly tab */
+    time?: {
+        hour: number;
+        minute: number;
+        second: number;
+    };
+    /** For daily tab: 'every' | 'weekdays' | 'weekends' | 'specific' */
+    dailyMode?: 'every' | 'weekdays' | 'weekends' | 'specific';
+    /** For weekly/daily specific: selected days (0-6, 0=Sunday) */
+    selectedDays?: Weekday[];
+    /** For monthly tab */
+    monthlyMode?: 'specific' | 'relative';
+    dayOfMonth?: number;
+    relativeWeek?: 'first' | 'second' | 'third' | 'fourth' | 'last';
+    relativeDay?: Weekday;
+    /** For custom tab: raw cron fields */
+    customFields?: CronFields;
+}
+interface CronFields {
+    second: string;
+    minute: string;
+    hour: string;
+    dayOfMonth: string;
+    month: string;
+    dayOfWeek: string;
+}
+interface CronValidationResult {
+    isValid: boolean;
+    error?: string;
+    errorField?: keyof CronFields;
+}
+interface CronPreset {
+    id: string;
+    label: string;
+    description: string;
+    expression: string;
+    category?: 'frequent' | 'hourly' | 'daily' | 'weekly' | 'monthly';
+}
+declare const CRON_PRESETS: CronPreset[];
+interface DropdownOption<T = string | number> {
+    value: T;
+    label: string;
+}
+declare const SECOND_INTERVALS: DropdownOption<number>[];
+declare const MINUTE_INTERVALS: DropdownOption<number>[];
+declare const HOUR_INTERVALS: DropdownOption<number>[];
+declare const WEEKDAYS: DropdownOption<Weekday>[];
+declare const WEEKDAY_ABBREVIATIONS: DropdownOption<Weekday>[];
+declare const RELATIVE_WEEKS: DropdownOption<string>[];
+/** Generate options for hours (0-23) */
+declare function generateHourOptions(): DropdownOption<number>[];
+/** Generate options for minutes/seconds (0-59) */
+declare function generateMinuteOptions(): DropdownOption<number>[];
+/** Generate options for day of month (1-31) */
+declare function generateDayOfMonthOptions(): DropdownOption<number>[];
+
+declare class CronBuilderComponent implements OnInit, ControlValueAccessor {
+    config: CronBuilderConfig;
+    private readonly cronParser;
+    private readonly cronHumanizer;
+    protected readonly copyIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly clockIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly checkIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
+    private onChange;
+    private onTouched;
+    protected disabled: i0.WritableSignal<boolean>;
+    protected readonly expression: i0.WritableSignal<string>;
+    protected readonly selectedTabIndex: i0.WritableSignal<number>;
+    protected readonly copiedRecently: i0.WritableSignal<boolean>;
+    private suppressOnChange;
+    protected readonly scheduleType: i0.WritableSignal<ScheduleType>;
+    protected readonly secondInterval: i0.WritableSignal<number>;
+    protected readonly minuteInterval: i0.WritableSignal<number>;
+    protected readonly hourInterval: i0.WritableSignal<number>;
+    protected readonly hourMinute: i0.WritableSignal<number>;
+    protected readonly hourSecond: i0.WritableSignal<number>;
+    protected readonly timeHour: i0.WritableSignal<number>;
+    protected readonly timeMinute: i0.WritableSignal<number>;
+    protected readonly timeSecond: i0.WritableSignal<number>;
+    protected readonly dailyMode: i0.WritableSignal<"every" | "weekdays" | "weekends" | "specific">;
+    protected readonly selectedDays: i0.WritableSignal<Weekday[]>;
+    protected readonly monthlyMode: i0.WritableSignal<"relative" | "specific">;
+    protected readonly dayOfMonth: i0.WritableSignal<number>;
+    protected readonly relativeWeek: i0.WritableSignal<string>;
+    protected readonly relativeDay: i0.WritableSignal<Weekday>;
+    protected readonly customSecond: i0.WritableSignal<string>;
+    protected readonly customMinute: i0.WritableSignal<string>;
+    protected readonly customHour: i0.WritableSignal<string>;
+    protected readonly customDayOfMonth: i0.WritableSignal<string>;
+    protected readonly customMonth: i0.WritableSignal<string>;
+    protected readonly customDayOfWeek: i0.WritableSignal<string>;
+    protected readonly mergedConfig: i0.Signal<{
+        showPresets?: boolean;
+        showHumanReadable?: boolean;
+        showNextExecutions?: boolean;
+        maxNextExecutions?: number;
+        showCopyButton?: boolean;
+        allowCustom?: boolean;
+        defaultScheduleType?: ScheduleType;
+        locale?: string;
+    }>;
+    protected readonly humanReadable: i0.Signal<string>;
+    protected readonly validationResult: i0.Signal<_meshmakers_shared_ui.CronValidationResult>;
+    protected readonly nextExecutions: i0.Signal<Date[]>;
+    protected readonly presets: i0.Signal<CronPreset[]>;
+    protected readonly presetsByCategory: i0.Signal<{
+        frequent: CronPreset[];
+        hourly: CronPreset[];
+        daily: CronPreset[];
+        weekly: CronPreset[];
+        monthly: CronPreset[];
+    }>;
+    protected readonly secondIntervalOptions: DropdownOption<number>[];
+    protected readonly minuteIntervalOptions: DropdownOption<number>[];
+    protected readonly hourIntervalOptions: DropdownOption<number>[];
+    protected readonly weekdayOptions: DropdownOption<Weekday>[];
+    protected readonly weekdayAbbreviations: DropdownOption<Weekday>[];
+    protected readonly relativeWeekOptions: DropdownOption<string>[];
+    protected readonly hourOptions: DropdownOption<number>[];
+    protected readonly minuteOptions: DropdownOption<number>[];
+    protected readonly dayOfMonthOptions: DropdownOption<number>[];
+    protected readonly tabIndexToType: ScheduleType[];
+    constructor();
+    ngOnInit(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onTabSelect(index: number): void;
+    protected onPresetSelect(preset: CronPreset): void;
+    protected onCopyExpression(): Promise<void>;
+    protected onSecondIntervalChange(value: number): void;
+    protected onMinuteIntervalChange(value: number): void;
+    protected onHourIntervalChange(value: number): void;
+    protected onHourMinuteChange(value: number): void;
+    protected onHourSecondChange(value: number): void;
+    protected onTimeHourChange(value: number): void;
+    protected onTimeMinuteChange(value: number): void;
+    protected onTimeSecondChange(value: number): void;
+    protected onDailyModeChange(mode: 'every' | 'weekdays' | 'weekends' | 'specific'): void;
+    protected onDayToggle(day: Weekday): void;
+    protected isDaySelected(day: Weekday): boolean;
+    protected onMonthlyModeChange(mode: 'specific' | 'relative'): void;
+    protected onDayOfMonthChange(value: number): void;
+    protected onRelativeWeekChange(value: string): void;
+    protected onRelativeDayChange(value: Weekday): void;
+    protected onCustomFieldChange(field: keyof CronFields, value: string): void;
+    protected formatNextExecution(date: Date): string;
+    private buildScheduleFromState;
+    private parseExpressionToState;
+    protected trackByValue(_index: number, item: DropdownOption): number | string;
+    protected trackByPresetId(_index: number, item: CronPreset): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CronBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CronBuilderComponent, "mm-cron-builder", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Service for parsing, validating, and generating cron expressions.
+ * Supports 6-field format: second minute hour dayOfMonth month dayOfWeek
+ */
+declare class CronParserService {
+    /**
+     * Validate a 6-field cron expression
+     */
+    validate(expression: string): CronValidationResult;
+    /**
+     * Parse a cron expression into a structured CronSchedule object
+     */
+    parse(expression: string): CronSchedule | null;
+    /**
+     * Generate a cron expression from a CronSchedule object
+     */
+    generate(schedule: CronSchedule): string;
+    /**
+     * Calculate next execution times for a cron expression
+     */
+    getNextExecutions(expression: string, count?: number): Date[];
+    private detectScheduleType;
+    private detectDailyMode;
+    private parseInterval;
+    private parseSimpleValue;
+    private isSimpleValue;
+    private parseDaysOfWeek;
+    private generateSecondsExpression;
+    private generateMinutesExpression;
+    private generateHourlyExpression;
+    private generateDailyExpression;
+    private generateWeeklyExpression;
+    private generateMonthlyExpression;
+    private generateCustomExpression;
+    private getWeekNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CronParserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CronParserService>;
+}
+
+/**
+ * Service for converting cron expressions to human-readable text.
+ * Supports multiple locales (EN, DE).
+ */
+declare class CronHumanizerService {
+    /**
+     * Convert a cron expression to human-readable text
+     * @param expression The cron expression (5 or 6 fields)
+     * @param locale The locale for output ('en' | 'de')
+     * @returns Human-readable description or error message
+     */
+    toHumanReadable(expression: string, locale?: string): string;
+    /**
+     * Get a detailed description with additional context
+     */
+    toDetailedDescription(expression: string, locale?: string): {
+        summary: string;
+        frequency: string;
+        timing: string;
+    };
+    /**
+     * Check if a locale is supported
+     */
+    isLocaleSupported(locale: string): boolean;
+    /**
+     * Get list of supported locales
+     */
+    getSupportedLocales(): {
+        code: string;
+        name: string;
+    }[];
+    private normalizeLocale;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CronHumanizerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CronHumanizerService>;
+}
+
+/**
+ * A component that displays a read-only text value with a copy-to-clipboard button.
+ *
+ * @example
+ * ```html
+ * <mm-copyable-text
+ *   [value]="rtId"
+ *   label="Runtime ID"
+ *   copyLabel="Runtime ID">
+ * </mm-copyable-text>
+ * ```
+ */
+declare class CopyableTextComponent {
+    /** The value to display and copy. Displays an em-dash when null/undefined/empty. */
+    value: string | null | undefined;
+    /** Optional label displayed above the value. */
+    label?: string;
+    /** Label used in the notification message. Falls back to label, then 'Value'. */
+    copyLabel?: string;
+    /** Tooltip for the copy button. */
+    buttonTitle: string;
+    /** Emitted when the value is successfully copied to clipboard. */
+    copied: EventEmitter<string>;
+    protected readonly copyIcon: _progress_kendo_svg_icons.SVGIcon;
+    private readonly notificationService;
+    /** Returns true if the value is non-empty and can be copied. */
+    protected get hasValue(): boolean;
+    /** Copies the value to clipboard and shows a notification. */
+    protected copyToClipboard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyableTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CopyableTextComponent, "mm-copyable-text", never, { "value": { "alias": "value"; "required": true; }; "label": { "alias": "label"; "required": false; }; "copyLabel": { "alias": "copyLabel"; "required": false; }; "buttonTitle": { "alias": "buttonTitle"; "required": false; }; }, { "copied": "copied"; }, never, never, true, never>;
+}
+
+declare class ImportStrategyDialogResult {
+    strategy: ImportStrategyDto;
+    constructor(strategy: ImportStrategyDto);
+}
+declare class ImportStrategyDialogComponent extends DialogContentBase {
+    private readonly dialogRef;
+    message: string;
+    protected selectedStrategy: ImportStrategyDto;
+    protected readonly ImportStrategyDto: typeof ImportStrategyDto;
+    constructor();
+    onImport(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImportStrategyDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImportStrategyDialogComponent, "mm-import-strategy-dialog", never, { "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ImportStrategyDialogService {
+    private readonly dialogService;
+    showImportStrategyDialog(title?: string, message?: string): Promise<ImportStrategyDto | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImportStrategyDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImportStrategyDialogService>;
+}
+
+declare function provideMmSharedUi(): EnvironmentProviders;
+
+export { BaseFormComponent, BaseTreeDetailComponent, BytesToSizePipe, CRON_PRESETS, ConfirmationService, CopyableTextComponent, CronBuilderComponent, CronHumanizerService, CronParserService, DEFAULT_CRON_BUILDER_CONFIG, DEFAULT_RESPONSIVE_COLSPAN, DEFAULT_TIME_RANGE_LABELS, DataSourceBase, DataSourceTyped, EntitySelectDialogComponent, EntitySelectDialogService, EntitySelectInputComponent, FetchResultBase, FetchResultTyped, FileUploadService, HAS_UNSAVED_CHANGES, HOUR_INTERVALS, HierarchyDataSource, HierarchyDataSourceBase, ImportStrategyDialogComponent, ImportStrategyDialogResult, ImportStrategyDialogService, ImportStrategyDto, InputDialogComponent, InputService, ListViewComponent, MINUTE_INTERVALS, MessageDetailsDialogComponent, MessageDetailsDialogService, MessageListenerService, MmListViewDataBindingDirective, NotificationDisplayService, PascalCasePipe, ProgressValue, ProgressWindowComponent, ProgressWindowService, RELATIVE_WEEKS, SECOND_INTERVALS, SaveAsDialogComponent, SaveAsDialogService, TimeRangePickerComponent, TimeRangeUtils, TreeComponent, UnsavedChangesDirective, UnsavedChangesGuard, UploadFileDialogComponent, WEEKDAYS, WEEKDAY_ABBREVIATIONS, generateDayOfMonthOptions, generateHourOptions, generateMinuteOptions, provideMmSharedUi };
+export type { BaseFormConfig, ColumnDefinition, ContextMenuType, CronBuilderConfig, CronFields, CronPreset, CronSchedule, CronValidationResult, DialogFetchOptions, DialogFetchResult, DropdownOption, EntitySelectDialogDataSource, EntitySelectDialogOptions, EntitySelectDialogResult, FetchDataOptions, FetchResult, HasUnsavedChanges, MessageDetailsDialogData, NameAvailabilityResult, NodeDroppedEvent, NodeInfo, ProgressWindowConfig, ProgressWindowData, ProgressWindowOptions, ProgressWindowResult, Quarter, RelativeTimeUnit, ResponsiveFormBreakPoint, SaveAsDialogDataSource, SaveAsDialogOptions, SaveAsDialogResult, ScheduleType, StatusFieldConfig, StatusIconMapping, StatusMapping, TableColumn, TimeRange, TimeRangeISO, TimeRangeOption, TimeRangePickerConfig, TimeRangePickerLabels, TimeRangeSelection, TimeRangeType, Weekday };