import * as i0 from '@angular/core';
import { OnDestroy, AfterViewInit, EventEmitter, ElementRef, OnInit, InjectionToken, TemplateRef, 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 { AutoCompleteComponent } from '@progress/kendo-angular-dropdowns';
import { DialogContentBase, DialogRef, WindowRef } from '@progress/kendo-angular-dialog';
import { CompositeFilterDescriptor } from '@progress/kendo-data-query';
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' | 'numericRange' | 'boolean' | 'date' | 'iso8601' | 'bytes' | 'statusIcons' | 'cronExpression' | 'progressBar';
    format?: string;
    /**
     * 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;
    /**
     * Whether filtering is enabled for this column.
     * When not set, defaults to true (filterable).
     * Set to false to hide the filter cell for this column when row filtering is active.
     */
    filterable?: boolean;
    /**
     * Default filter operator for the row filter.
     * For numeric columns, defaults to 'eq'. Set to 'gte' for range-style filtering.
     */
    filterOperator?: string;
    /**
     * Dropdown filter options for the row filter.
     * When set, the column's row filter renders a dropdown instead of a text input.
     * Each option has a display text and a value used for filtering.
     */
    filterOptions?: {
        text: string;
        value: string;
    }[];
}
type ColumnDefinition = string | TableColumn;
type ContextMenuType = 'contextMenu' | 'actionMenu';
/**
 * Callback for applying CSS classes to individual grid rows based on data.
 * Mirrors Kendo Grid's RowClassFn signature.
 *
 * @example
 * ```typescript
 * rowClassFn = (context: { dataItem: any; index: number }) => ({
 *   'row-warning': context.dataItem.status === 'warn',
 *   'row-error': context.dataItem.status === 'error'
 * });
 * ```
 */
type RowClassFn = (context: {
    dataItem: unknown;
    index: number;
}) => string | string[] | Set<string> | Record<string, boolean>;
/**
 * Translatable messages for the ListViewComponent.
 * Pass translated strings to override the English defaults.
 */
interface ListViewMessages {
    /** Search input placeholder. Default: "Search in all columns..." */
    searchPlaceholder: string;
    /** Tooltip for "Show Row Filter" button. Default: "Show Row Filter" */
    showRowFilter: string;
    /** Tooltip for "Export to Excel" button. Default: "Export to Excel" */
    exportToExcel: string;
    /** Tooltip for "Export to PDF" button. Default: "Export to PDF" */
    exportToPdf: string;
    /** Tooltip for "Refresh Data" button. Default: "Refresh Data" */
    refreshData: string;
    /** Title for the actions command column. Default: "Actions" */
    actionsColumnTitle: string;
    /** PDF footer page template. Default: "Page {pageNum} of {totalPages}" */
    pdfPageTemplate: string;
    /** Pager: text after page size selector. Default: "items per page" */
    pagerItemsPerPage: string;
    /** Pager: "of" text between page number and total. Default: "of" */
    pagerOf: string;
    /** Pager: text after total count. Default: "items" */
    pagerItems: string;
    /** Pager: text before page input. Default: "Page" */
    pagerPage: string;
    /** Pager: first page button tooltip. Default: "Go to the first page" */
    pagerFirstPage: string;
    /** Pager: last page button tooltip. Default: "Go to the last page" */
    pagerLastPage: string;
    /** Pager: previous page button tooltip. Default: "Go to the previous page" */
    pagerPreviousPage: string;
    /** Pager: next page button tooltip. Default: "Go to the next page" */
    pagerNextPage: string;
    /** Grid: no records message. Default: "No records available." */
    noRecords: string;
}
/**
 * Default English messages for the ListViewComponent.
 */
declare const DEFAULT_LIST_VIEW_MESSAGES: ListViewMessages;

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: i0.WritableSignal<boolean>;
    private gridComponent?;
    private dataBindingDirective?;
    gridContextMenu?: ContextMenuComponent;
    rowClicked: EventEmitter<unknown[]>;
    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;
    /**
     * Callback for applying CSS classes to grid rows based on row data.
     * Passed through to Kendo Grid's [rowClass] input.
     */
    rowClass: RowClassFn | undefined;
    protected readonly defaultRowClass: RowClassFn;
    protected _messages: ListViewMessages;
    set messages(value: Partial<ListViewMessages>);
    get messages(): ListViewMessages;
    selectable: SelectableSettings;
    set columns(cols: ColumnDefinition[]);
    get columns(): TableColumn[];
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    protected getDisplayName(column: TableColumn): string;
    protected getIsDisabled(commandItem: CommandItem, dataItem?: unknown): boolean;
    protected getValue(element: Record<string, unknown>, column: TableColumn): unknown;
    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: Record<string, unknown>, 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: unknown): string;
    protected hasFilterOptions(column: TableColumn): boolean;
    protected getSelectedFilterValue(column: TableColumn): string | null;
    protected onDropdownFilter(value: string | null, column: TableColumn): void;
    protected getRangeFilterValue(column: TableColumn, operator: 'gte' | 'lte'): number | null;
    protected onRangeFilterChange(value: number | null, column: TableColumn, operator: 'gte' | 'lte'): void;
    protected onShowRowFilter(): void;
    protected onRefresh(): void;
    onExecuteFilter: EventEmitter<string | null>;
    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: unknown, menuItem: MenuItem): Promise<void>;
    protected getMenuItemVisible(menuItem: MenuItem, dataItem: unknown): boolean;
    protected getMenuItemDisabled(menuItem: MenuItem, dataItem: unknown): boolean;
    protected onContextMenu(dataItem: unknown, e: PointerEvent): void;
    private buildContextMenuItemsWithDisabledState;
    protected onContextMenuClosed(_event: ContextMenuPopupEvent): void;
    protected onToolbarCommand(commandItem: CommandItem): Promise<void>;
    protected onToolbarDropdownItemClick(childItem: CommandItem): Promise<void>;
    private buildMenuItems;
    protected getPdfPageText(pageNum: number, totalPages: number): string;
    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; }; "rowClass": { "alias": "rowClass"; "required": false; }; "messages": { "alias": "messages"; "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: Event): 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: string | 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: string[];
    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<TreeItemData>;
    nodeClick: EventEmitter<TreeItemData>;
    nodeDoubleClick: EventEmitter<TreeItemData>;
    nodeDrop: EventEmitter<NodeDroppedEvent<unknown>>;
    expand: EventEmitter<TreeItemData>;
    collapse: EventEmitter<TreeItemData>;
    protected get rootNodes(): Observable<TreeItemData[]>;
    protected hasChildren: (item: object) => boolean;
    protected isExpanded: (item: object, _index: string) => boolean;
    protected fetchChildren: (item: object) => Observable<object[]>;
    protected onNodeSelect(treeItem: TreeItem): void;
    protected onNodeClick(event: NodeClickEvent): void;
    protected onNodeDoubleClick(event: NodeClickEvent): void;
    protected onExpand(event: TreeItem): void;
    protected onCollapse(event: TreeItem): 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(): string[];
    collapseAll(): void;
    setExpandedKeys(keys: string[]): 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>;
}

/**
 * Messages for the unsaved changes confirmation dialog.
 * All properties are optional — English defaults are used for any missing values.
 */
interface UnsavedChangesMessages {
    /** Dialog title (default: "Unsaved Changes") */
    title?: string;
    /** Message when component supports saving (default: "You have unsaved changes. Do you want to save before leaving?") */
    savePrompt?: string;
    /** Message when component does not support saving (default: "You have unsaved changes. Are you sure you want to leave? Your changes will be lost.") */
    discardPrompt?: string;
    /** Label for the "Yes" button (default: "Yes") */
    yesButton?: string;
    /** Label for the "No" button (default: "No") */
    noButton?: string;
    /** Label for the "Cancel" button (default: "Cancel") */
    cancelButton?: string;
}
/**
 * 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>;
    /**
     * Optional translated messages for the confirmation dialog.
     * If not provided, English defaults are used.
     */
    unsavedChangesMessages?(): UnsavedChangesMessages;
}
/**
 * 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>;
}

declare class FormTitleExtraDirective {
    readonly templateRef: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormTitleExtraDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormTitleExtraDirective, "[mmFormTitleExtra]", never, {}, {}, never, never, true, never>;
}
interface ResponsiveFormBreakPoint {
    maxWidth: number;
    value: number;
}
/**
 * Translatable messages for the base form.
 * All properties are optional — English defaults are used as fallbacks.
 */
interface BaseFormMessages {
    /** Default title when isViewMode is true (default: 'View Details') */
    viewTitle?: string;
    /** Default title when isEditMode is true (default: 'Edit') */
    editTitle?: string;
    /** Default title for new items (default: 'New') */
    newTitle?: string;
    /** Save button text when saving is in progress (default: 'Saving...') */
    savingText?: string;
    /** Save button text in edit mode (default: 'Update') */
    updateText?: string;
    /** Save button text in create mode (default: 'Create') */
    createText?: string;
    /** Cancel button text in view mode (default: 'Back') */
    backText?: string;
    /** Cancel button text (default: 'Cancel') */
    cancelText?: string;
    /** Save button text (default: 'Save') */
    saveText?: string;
    /** Badge text for unsaved changes (default: 'Unsaved Changes') */
    unsavedChangesText?: string;
    /** Loading overlay text (default: 'Loading...') */
    loadingText?: string;
    /** Status text when form has changes (default: 'MODIFIED') */
    modifiedText?: string;
    /** Status text when form is clean (default: 'READY') */
    readyText?: string;
}
interface BaseFormConfig {
    title?: string;
    cardWidth?: string;
    showCard?: boolean;
    saveButtonText?: string;
    cancelButtonText?: string;
    isEditMode?: boolean;
    isViewMode?: boolean;
    isLoading?: boolean;
    isSaving?: boolean;
    showCancelButton?: boolean;
    showLoadingOverlay?: boolean;
    /**
     * Whether to show the title row. Defaults to true.
     * Set to false to hide the title (useful when the form is embedded in a tab).
     */
    showTitle?: boolean;
    /**
     * Indicates whether the form has unsaved changes.
     * When true, displays a "Modified" indicator in the header and footer.
     */
    hasChanges?: boolean;
    /**
     * Translatable messages for all static texts in the form.
     * Allows consuming applications to provide localized strings.
     */
    messages?: BaseFormMessages;
}
declare const DEFAULT_RESPONSIVE_COLSPAN: ResponsiveFormBreakPoint[];
declare class BaseFormComponent implements HasUnsavedChanges {
    titleExtra?: FormTitleExtraDirective;
    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 unsavedChangesText(): string;
    protected get loadingText(): string;
    protected get modifiedText(): string;
    protected get readyText(): string;
    protected get showSaveButton(): boolean;
    protected get showCancelButton(): 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"; }, ["titleExtra"], ["*", "[additionalActions]"], true, [{ directive: typeof UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
}

declare class BaseTreeDetailComponent<T = unknown> 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: TreeItemData): void;
    protected onNodeDrop(event: NodeDroppedEvent<unknown>): 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(): string[];
    collapseAll(): void;
    setExpandedKeys(keys: string[]): 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<T = unknown> {
    get data(): T;
    get totalCount(): number;
}
declare class FetchResultBase<T = unknown> implements FetchResult<T> {
    private readonly _data;
    private readonly _totalCount;
    constructor(_data: T, _totalCount: number);
    get data(): T;
    get totalCount(): number;
}
declare class FetchResultTyped<TDto> implements FetchResult<(TDto | null)[]> {
    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(): void;
    ngOnDestroy(): void;
    /**
     * Triggers a rebind when the filter state changes programmatically.
     * Syncs the grid's filter into the DataBindingDirective state before rebinding.
     */
    notifyFilterChange(filter: CompositeFilterDescriptor): 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 enum ButtonTypes {
    Ok = 0,
    Cancel = 1,
    Yes = 2,
    No = 3
}
declare enum DialogType {
    YesNo = 0,
    YesNoCancel = 1,
    OkCancel = 2,
    Ok = 3
}
interface ConfirmationButtonLabels {
    yes?: string;
    no?: string;
    ok?: string;
    cancel?: string;
}
interface ConfirmationWindowData {
    title: string;
    message: string;
    dialogType: DialogType;
    buttonLabels?: ConfirmationButtonLabels;
}
declare class ConfirmationWindowResult {
    result: ButtonTypes;
    constructor(result: ButtonTypes);
}
interface FileUploadData {
    title: string;
    message: string;
    mimeTypes: string;
    fileExtensions: string | null;
}
declare class FileUploadResult {
    selectedFile: File | null;
    constructor(selectedFile: File);
}

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 class ConfirmationService {
    private readonly dialogService;
    showYesNoConfirmationDialog(title: string, message: string, cssClass?: string, buttonLabels?: ConfirmationButtonLabels): Promise<boolean>;
    showYesNoCancelConfirmationDialog(title: string, message: string, buttonLabels?: ConfirmationButtonLabels): 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';
    copyLabel?: string;
    closeLabel?: string;
}
declare class MessageDetailsDialogComponent implements OnInit {
    protected readonly copyIcon: _progress_kendo_svg_icons.SVGIcon;
    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
    private readonly windowRef;
    data: MessageDetailsDialogData;
    details: string;
    copyLabel: string;
    closeLabel: string;
    ngOnInit(): void;
    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 windowService;
    private readonly windowStateService;
    /**
     * Opens a resizable window to show message details with copy-to-clipboard functionality
     */
    showDetailsDialog(data: MessageDetailsDialogData): WindowRef;
    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): string;
}
/**
 * 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;
    /** Translatable messages for the dialog UI */
    messages?: Partial<EntitySelectDialogMessages>;
}
/**
 * Result returned from the entity select dialog
 */
interface EntitySelectDialogResult<T> {
    /** Selected entities (single item array for single-select) */
    selectedEntities: T[];
}
/**
 * Translatable messages for the entity select dialog.
 */
interface EntitySelectDialogMessages {
    /** Search textbox placeholder. Default: "Search..." */
    searchPlaceholder: string;
    /** Cancel button text. Default: "Cancel" */
    cancelButton: string;
    /** Confirm button text. Default: "OK" */
    confirmButton: string;
    /** Text appended to the count of selected items (e.g. "3 selected"). Default: "selected" */
    selectedSuffix: string;
    /** Pager: "items per page" label */
    pagerItemsPerPage: string;
    /** Pager: "of" label between current and total */
    pagerOf: string;
    /** Pager: "items" label */
    pagerItems: string;
    /** Pager: "Page" label */
    pagerPage: string;
    /** Pager: tooltip for first page button */
    pagerFirstPage: string;
    /** Pager: tooltip for last page button */
    pagerLastPage: string;
    /** Pager: tooltip for previous page button */
    pagerPreviousPage: string;
    /** Pager: tooltip for next page button */
    pagerNextPage: string;
}
declare const DEFAULT_ENTITY_SELECT_DIALOG_MESSAGES: EntitySelectDialogMessages;
/**
 * Translatable messages for the entity select input.
 */
interface EntitySelectInputMessages {
    /** Autocomplete placeholder. Default: "Select an entity..." */
    placeholder: string;
    /** Advanced search link/button label. Default: "Advanced Search..." */
    advancedSearchLabel: string;
    /** Default dialog title. Default: "Select Entity" */
    dialogTitle: string;
    /** Template for "no results" message. Use {0} for the search term. Default: "No entities found for \"{0}\"" */
    noEntitiesFound: string;
    /** Template for minimum characters hint. Use {0} for the minimum count. Default: "Type at least {0} characters to search..." */
    minCharactersHint: string;
    /** Text appended to count for multi-select display (e.g. "3 selected"). Default: "selected" */
    selectedSuffix: string;
}
declare const DEFAULT_ENTITY_SELECT_INPUT_MESSAGES: EntitySelectInputMessages;

declare class EntitySelectInputComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    autocomplete: AutoCompleteComponent;
    dataSource: EntitySelectDataSource<any>;
    placeholder: string;
    minSearchLength: number;
    maxResults: number;
    debounceMs: number;
    prefix: string;
    set initialDisplayValue(value: string | undefined);
    dialogDataSource?: EntitySelectDialogDataSource<any>;
    dialogTitle: string;
    multiSelect: boolean;
    advancedSearchLabel: string;
    dialogMessages?: Partial<EntitySelectDialogMessages>;
    _messages: EntitySelectInputMessages;
    set messages(value: Partial<EntitySelectInputMessages>);
    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: unknown;
    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;
    formatMessage(template: string, ...args: unknown[]): string;
    ngOnInit(): void;
    ngOnDestroy(): void;
    writeValue(value: unknown): void;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(_isDisabled: boolean): void;
    validate(control: AbstractControl): ValidationErrors | null;
    onFilterChange(event: string): void;
    onSelectionChange(value: string): 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; }; "initialDisplayValue": { "alias": "initialDisplayValue"; "required": false; }; "dialogDataSource": { "alias": "dialogDataSource"; "required": false; }; "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "multiSelect": { "alias": "multiSelect"; "required": false; }; "advancedSearchLabel": { "alias": "advancedSearchLabel"; "required": false; }; "dialogMessages": { "alias": "dialogMessages"; "required": false; }; "messages": { "alias": "messages"; "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> implements OnInit, OnDestroy {
    private readonly windowRef;
    private searchSubject;
    private destroy$;
    dataSource: EntitySelectDialogDataSource<T>;
    multiSelect: boolean;
    preSelectedEntities: T[];
    _messages: EntitySelectDialogMessages;
    set messages(value: Partial<EntitySelectDialogMessages>);
    columns: TableColumn[];
    gridData: {
        data: T[];
        total: number;
    };
    selectedEntities: T[];
    selectedKeys: string[];
    isLoading: boolean;
    searchValue: string;
    pageSize: number;
    skip: number;
    pageable: PagerSettings;
    get selectableSettings(): SelectableSettings;
    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; }; "messages": { "alias": "messages"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EntitySelectDialogService {
    private readonly windowService;
    private readonly windowStateService;
    /**
     * 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' | 'day' | '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;
    /** Day of month (1-31), used with 'day' type */
    day?: number;
    /** Hour from (0-23), optional hour filter for 'day' type */
    hourFrom?: number;
    /** Hour to (1-24), optional hour filter for 'day' type. Exclusive upper bound. */
    hourTo?: 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;
    day?: string;
    relativeValue?: string;
    relativeUnit?: string;
    hourFrom?: string;
    hourTo?: string;
    customFrom?: string;
    customTo?: string;
    typeYear?: string;
    typeQuarter?: string;
    typeMonth?: string;
    typeDay?: 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.
     * Uses exclusive end boundary (start of next year) for correct LESS_THAN filtering.
     */
    static getYearRange(year: number): TimeRange;
    /**
     * Calculate time range for a specific quarter.
     * Uses exclusive end boundary (start of next quarter) for correct LESS_THAN filtering.
     */
    static getQuarterRange(year: number, quarter: Quarter): TimeRange;
    /**
     * Calculate time range for a specific month.
     * Uses exclusive end boundary (start of next month) for correct LESS_THAN filtering.
     */
    static getMonthRange(year: number, month: number): TimeRange;
    /**
     * Calculate time range for a specific day.
     * Uses exclusive end boundary (start of next day) for correct LESS_THAN filtering.
     * Optionally filters to a specific hour range within the day.
     * @param hourFrom Start hour (0-23), defaults to 0
     * @param hourTo End hour (1-24, exclusive), defaults to 24 (= next day 00:00)
     */
    static getDayRange(year: number, month: number, day: number, hourFrom?: number, hourTo?: number): TimeRange;
    /**
     * Calculate time range relative to now
     */
    static getRelativeRange(value: number, unit: RelativeTimeUnit): TimeRange;
    /**
     * Calculate time range from selection.
     * @param selection The current selection state
     * @param showTime If false (default), custom date ranges are normalized to full-day boundaries
     *                 with exclusive end (from: 00:00:00 UTC, to: start of next day 00:00:00 UTC)
     */
    static getTimeRangeFromSelection(selection: TimeRangeSelection, showTime?: boolean): 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 selectedDay: i0.WritableSignal<number>;
    protected relativeValue: i0.WritableSignal<number>;
    protected relativeUnit: i0.WritableSignal<RelativeTimeUnit>;
    protected hourFrom: i0.WritableSignal<number | null>;
    protected hourTo: i0.WritableSignal<number | null>;
    protected customFrom: i0.WritableSignal<Date>;
    protected customTo: i0.WritableSignal<Date>;
    protected mergedLabels: i0.Signal<{
        rangeType?: string;
        year?: string;
        quarter?: string;
        month?: string;
        day?: string;
        relativeValue?: string;
        relativeUnit?: string;
        hourFrom?: string;
        hourTo?: string;
        customFrom?: string;
        customTo?: string;
        typeYear?: string;
        typeQuarter?: string;
        typeMonth?: string;
        typeDay?: 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 dayOptions: i0.Signal<TimeRangeOption<number>[]>;
    protected hourFromOptions: i0.Signal<TimeRangeOption<number>[]>;
    protected hourToOptions: 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 onDayChange(day: number): void;
    protected onHourFromChange(hour: number | null): void;
    protected onHourToChange(hour: number | null): void;
    protected clearHourFilter(): 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>;
}

interface WindowDimensions {
    width: number;
    height: number;
}
declare class WindowStateService {
    private readonly storageKey;
    private activeBackdrops;
    getDimensions(dialogKey: string): WindowDimensions | null;
    saveDimensions(dialogKey: string, dimensions: WindowDimensions): void;
    clearDimensions(dialogKey: string): void;
    resolveWindowSize(dialogKey: string, defaults: WindowDimensions): WindowDimensions;
    captureAndSave(dialogKey: string, windowElement: HTMLElement): void;
    /**
     * Applies modal behavior to a Kendo WindowRef: shows a dark backdrop overlay
     * that blocks interaction with the background, and removes it when the window closes.
     * Also captures and saves window dimensions on close.
     */
    applyModalBehavior(dialogKey: string, windowRef: WindowRef): void;
    private showBackdrop;
    private hideBackdrop;
    private getOrCreateBackdropElement;
    private loadStates;
    private saveStates;
    static ɵfac: i0.ɵɵFactoryDeclaration<WindowStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WindowStateService>;
}

declare function provideMmSharedUi(): EnvironmentProviders;

export { BaseFormComponent, BaseTreeDetailComponent, ButtonTypes, BytesToSizePipe, CRON_PRESETS, ConfirmationService, ConfirmationWindowResult, CopyableTextComponent, CronBuilderComponent, CronHumanizerService, CronParserService, DEFAULT_CRON_BUILDER_CONFIG, DEFAULT_ENTITY_SELECT_DIALOG_MESSAGES, DEFAULT_ENTITY_SELECT_INPUT_MESSAGES, DEFAULT_LIST_VIEW_MESSAGES, DEFAULT_RESPONSIVE_COLSPAN, DEFAULT_TIME_RANGE_LABELS, DataSourceBase, DataSourceTyped, DialogType, EntitySelectDialogComponent, EntitySelectDialogService, EntitySelectInputComponent, FetchResultBase, FetchResultTyped, FileUploadResult, FileUploadService, FormTitleExtraDirective, 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, WindowStateService, generateDayOfMonthOptions, generateHourOptions, generateMinuteOptions, provideMmSharedUi };
export type { BaseFormConfig, BaseFormMessages, ColumnDefinition, ConfirmationButtonLabels, ConfirmationWindowData, ContextMenuType, CronBuilderConfig, CronFields, CronPreset, CronSchedule, CronValidationResult, DialogFetchOptions, DialogFetchResult, DropdownOption, EntitySelectDialogDataSource, EntitySelectDialogMessages, EntitySelectDialogOptions, EntitySelectDialogResult, EntitySelectInputMessages, FetchDataOptions, FetchResult, FileUploadData, HasUnsavedChanges, ListViewMessages, MessageDetailsDialogData, NameAvailabilityResult, NodeDroppedEvent, NodeInfo, ProgressWindowConfig, ProgressWindowData, ProgressWindowOptions, ProgressWindowResult, Quarter, RelativeTimeUnit, ResponsiveFormBreakPoint, RowClassFn, SaveAsDialogDataSource, SaveAsDialogOptions, SaveAsDialogResult, ScheduleType, StatusFieldConfig, StatusIconMapping, StatusMapping, TableColumn, TimeRange, TimeRangeISO, TimeRangeOption, TimeRangePickerConfig, TimeRangePickerLabels, TimeRangeSelection, TimeRangeType, UnsavedChangesMessages, Weekday, WindowDimensions };