import * as i0 from '@angular/core';
import { TemplateRef, EventEmitter, ElementRef, ModuleWithProviders, OnInit, AfterContentInit, AfterContentChecked, Renderer2, ChangeDetectorRef, OnDestroy, PipeTransform, AfterViewChecked, OnChanges, SimpleChanges, AfterViewInit, NgZone, QueryList, InjectionToken, ViewContainerRef, Injector, ComponentRef, Optional, DoCheck } from '@angular/core';
import * as i1 from '@angular/common';
import * as rxjs from 'rxjs';
import { Observable, Subscription, Subject, BehaviorSubject } from 'rxjs';
import * as i1$1 from '@angular/cdk/overlay';
import { CdkConnectedOverlay, ConnectedOverlayPositionChange, ScrollStrategy, ComponentType, OverlayRef, FlexibleConnectedPositionStrategyOrigin, ViewportRuler, Overlay, ConnectedPosition } from '@angular/cdk/overlay';
import * as i5 from '@angular/forms';
import { ControlValueAccessor, AbstractControl, FormGroupDirective, NgForm, NgControl, Validator, ValidationErrors } from '@angular/forms';
import * as i7 from '@angular/cdk/bidi';
import { Directionality, Direction } from '@angular/cdk/bidi';
import { CdkAccordion, CdkAccordionItem } from '@angular/cdk/accordion';
import * as i3 from '@angular/cdk/portal';
import { TemplatePortal, ComponentPortal, CdkPortalOutlet, CdkPortal } from '@angular/cdk/portal';
import { FocusableOption, FocusOrigin, ActiveDescendantKeyManager, FocusKeyManager } from '@angular/cdk/a11y';
import * as i1$3 from '@angular/cdk/dialog';
import { DialogConfig, CdkDialogContainer, DialogRef, Dialog } from '@angular/cdk/dialog';
import * as i1$2 from '@angular/cdk/scrolling';
import * as i3$1 from '@angular/cdk/stepper';
import { CdkStepLabel, StepState, CdkStep, CdkStepper, CdkStepperNext, CdkStepperPrevious, CdkStepHeader } from '@angular/cdk/stepper';
export { StepState, StepperOrientation } from '@angular/cdk/stepper';
import { SelectionModel } from '@angular/cdk/collections';
import { ModifierKey } from '@angular/cdk/keycodes';
/**
* Component for displaying a collapsible content.
*
*
* Example of usage:
*```
*
*
*
* Card Title
*
*
*
*
Content inside collapse
*
*
*
*```
* https://platform.mef.dev/ui_kit_demo/view/page_components/collapse
*/
declare class CollapseComponent {
private _collapseSet;
private _elementRef;
private _disabled;
_active: boolean;
_el: any;
/**
* ContentChild for the template of the card title.
*
* Example:
* ```
*
* Card Title
*
* ```
*/
CardTitle: TemplateRef;
/**
* Indicates whether the collapse is disabled.
* Set this to `true` to disable the collapse. Defaults to `false`.
*/
set Disabled(value: boolean);
get Disabled(): boolean;
/**
* Indicates whether the collapse is active or not.
*/
set Active(value: boolean);
get Active(): boolean;
/**
* Event emitter for the state change of the collapse.
* Emits a boolean value indicating whether the collapse is active or not.
*
* Example:
* ```
* ;
/**
* Event handler for the header click event.
* Toggles the active state of the collapse and emits the state change event.
*
* @param $event The mouse event object.
*/
clickHeader($event: MouseEvent): void;
constructor(_collapseSet: CollapseSetComponent, _elementRef: ElementRef);
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Component representing a set of collapsible panels.
*
* Example of usage:
*
*```
*
*
*
* Panel 1
* Panel 1 content...
*
*
*
* Panel 2
* Panel 2 content...
*
*
*
* Panel 3
* Panel 3 content...
*
*
*```
*/
declare class CollapseSetComponent {
private _accordion;
private _horizontal;
private _expandAny;
panels: CollapseComponent[];
/**
* Indicates whether multiple panels can be expanded simultaneously.
* Set this to `true` to allow multiple panels to be expanded. Defaults to `false`.
*/
set expandAny(value: boolean);
get expandAny(): boolean;
/**
* Indicates whether the collapse set operates as an accordion.
* Set this to `true` to enable accordion behavior. Defaults to `false`.
*/
set Accordion(value: boolean);
get Accordion(): boolean;
/**
* Indicates whether the collapse set is displayed horizontally or vertically.
* Set this to `true` for horizontal display and `false` for vertical display. Defaults to `true`.
*/
set Horizontal(value: boolean);
get Horizontal(): boolean;
/**
* Event handler for the click event on a collapse panel.
* Closes other panels if the collapse set is an accordion and does not allow multiple expansions.
*
* @param collapse The clicked collapse component.
*/
pgClick(collapse: CollapseComponent): void;
/**
* Adds a collapse panel to the collapse set.
*
* @param collapse The collapse component to be added.
*/
addTab(collapse: CollapseComponent): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare const mefDevCollapseModuleComponents: (typeof CollapseComponent | typeof CollapseSetComponent)[];
declare class MefDevCollapseModule {
static forRoot(): ModuleWithProviders;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
declare class FiltredItemModel {
constructor(id: string, newValue: string, standartValue: string, discard: (standartValue: string) => any);
id: string;
newValue: string;
standartValue: string;
discard: (standartValue: string) => any;
}
declare class FilteredFieldService {
private newFilterItem;
private openFilter;
constructor();
/**
* Returns an observable that emits the open filter events.
*/
getOpenFilter(): Observable;
/**
* Sends an open filter event with the specified item.
* @param item The filtered item model.
*/
sendOpenFilter(item: FiltredItemModel): void;
/**
* Returns an observable that emits the new filter item events.
*/
getNewFilterItem(): Observable;
/**
* Sends a new filter item event with the specified item.
* @param item The filtered item model.
*/
sendNewFilterItem(item: FiltredItemModel): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵprov: i0.ɵɵInjectableDeclaration;
}
/**
* A container component for filtered fields.
*
* Example of usage:
* ```
*
*
*
*
*
*
* ```
* Example of usage:
* https://platform.mef.dev/ui_kit_demo/view/utils/filtered_field
*/
declare class FilteredFieldContainerComponent implements OnInit {
private service;
/**
* An array of filtered item models.
*/
items: FiltredItemModel[];
constructor(service: FilteredFieldService);
/**
* Event handler for opening the filter.
*
* @param item The filtered item model.
*/
onOpenFilter(item: FiltredItemModel): void;
/**
* Event handler for discarding the filter.
*
* @param item The filtered item model.
*/
onDiscard(item: FiltredItemModel): void;
ngOnInit(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Component representing a filtered field item.
*
* Example of usage:
* ```
*
*
*```
*
*/
declare class FilteredFieldItemComponent implements OnInit {
/**
* The filtered item model.
* ```
*
* Content goes here...
*
* ```
*/
item: FiltredItemModel;
/**
* Event emitted when the filter is discarded.
* ```
*
* Content goes here...
*
* ```
*/
discard: EventEmitter;
/**
* Event emitted when the filter is opened.
* ```
*
* Content goes here...
*
* ```
*/
openFilter: EventEmitter;
constructor();
ngOnInit(): void;
/**
* Event handler for opening the filter.
* Emits the `openFilter` event.
*/
onOpenFilter(): void;
/**
* Event handler for discarding the filter.
* Emits the `discard` event with the `item` as the payload.
*/
onDiscard(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevFilteredFieldModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* Component for displaying a simple card with a title.
*
* Example of usage:
*```
*
*
*
*
*
*```
*
* https://platform.mef.dev/ui_kit_demo/view/page_components/card/card_simple
*/
declare class CardSimpleComponent implements OnInit {
/**
* Determines whether the card is disabled or not.
*/
isDisabled: boolean;
/**
* Template for displaying the title of the card.
*```
*
*
* Card Title
*
*
*```
*/
card_title: TemplateRef;
constructor();
ngOnInit(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Example of usage:
* https://platform.mef.dev/ui_kit_demo/view/controls/select
*/
declare class MefDevSelectComponent implements OnInit, AfterContentInit, AfterContentChecked, ControlValueAccessor {
private _elementRef;
private _renderer;
private cDRef;
private _allowClear;
private _disabled;
private _isTags;
private _isMultiple;
private _keepUnListOptions;
private _showSearch;
_el: HTMLElement;
_isOpen: boolean;
_prefixCls: string;
_classList: string[];
_dropDownClassMap: any;
_dropDownPrefixCls: string;
_selectionClassMap: any;
_selectionPrefixCls: string;
_size: string;
_value: string[] | string;
_placeholder: string;
_notFoundContent: string;
_searchText: string;
_triggerWidth: number;
_selectedOption: MefDevOptionComponent;
_operatingMultipleOption: MefDevOptionComponent;
_selectedOptions: Set;
_options: MefDevOptionComponent[];
_cacheOptions: MefDevOptionComponent[];
_filterOptions: MefDevOptionComponent[];
_tagsOptions: MefDevOptionComponent[];
_activeFilterOption: MefDevOptionComponent;
_isMultiInit: boolean;
_dropDownPosition: "top" | "center" | "bottom";
_composing: boolean;
_mode: any;
onChange: (value: string | string[]) => void;
onTouched: () => void;
searchInputElementRef: any;
trigger: ElementRef;
dropdownUl: ElementRef;
SearchChange: EventEmitter;
change: EventEmitter;
OpenChange: EventEmitter;
ScrollToBottom: EventEmitter;
Filter: boolean;
MaxMultiple: number;
FirstDefault: boolean;
_cdkOverlay: CdkConnectedOverlay;
set AllowClear(value: boolean);
get AllowClear(): boolean;
set KeepUnListOptions(value: boolean);
get KeepUnListOptions(): boolean;
set Mode(value: string);
set Multiple(value: boolean);
get Multiple(): boolean;
set PlaceHolder(value: string);
get PlaceHolder(): string;
set NotFoundContent(value: string);
get NotFoundContent(): string;
set Size(value: string);
get Size(): string;
set ShowSearch(value: boolean);
get ShowSearch(): boolean;
set Tags(value: boolean);
get Tags(): boolean;
set Disabled(value: boolean);
get Disabled(): boolean;
set Open(value: boolean);
get Open(): boolean;
/** new -option insert or new tags insert */
addOption: (option: any) => void;
/** -option remove or tags remove */
removeOption(option: MefDevOptionComponent): void;
/** dropdown position changed */
onPositionChange(position: ConnectedOverlayPositionChange): void;
compositionStart(): void;
compositionEnd(): void;
/** clear single selected option */
clearSelect($event?: MouseEvent): void;
/** click dropdown option by user */
clickOption(option: MefDevOptionComponent, $event?: MouseEvent): void;
/** choose option */
chooseOption(option: MefDevOptionComponent, isUserClick?: boolean, $event?: MouseEvent): void;
updateWidth(element: HTMLInputElement, text: string): void;
/** determine if option in set */
isInSet(set: Set, option: MefDevOptionComponent): MefDevOptionComponent;
/** cancel select multiple option */ unSelectMultipleOption: (option: any, $event?: any, emitChange?: boolean) => void;
/** select multiple option */
selectMultipleOption(option: MefDevOptionComponent, $event?: MouseEvent): void;
/** emit multiple options */
emitMultipleOptions(): void;
/** update selected option when add remove option etc */
updateSelectedOption(currentModelValue: string | string[], triggerByNgModel?: boolean): void;
forceUpdateSelectedOption(value: string | string[]): void;
get Value(): string | string[];
set Value(value: string | string[]);
clearAllSelectedOption(emitChange?: boolean): void;
handleKeyEnterEvent(event: KeyboardEvent): void;
handleKeyBackspaceEvent(event: KeyboardEvent): void;
handleKeyDownEvent($event: MouseEvent): void;
handleKeyUpEvent($event: MouseEvent): void;
preOption(option: MefDevOptionComponent, options: MefDevOptionComponent[]): MefDevOptionComponent;
nextOption(option: MefDevOptionComponent, options: MefDevOptionComponent[]): MefDevOptionComponent;
clearSearchText(): void;
updateFilterOption(updateActiveFilter?: boolean): void;
onSearchChange(searchValue: string): void;
onClick(e: MouseEvent): void;
onKeyDown(e: KeyboardEvent): void;
closeDropDown(): void;
setClassMap(): void;
setDropDownClassMap(): void;
scrollToActive(): void;
flushComponentState(): void;
_setTriggerWidth(): void;
_getTriggerRect(): ClientRect;
writeValue(value: string | string[]): void;
registerOnChange(fn: (value: string | string[]) => void): void;
registerOnTouched(fn: () => void): void;
setDisabledState(isDisabled: boolean): void;
dropDownScroll(ul: HTMLUListElement): void;
checkDropDownScroll(): void;
constructor(_elementRef: ElementRef, _renderer: Renderer2, cDRef: ChangeDetectorRef);
ngAfterContentInit(): void;
ngOnInit(): void;
ngAfterContentChecked(): void;
private _updateValue;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* @skipTemplateDoc true
* Component for representing an option in a dropdown list.
*
*```
*
*
*```
*
*/
declare class MefDevOptionComponent implements OnDestroy, OnInit {
private _Select;
private _disabled;
_value: string;
_label: string;
/**
* Template for the content of the option.
*/
OptionTemplate: any;
/**
* The value of the option.
*/
set Value(value: string);
get Value(): string;
/**
* The label of the option.
*/
set Label(value: string);
get Label(): string;
/**
* Indicates whether the option is disabled.
*/
set Disabled(value: boolean);
get Disabled(): boolean;
constructor(_Select: MefDevSelectComponent);
/**
* Initialization lifecycle hook.
* Adds the option to the dropdown list.
*/
ngOnInit(): void;
/**
* Destruction lifecycle hook.
* Removes the option from the dropdown list.
*/
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class OptionPipe implements PipeTransform {
transform(options: MefDevOptionComponent[], value: any): any;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵpipe: i0.ɵɵPipeDeclaration;
}
declare class MefDevSelectModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
declare const mefDevCardComponents: (typeof CardSimpleComponent)[];
declare class MefDevCardModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* Fill Component for a modal window.
*
* Example of usage:
* ```
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* https://platform.mef.dev/ui_kit_demo/view/page_components/modals/fill
*/
declare class FillComponent implements OnInit {
protected visible: boolean;
protected dialog?: ElementRef;
/**
* The header template of the modal window.
* ```
*
*
*
*
*
* ```
*/
modal_header: TemplateRef;
/**
* The footer template of the modal window.
* ```
*
*
*
*
*
* ```
*/
modal_footer: TemplateRef;
/**
* Input parameter that determines whether to show the modal window.
*/
set show(val: boolean);
/**
* Event emitted when the modal is change state.
* Emits a boolean value indicating if the modal is closed(false), or open(true).
* Example:
* ```
* ;
constructor();
ngOnInit(): void;
/**
* Shows the modal state.
* Return a boolean value indicating if the modal is closed(false), or open(true)
*/
getModalState(): boolean;
/**
* Shows the modal.
* Call this method to open the modal window.
*/
showModal(): void;
/**
* Hides the modal.
* Call this method to close the modal window.
*/
hideModal(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* A component representing a slide-up modal window.
*
* Example of usage:
*
* ```
*
*
* Modal Header
*
*
* Close
*
*
* Content goes here...
*
*
* ```
* https://platform.mef.dev/ui_kit_demo/view/page_components/modals/slide_up
*/
declare class SlideUpComponent implements OnInit {
protected visible: boolean;
/**
* Reference to the template for the modal header.
* Use this template to customize the header of the modal.
*/
modal_header: TemplateRef;
/**
* Reference to the template for the modal footer.
* Use this template to customize the footer of the modal.
*/
modal_footer: TemplateRef;
/**
* Flag indicating whether the modal should be shown or hidden.
* Set it to `true` to show the modal and `false` to hide it.
*/
set show(val: boolean);
/**
* Event emitted when the modal is change state.
* Emits a boolean value indicating if the modal is closed(false), or open(true).
*/
visibleChange: EventEmitter;
constructor();
ngOnInit(): void;
/**
* Shows the modal state.
* Return a boolean value indicating if the modal is closed(false), or open(true)
*/
getModalState(): boolean;
/**
* Shows the modal.
* Call this method to open the modal window.
*/
showModal(): void;
/**
* Hides the modal.
* Call this method to close the modal window.
*/
hideModal(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare const enum ModalSize {
sm = "sm",
md = "md",
lg = "lg"
}
/**
* A component representing a slide-right modal window.
*
* Example of usage:
*
* ```
*
*
* Modal Header
*
*
* Close
*
*
* Content goes here...
*
*
* ```
* https://platform.mef.dev/ui_kit_demo/view/page_components/modals/slide_right
*/
declare class SlideRightComponent implements OnInit {
protected visible: boolean;
protected dialog: ElementRef;
/**
* Reference to the template for the modal header.
* Use this template to customize the header of the modal.
*/
modal_header: TemplateRef;
/**
* Reference to the template for the modal footer.
* Use this template to customize the footer of the modal.
*/
modal_footer: TemplateRef;
/**
* Size of the modal.
* Defaults to `ModalSize.md`.
* Possible values: `ModalSize.sm`, `ModalSize.md`, `ModalSize.lg`, `ModalSize.xl`.
*/
size: ModalSize;
/**
* Flag indicating whether the modal should be shown or hidden.
* Set it to `true` to show the modal and `false` to hide it.
*/
set show(val: boolean);
/**
* Event emitted when the modal is change state.
* Emits a boolean value indicating if the modal is closed(false), or open(true).
* Example:
* ```
* ;
constructor();
ngOnInit(): void;
/**
* Shows the modal state.
* Return a boolean value indicating if the modal is closed(false), or open(true)
*/
getModalState(): boolean;
/**
* Shows the modal.
* Call this method to open the modal window.
*/
showModal(): void;
/**
* Hides the modal.
* Call this method to close the modal window.
*/
hideModal(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Component representing the right filter.
*/
declare class RightFilterComponent implements OnInit {
private filteredFieldService;
/**
* Flag indicating whether the right filter is open or closed.
*/
isOpen: boolean;
showStandartOpenButton: boolean;
constructor(filteredFieldService: FilteredFieldService);
ngOnInit(): void;
/**
* Opens or closes the right filter modal.
*/
openModal(): void;
/**
* Event handler for when the modal is closed.
* Sets the isOpen flag to false.
*/
modalIsCloused(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevModalModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* A component representing a central page layout.
*
* Example of usage:
*
* ```
*
* Content goes here...
*
* ```
*
* https://platform.mef.dev/ui_kit_demo/view/page_layouts/central_page
*/
declare class CentralPageComponent implements OnInit, OnDestroy, AfterViewChecked {
constructor();
/**
* The width of the central page.
* Defaults to '100%'.
* You can specify the width using CSS units (e.g., '80%', '500px').
*/
width: string;
/**
* Lifecycle hook called just before the component is destroyed.
* Removes the height style from the main content element.
*/
ngOnDestroy(): void;
ngOnInit(): void;
/**
* Lifecycle hook called after the component's view has been checked.
* Sets the height of the main content element to '100%'.
*/
ngAfterViewChecked(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* A component representing a central page layout.
*
* Example of usage:
*
* ```
*
*
* Content goes here...
*
*
* ```
*/
declare class CentralPageRowComponent implements OnInit {
constructor();
ngOnInit(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* A component representing a table page layout.
*
* Example of usage:
*
* ```
*
*
*
*
*
* ```
*
* https://platform.mef.dev/ui_kit_demo/view/page_layouts/table_page
*/
declare class TablePageComponent implements OnInit {
/**
* The template reference to the content of the filter column.
* ```
*
*
*
* ```
*/
filter_colum: TemplateRef;
constructor();
ngOnInit(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* A component representing a manage page layout.
*
* Example of usage:
*
* ```
*
*
* Title of the card
*
*
* Content of the tabs block
*
*
* ```
*
* Example of usage:
* https://platform.mef.dev/ui_kit_demo/view/page_layouts/manage_page
*/
declare class ManagePageComponent implements OnInit {
/**
* The template reference to the card title.
* ```
*
*
* Title of the card
*
*
* ```
*/
card_title: TemplateRef;
/**
* The template reference to the tabs block.
* ```
*
*
* Content of the tabs block
*
*
* ```
*/
tabs_block: TemplateRef;
/**
* The index of the starting tab.
* ```
*
* Content goes here...
*
* ```
*/
startTabInd: number;
constructor();
ngOnInit(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevPageLayoutsModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* @ignore
*/
declare class StageComponent {
currentExecutorStep: number;
isRightModal: boolean;
isCompleted: boolean;
title: string;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* A component that allows us to create a content page - a step in our executor.
* Each individual step can have different styles, content and settings.
*
* Example of usage:
*
* ```
*
*
*
*
*
*
*
*
*
* ```
*
*/
declare class MefdevExecutorPageComponent implements OnChanges {
private _mainExecutor;
private _elementRef;
/**
* The title of the step
* @usageNotes
* ```
*
*
*
*
*
*
* ```
*/
isActive: boolean;
/**
* The input parameter that checks whether the step is completed.
*
* @usageNotes
* ```
* ;
elRef: ElementRef;
constructor(_mainExecutor: StepExecutorComponent, _elementRef: ElementRef);
ngOnChanges(changes: SimpleChanges): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Wrapper component that represents a specific encapsulated executor.
*
* Example of usage:
*```
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*```
* https://platform.mef.dev/ui_kit_demo/view/utils/main_executor
*/
declare class StepExecutorComponent implements AfterViewInit {
private renderer;
private changeDetectorRef;
/**
* Mandatory input parameter that specifies the type of the step-by-step wizard.
* It can have three options: regular, modal, right.
*
* @usageNotes
* ```
* ;
/**
* Template for displaying the content of the executor title.
*
* @usageNotes
* ```
*
*
*
* ```
*/
title: TemplateRef;
/**
* Template for displaying the content of the executor description.
*
* @usageNotes
* ```
*
*
*
* ```
*/
description: TemplateRef;
/**
* Template for displaying the content of the executor footer.
*
* @usageNotes
* ```
*
*
*
* ```
*/
footer: TemplateRef;
/**
* The output parameter that emits the class of the active page - active step.
*
* @usageNotes
* ```
* ;
/**
* An output parameter that conveys the current state of the stepper in modal view
*
* @usageNotes
* ```
* ;
/**
* An output parameter that conveys the current state of the stepper in right view
*
* @usageNotes
* ```
* ;
_activePageInd: number;
pages: MefdevExecutorPageComponent[];
constructor(renderer: Renderer2, changeDetectorRef: ChangeDetectorRef);
set activePageInd(activePageNumber: number);
get activePageInd(): number;
get activePage(): MefdevExecutorPageComponent | null;
ngAfterViewInit(): void;
/**
* A function that is allows to track the status of your executor in the modal view
*/
modalStepExecutorVisibleChange(value: boolean): void;
/**
* A function that is allows to track the status of your executor in the right view
*/
rightStepExecutorVisibleChange(value: boolean): void;
/**
* A function that allows you to close your executor
*/
closeExecutor(): void;
/**
* Check whether there is a next step of the executor. If we are at the last step - disable the 'next' button
*/
nextBtnIsDisabled(): boolean;
/**
* Check whether there is a next step of the executor. If we are at the last step - disable the 'next' button
*/
prev(): void;
/**
* Go back to the previous step
*/
cancel(): void;
/**
* Go to the next step
*/
next(): void;
/**
* Set a specific active page
*/
setActivePage(pageNumber: number): void;
/**
* Add new page
*/
addPage(page: MefdevExecutorPageComponent): void;
/**
* Delete a specific page
*/
removeSpecificPage(page: MefdevExecutorPageComponent): void;
/**
* Delete a page by its index
*/
removePageByIndex(index: number): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevStepExecutorModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
declare class MefdevDropdownMenuComponent {
private _eref;
label: TemplateRef;
protected isOpen: boolean;
constructor(_eref: ElementRef);
onClick($event: any): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevDropDownMenuModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* Component representing a progress bar.
*
* Example of usage:
*
* ```
* ;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class ProgressConfig {
color: string;
thickness: number;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵprov: i0.ɵɵInjectableDeclaration;
}
declare class MefDevProgressModule {
static forRoot(): ModuleWithProviders;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* @component
* @skipTemplateDoc: true
* Example of usage:
* https://platform.mef.dev/ui_kit_demo/view/controls/switch
*/
declare class MefDevSwitchComponent implements OnInit, ControlValueAccessor {
private _disabled;
_prefixCls: string;
_color: string;
_innerPrefixCls: string;
_classMap: any;
_size: string;
_checked: boolean;
/**
* Event emitted when the value of the switch changes.
*
* @output
* @param value The new value of the switch.
*
* Usage example:
* ```
* ;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevSwitchModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* Component representing the body of a tab, which displays the tab's content.
*/
declare class MefDevTabBodyComponent {
/**
* The content of the tab, which can be passed as a template.
*/
content: TemplateRef;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevTabLabelDirective {
elementRef: ElementRef;
private _disabled;
set disabled(value: boolean);
get disabled(): boolean;
constructor(elementRef: ElementRef);
getOffsetLeft(): number;
getOffsetWidth(): number;
getOffsetTop(): number;
getOffsetHeight(): number;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
type TabPositionMode$2 = 'horizontal' | 'vertical';
declare class MefDevTabsInkBarDirective {
private _renderer;
private _elementRef;
private _ngZone;
private _animated;
set Animated(value: boolean);
get Animated(): boolean;
PositionMode: TabPositionMode$2;
constructor(_renderer: Renderer2, _elementRef: ElementRef, _ngZone: NgZone);
alignToElement(element: HTMLElement): void;
show(): void;
setDisplay(value: string): void;
hide(): void;
_getLeftPosition(element: HTMLElement): string;
_getElementWidth(element: HTMLElement): string;
_getTopPosition(element: HTMLElement): string;
_getElementHeight(element: HTMLElement): string;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/** code from https://github.com/angular/material2 */
type ScrollDirection$1 = 'after' | 'before';
/** duplicated defined https://github.com/angular/angular-cli/issues/2034 **/
type TabPositionMode$1 = 'horizontal' | 'vertical';
declare class MefDevTabsNavComponent implements AfterContentChecked, AfterContentInit {
_elementRef: ElementRef;
private _ngZone;
private _renderer;
private _dir;
private _animated;
private _hideBar;
private _showPagination;
_showPaginationControls: boolean;
_disableScrollAfter: boolean;
_disableScrollBefore: boolean;
_scrollDistance: number;
_selectedIndexChanged: boolean;
_realignInkBar: Subscription | null;
_tabLabelCount: number;
_scrollDistanceChanged: boolean;
_selectedIndex: number;
_tabPositionMode: TabPositionMode$1;
_tabPosition: string;
Size: string;
_type: string;
set Animated(value: boolean);
get Animated(): boolean;
set Position(value: string);
get Position(): string;
set HideBar(value: boolean);
get HideBar(): boolean;
set Type(value: string);
get Type(): string;
_tabBarExtraContent: TemplateRef;
_labelWrappers: QueryList;
_inkBar: MefDevTabsInkBarDirective;
_tabListContainer: ElementRef;
_tabList: ElementRef;
set ShowPagination(value: boolean);
get ShowPagination(): boolean;
set PositionMode(value: TabPositionMode$1);
get PositionMode(): TabPositionMode$1;
set selectedIndex(value: number);
get selectedIndex(): number;
constructor(_elementRef: ElementRef, _ngZone: NgZone, _renderer: Renderer2, _dir: Directionality);
_onContentChanges(): void;
_scrollHeader(scrollDir: ScrollDirection$1): void;
ngAfterContentChecked(): void;
ngAfterContentInit(): void;
_updateTabScrollPosition(): void;
_updatePagination(): void;
_checkPaginationEnabled(): void;
_scrollToLabel(labelIndex: number): void;
_checkScrollingControls(): void;
/**
* Determines what is the maximum length in pixels that can be set for the scroll distance. This
* is equal to the difference in width between the tab list container and tab header container.
*
* This is an expensive call that forces a layout reflow to compute box and scroll metrics and
* should be called sparingly.
*/
_getMaxScrollDistance(): number;
/** Sets the distance in pixels that the tab header should be transformed in the X-axis. */
set scrollDistance(v: number);
get scrollDistance(): number;
get viewWidthHeightPix(): number;
get tabListScrollWidthHeightPix(): number;
get elementRefOffSetWidthHeight(): number;
_getLayoutDirection(): Direction;
_alignInkBarToSelectedTab(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/** code from https://github.com/angular/material2 */
interface AnimatedInterface {
inkBar: boolean;
tabPane: boolean;
}
declare class TabChangeEvent {
index: number;
tab: MefDevTabComponent;
}
type TabPosition = 'top' | 'bottom' | 'left' | 'right';
type TabPositionMode = 'horizontal' | 'vertical';
type TabType = 'line' | 'fillup' | 'linetriangle';
/**
* Represents a tab set or tab group component.
* @example
*
* Tab 1 content
* Tab 2 content
*
*
* Example of usage:
* https://platform.mef.dev/ui_kit_demo/view/page_components/tabset
*/
declare class MefDevTabSetComponent implements AfterContentChecked, OnInit, AfterViewInit {
private _renderer;
_el: any;
_classMap: any;
_prefixCls: string;
_width: any;
_tabPosition: TabPosition;
_tabPositionMode: TabPositionMode;
_indexToSelect: number | null;
_selectedIndex: number | null;
_isViewInit: boolean;
_tabs: MefDevTabComponent[];
_tabAnimation: string;
_extra_tab_class: string;
_extra_tabcontent_class: string;
/**
* Template reference for additional content to be displayed in the tab bar.
*/
TabBarExtraTemplate: TemplateRef;
TabBarExtraContent: TemplateRef;
_tabNav: MefDevTabsNavComponent;
_tabContent: ElementRef;
_hostContent: ElementRef;
/**
* Whether the tab set is animated. Can be a boolean or an object of type AnimatedInterface.
* @example
* - true (enables animation for both ink bar and tab pane)
* - { inkBar: true, tabPane: false } (enables animation for ink bar only)
* Default: true
*/
Animated: AnimatedInterface | boolean;
/**
* Whether to show pagination controls for scrolling tabs.
* @example true
* Default: true
*/
ShowPagination: boolean;
/**
* Whether the tab set is hidden.
* @example true
* Default: false
*/
Hide: boolean;
/**
* The index of the selected tab.
*/
set SelectedIndex(value: number | null);
get SelectedIndex(): number | null;
/**
* Event emitted when the selected tab index changes.
* @returns An Observable emitting the index of the selected tab.
*/
get SelectedIndexChange(): Observable;
/**
* Event emitted when a tab is selected.
* @example
* ;
/**
* Size of the tab set. Can be 'default', 'small', or 'large'.
* @example 'large'
* Default: 'default'
*/
Size: string;
_type: TabType;
tabs: MefDevTabComponent[];
/**
* Position of the tab set. Can be 'top', 'bottom', 'left', or 'right'.
*/
set TabPosition(value: TabPosition);
get TabPosition(): TabPosition;
/**
* Additional CSS class for the tabs.
*/
set extraTabClass(value: string);
/**
* Additional CSS class for the tab content.
*/
set extraTabContentClass(value: string);
/**
* Type of the tab set. Can be 'line', 'fillup', or 'linetriangle'.
*/
set Type(value: TabType);
/**
* Animation to apply to the tabs. Accepts CSS animation name.
*/
set tabAnimation(value: string);
get Type(): TabType;
_setPosition(value: TabPosition): void;
_setClassMap(): void;
/**
* Selects the tab at the specified index.
* @param index The index of the tab to select.
* ```
* Select Tab 1
*```
*/
clickLabel(index: number): void;
ngOnInit(): void;
ngAfterContentChecked(): void;
ngAfterViewInit(): void;
private _createChangeEvent;
get inkBarAnimated(): boolean;
get tabPaneAnimated(): boolean;
constructor(_renderer: Renderer2);
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevTabComponent implements OnDestroy, OnInit {
private MefDevTabSetComponent;
private disabled;
position: number | null;
origin: number | null;
/**
* Sets the disabled state of the tab.
*```html
* ;
/**
* Event emitted when the tab is clicked.
*```html
* ;
/**
* Event emitted when the tab is deselected.
*```html
* ;
/**
* Reference to the template for the tab heading.
*/
_tabHeading: TemplateRef;
/**
* Reference to the template for the tab content.
*/
_content: TemplateRef;
/**
* Gets the template for the tab content.
*```html
* | null;
constructor(MefDevTabSetComponent: MefDevTabSetComponent);
/**
* Initializes the tab component.
*/
ngOnInit(): void;
/**
* Cleans up resources when the tab component is destroyed.
*/
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
declare class MefDevTabsModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
type AccordionDisplayMode = 'default' | 'flat';
type AccordionTogglePosition = 'before' | 'after';
interface AccordionBase extends CdkAccordion {
hideToggle: boolean;
displayMode: AccordionDisplayMode;
togglePosition: AccordionTogglePosition;
_handleHeaderKeydown: (event: KeyboardEvent) => void;
_handleHeaderFocus: (header: any) => void;
}
declare const ACCORDION: InjectionToken;
interface ExpansionPanelBase extends CdkAccordionItem {
hideToggle: boolean;
}
declare const MD_EXPANSION_PANEL: InjectionToken;
declare class MDExpansionPanelContent {
_template: TemplateRef;
_expansionPanel: ExpansionPanelBase | null;
constructor();
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/** Visual state of the panel used by host bindings/classes. */
type ExpansionPanelState = 'expanded' | 'collapsed';
/** Optional DI defaults for panel behavior and look. */
interface ExpansionPanelDefaultOptions {
expandedHeight: string;
collapsedHeight: string;
hideToggle: boolean;
}
/** Injection token for providing default expansion-panel options. */
declare const EXPANSION_PANEL_DEFAULT_OPTIONS: InjectionToken;
declare class MDExpansionPanel extends CdkAccordionItem implements AfterContentInit, OnChanges, OnDestroy {
/** View container for lazily attaching projected content via portals. */
private _viewContainerRef;
/** Global animation toggle for this component instance. */
private readonly _animationsDisabled;
/** Document reference for focus containment checks. */
private _document;
/** NgZone to run listeners outside Angular and re-enter only on emit. */
private _ngZone;
/** Host element ref for event binding and CSS class toggles. */
private _elementRef;
/** Renderer used to register `transitionend` listeners. */
private _renderer;
/** Cleanup function returned by Renderer2.listen; called on destroy. */
private _cleanupTransitionEnd;
/** Whether the toggle indicator should be hidden (local or inherited). */
get hideToggle(): boolean;
set hideToggle(value: boolean);
private _hideToggle;
/** Toggle position relative to header content (local or inherited). */
get togglePosition(): AccordionTogglePosition;
set togglePosition(value: AccordionTogglePosition);
private _togglePosition;
/** Fires after the expand transition completes. */
readonly afterExpand: EventEmitter;
/** Fires after the collapse transition completes. */
readonly afterCollapse: EventEmitter;
/** Emits whenever any @Input changes (for consumers to react). */
readonly _inputChanges: Subject;
/** Optional parent accordion context (if inside an accordion). */
accordion: AccordionBase;
/** Lazily-projected body content (). */
_lazyContent: MDExpansionPanelContent;
/** Body host element (focus containment & transition target). */
_body: ElementRef;
/** Wrapper element that handles the grid/height transition. */
protected _bodyWrapper: ElementRef | undefined;
/** Portal wrapping the lazy content; created on first open. */
_portal: TemplatePortal;
/** Header id for aria-controls/label association. */
_headerId: string;
constructor();
/** Host CSS helper: spacing only in default display mode when expanded. */
_hasSpacing(): boolean;
/** Map boolean expanded flag to the public state union. */
_getExpandedState(): ExpansionPanelState;
/** Programmatic toggle (overrides base to flip expanded flag). */
toggle(): void;
/** Programmatic close. */
close(): void;
/** Programmatic open. */
open(): void;
/** Set up lazy content portal and animation listeners once content is ready. */
ngAfterContentInit(): void;
/** Forward raw input changes to a Subject for external observers. */
ngOnChanges(changes: SimpleChanges): void;
/** Cleanup listeners and subjects. */
ngOnDestroy(): void;
/** Whether the current document focus is inside the panel body. */
_containsFocus(): boolean;
/**
* Transitionend handler:
* - Ensures we react only to the body wrapper's grid-height transition.
* - Emits the appropriate afterExpand/afterCollapse event inside Angular.
*/
private _transitionEndListener;
/**
* Registers animation listeners:
* - In no-animation mode, emit completion events immediately on state streams.
* - Otherwise, add a `transitionend` listener and a CSS class to enable transitions,
* after a short timeout so the initial render settles.
*/
protected _setupAnimationEvents(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
static ngAcceptInputType_hideToggle: unknown;
}
/**
* Simple action-row wrapper for projected buttons/links inside the panel body.
* Provides a stable class hook for styling.
*/
declare class ExpansionPanelActionRow {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Header component for an expansion panel.
* - Acts as the interactive control (button role) that toggles the panel.
* - Manages aria attributes and keyboard interaction.
* - Syncs with parent accordion/panel inputs and emits change detection marks.
*/
declare class MDExpansionPanelHeader implements AfterViewInit, OnDestroy, FocusableOption {
/** Owning panel (injected from host). */
panel: MDExpansionPanel;
/** Host element reference (focus & DOM ops). */
private _element;
/** FocusMonitor for origin-aware focus management. */
private _focusMonitor;
/** Marks for check on state changes (OnPush). */
private _changeDetectorRef;
/** Subscriptions to panel/accordion streams. */
private _parentChangeSubscription;
constructor();
/** Custom height when the panel is expanded (CSS length). */
expandedHeight: string;
/** Custom height when the panel is collapsed (CSS length). */
collapsedHeight: string;
/**
* Keyboard tab stop order for the header.
* Normalized via numberAttribute; defaults to 0 if null/undefined.
*/
tabIndex: number;
/** Whether the header is effectively disabled (delegates to panel). */
get disabled(): boolean;
/** Click/keyboard toggle handler. */
_toggle(): void;
/** Current expanded state as boolean. */
_isExpanded(): boolean;
/** Expanded state string used by templates/host bindings. */
_getExpandedState(): string;
/** ID of the associated panel body (for aria-controls). */
_getPanelId(): string;
/** Toggle indicator placement relative to header content. */
_getTogglePosition(): AccordionTogglePosition;
/** Whether to show the toggle indicator (inherits hideToggle/disabled). */
_showToggle(): boolean;
/** Compute header height based on state and provided inputs. */
_getHeaderHeight(): string | null;
/** Keydown handler: Space/Enter toggles; delegate others to accordion. */
_keydown(event: KeyboardEvent): void;
/** FocusableOption implementation with origin-aware focus. */
focus(origin?: FocusOrigin, options?: FocusOptions): void;
/** Start monitoring focus and notify accordion when header gains focus. */
ngAfterViewInit(): void;
/** Cleanup subscriptions and focus monitoring. */
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
static ngAcceptInputType_tabIndex: unknown;
}
/** Projected description container inside the header (styling hook). */
declare class ExpansionPanelDescription {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/** Projected title container inside the header (styling hook). */
declare class ExpansionPanelTitle {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Accordion container that coordinates multiple expansion panels.
* - Provides the ACCORDION token for children to read common settings.
* - Manages roving focus across panel headers with FocusKeyManager.
* - Filters projected headers so only this accordion’s own headers are managed.
*/
declare class MDAccordion extends CdkAccordion implements AccordionBase, AfterContentInit, OnDestroy {
/** Keyboard manager for roving focus (Home/End/Arrow navigation). */
private _keyManager;
/**
* Local QueryList containing only headers owned by this accordion.
* We derive it from `_headers` because projected content could include
* nested accordions or headers belonging to another parent.
*/
private _ownHeaders;
/** All descendant headers from projected content (may include foreign ones). */
_headers: QueryList;
/** Hides the toggle arrow/indicator on all child panels. */
hideToggle: boolean;
/** Display mode that affects spacing/styling of panels. */
displayMode: AccordionDisplayMode;
/** Placement of the toggle indicator relative to header content. */
togglePosition: AccordionTogglePosition;
/** After content init, filter and wire focus management. */
ngAfterContentInit(): void;
/** Delegate keydown from a header to the key manager (arrow/home/end handling). */
_handleHeaderKeydown(event: KeyboardEvent): void;
/** Update the active item when a particular header gains focus. */
_handleHeaderFocus(header: MDExpansionPanelHeader): void;
/** Tear down key manager and QueryList on destroy; call base cleanup too. */
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
static ngAcceptInputType_hideToggle: unknown;
}
declare const components: (typeof ExpansionPanelActionRow)[];
declare class MDCollapseModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
/**
* Public API type that controls the overall visual style of the card.
* - `'outlined'` — draws an outline around the card.
* - `'raised'` — default look with elevation (shadow).
* - `'filled'` — filled background emphasis.
*/
type CardAppearance = 'outlined' | 'raised' | 'filled';
/**
* Optional DI-provided configuration for MDCard defaults.
* Allows setting application-wide defaults without touching each instance.
*/
interface CardConfig {
/** Default appearance applied to all cards unless overridden per instance. */
appearance?: CardAppearance;
}
/**
* Injection token for providing a global {@link CardConfig}.
*
* @example App-wide default
* ```ts
* providers: [{ provide: CARD_CONFIG, useValue: { appearance: 'filled' } as CardConfig }]
* ```
*/
declare const CARD_CONFIG: InjectionToken;
/**
* Root Card component.
*
* @remarks
* - Renders a Material Design–like card container.
* - Applies host CSS classes based on the {@link appearance} input.
* - Reads optional defaults from DI via {@link CARD_CONFIG}.
*
* Template & styles:
* - `templateUrl: 'card.html'` — defines the card structure/slots.
* - `styleUrl: 'card.scss'` — variants and section styling.
*
* Performance:
* - `ChangeDetectionStrategy.OnPush` to minimize change detection work.
*
* Export:
* - `exportAs: 'mdCard'` — allows `#card="mdCard"` in templates.
*/
declare class MDCard {
/**
* Controls the visual style of the card.
*
* @default 'outlined' (or {@link CARD_CONFIG}.appearance if provided)
* @ignore
*/
appearance: CardAppearance;
constructor();
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Title directive.
*
* @example
* ```html
* Title
* Title
* Title
* ```
*
* Adds a semantic class for styling the title area.
*/
declare class MDCardTitle {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Title group component.
* Encapsulates grouped title-related content (e.g., title + subtitle + avatar).
* Template is defined in `card-title-group.html`.
*/
declare class MDCardTitleGroup {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Content directive for the main textual/body area of the card.
*
* @example
* ```html
* ...
* ```
*/
declare class MDCardContent {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Subtitle directive.
*
* @example
* ```html
* Subtitle
* Subtitle
* Subtitle
* ```
*
* Adds a semantic class for styling the subtitle text.
*/
declare class MDCardSubtitle {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Actions directive.
* Represents the action row (e.g., buttons) at the bottom or top of a card.
*
* Host classes:
* - Base: `'mdc-card-actions mdc-card__actions'`
* - If `align === 'end'`, also applies `'mdc-card-actions-align-end'`.
*/
declare class MDCardActions {
/**
* Controls horizontal alignment of actions.
* - `'start'` — actions align to the start edge
* - `'end'` — actions align to the end edge
*
* @default 'start'
*
* @example
* ```html
*
* Save
*
* ```
*/
align: 'start' | 'end';
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Header component.
* A dedicated container for card header content (e.g., avatar, title/subtitle group).
* Template is defined in `card-header.html`.
*/
declare class MDCardHeader {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Footer directive.
* A semantic area for card footers—secondary info, meta, or supplementary actions.
*/
declare class MDCardFooter {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Image directive (default size).
* Applies media-related classes to display a cover/media area inside the card.
*
* @example
* ```html
*
*
* ```
*
* Note: Actual sizing (height/ratio) should be defined in `card.scss`.
*/
declare class MDCardImage {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Small image directive.
* Adds the same base media classes; size differences should be implemented in CSS.
*/
declare class MDCardSmImage {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Medium image directive.
* Adds the same base media classes; size differences should be implemented in CSS.
*/
declare class MDCardMdImage {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Large image directive.
* Adds the same base media classes; size differences should be implemented in CSS.
*/
declare class MDCardLgImage {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Extra-large image directive.
* Adds the same base media classes; size differences should be implemented in CSS.
*/
declare class MDCardXlImage {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Avatar directive.
* Intended for small, typically circular images near the title/header area.
* The concrete size/shape should be controlled via CSS (e.g., width/height/border-radius).
*/
declare class MDCardAvatar {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
declare class MDCardModule {
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵmod: i0.ɵɵNgModuleDeclaration;
static ɵinj: i0.ɵɵInjectorDeclaration;
}
type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
type DialogRole = 'dialog' | 'alertdialog';
interface DialogPosition {
top?: string;
bottom?: string;
left?: string;
right?: string;
}
declare class MefDevDialogConfig {
viewContainerRef?: ViewContainerRef;
injector?: Injector;
id?: string;
role?: DialogRole;
panelClass?: string | string[];
hasBackdrop?: boolean;
backdropClass?: string | string[];
disableClose?: boolean;
closePredicate?: (result: Result | undefined, config: Config, componentInstance: Component | null) => boolean;
width?: string;
height?: string;
minWidth?: number | string;
minHeight?: number | string;
maxWidth?: number | string;
maxHeight?: number | string;
position?: DialogPosition;
data?: D | null;
direction?: Direction;
ariaDescribedBy?: string | null;
ariaLabelledBy?: string | null;
ariaLabel?: string | null;
ariaModal?: boolean;
autoFocus?: AutoFocusTarget | string | boolean;
restoreFocus?: boolean;
delayFocusTrap?: boolean;
scrollStrategy?: ScrollStrategy;
closeOnNavigation?: boolean;
enterAnimationDuration?: string | number;
exitAnimationDuration?: string | number;
animationPosition?: 'top' | 'right' | 'bottom' | 'left';
}
/** Legacy-style animation event payload used by the dialog service/ref. */
interface LegacyDialogAnimationEvent {
state: 'opened' | 'opening' | 'closing' | 'closed';
totalTime: number;
}
declare class MDDialogContainer extends CdkDialogContainer implements OnDestroy {
/** Emits animation lifecycle states understood by the dialog ref. */
_animationStateChanged: EventEmitter;
/** Master flag to enable/disable animations for this container instance. */
_animationsEnabled: boolean;
/** Count of projected action sections (affects layout class). */
protected _actionSectionCount: number;
/** Cached host element for class and style mutations. */
private _hostElement;
/** Effective enter animation duration derived from config (or defaults). */
private _enterAnimationDuration;
/** Effective exit animation duration derived from config (or defaults). */
private _exitAnimationDuration;
/** Timer id for open/close fallback completion. */
private _animationTimer;
/** After content is attached, kick off the open animation. */
protected _contentAttached(): void;
/** Optional position modifier class for origin-based animations. */
private ANIMATION_POSITION_CLASS;
/** Starts the open animation sequence and emits "opening". */
private _startOpenAnimation;
/** Public entrypoint called by the ref to start the close sequence. */
_startExitAnimation(): void;
/** Tracks action sections; used to toggle a host layout class. */
_updateActionSectionCount(delta: number): void;
/** Finishes open sequence: clear classes and emit "opened". */
private _finishDialogOpen;
/** Finishes close sequence: clear classes and emit "closed". */
private _finishDialogClose;
/** Removes transient animation classes (and optional position class). */
private _clearAnimationClasses;
/**
* Sets/refreshes a timeout to complete the animation sequence. This acts as a
* fallback when relying on CSS transitions without guaranteed end events.
*/
private _waitForAnimationToComplete;
/**
* Schedules a callback on the next animation frame, outside Angular,
* to ensure CSS transitions are applied predictably.
*/
private _requestAnimationFrame;
/** Focus handling after content attachment depending on `delayFocusTrap` config. */
protected _captureInitialFocus(): void;
/** Called when open animation completes to emit "opened" and (optionally) trap focus. */
protected _openAnimationDone(totalTime: number): void;
/** Cleanup any pending timers on destroy. */
ngOnDestroy(): void;
/**
* Decorates the root component host element with a class so that card/panel
* styles can target it specifically when used inside a dialog.
*/
attachComponentPortal(portal: ComponentPortal): ComponentRef;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵcmp: i0.ɵɵComponentDeclaration;
}
/**
* Internal finite state for a dialog's lifecycle.
* - OPEN: visible and interactive
* - CLOSING: exit animation playing or teardown in progress
* - CLOSED: fully closed and resources released
*/
declare enum DialogState {
OPEN = 0,
CLOSING = 1,
CLOSED = 2
}
/**
* Strongly-typed wrapper around CDK's DialogRef with MEF/MD container integration.
*
* Responsibilities:
* - Expose open/close lifecycle streams (afterOpened, beforeClosed, afterClosed).
* - Respect `disableClose`, ESC and backdrop click behavior.
* - Start/await container animations and provide a fallback close timeout.
* - Bridge size/position/panel class updates to the underlying CDK dialog.
* - Track the interaction type (mouse/keyboard) that triggered close for focus restoration.
*/
declare class MefDevDialogRef {
/** Underlying CDK dialog ref. */
private _ref;
/** Immutable configuration used to open this dialog. */
private _config;
/** Reference to the container component that hosts animations and structure. */
_containerInstance: MDDialogContainer;
/** Instance of the component hosted inside the dialog (if opened via component). */
componentInstance: T;
/** Low-level componentRef for advanced users (null for TemplateRef opens). */
readonly componentRef: ComponentRef | null;
/** When true, ESC and backdrop click won't close the dialog. */
disableClose: boolean | undefined;
/** Dialog id (auto-generated unless provided in config). */
id: string;
/** Emits once when the dialog has finished its enter animation. */
private readonly _afterOpened;
/** Emits right before the dialog starts closing (with the result). */
private readonly _beforeClosed;
/** Cached result passed to `close(result)`; emitted via afterClosed. */
private _result;
/** Fallback timer that triggers `_finishDialogClose` if animation events don't arrive. */
private _closeFallbackTimeout;
/** Current lifecycle state of the dialog. */
private _state;
/** Input modality that caused the close (used for focus origin on restore). */
private _closeInteractionType;
constructor(
/** Underlying CDK dialog ref. */
_ref: DialogRef,
/** Immutable configuration used to open this dialog. */
_config: MefDevDialogConfig,
/** Reference to the container component that hosts animations and structure. */
_containerInstance: MDDialogContainer);
/**
* Programmatically close the dialog with an optional result.
* Respects an optional `closePredicate` to veto the close.
*/
close(dialogResult?: R): void;
/** Stream that emits once the dialog is fully opened (after enter animation). */
afterOpened(): Observable;
/** Stream that emits the result after the dialog is fully closed and disposed. */
afterClosed(): Observable;
/** Stream that emits right before the dialog starts closing with the result (if any). */
beforeClosed(): Observable;
/** Backdrop click stream (useful for custom close logic / analytics). */
backdropClick(): Observable;
/** Keydown stream scoped to the dialog overlay (e.g., listen for ESC). */
keydownEvents(): Observable;
/**
* Updates the dialog position. If top/bottom or left/right are not provided,
* the dialog will be centered on that axis.
*/
updatePosition(position?: DialogPosition): this;
/** Updates dialog width/height (CSS length values, e.g. '600px', '80vh'). */
updateSize(width?: string, height?: string): this;
/** Adds one or more CSS classes to the overlay panel. */
addPanelClass(classes: string | string[]): this;
/** Removes one or more CSS classes from the overlay panel. */
removePanelClass(classes: string | string[]): this;
/** Returns the current lifecycle state of the dialog. */
getState(): DialogState;
/**
* Finalizes the closing sequence:
* - Sets state to CLOSED
* - Closes underlying CDK ref (emits afterClosed with the result)
* - Clears strong reference to the component instance
*/
private _finishDialogClose;
}
/**
* Helper to close a dialog and tag the close with the interaction origin.
* Used by default ESC/backdrop handlers to restore focus appropriately.
*/
declare function _closeDialogVia(ref: MefDevDialogRef, interactionType: FocusOrigin, result?: R): void;
/** Injection token used to pass arbitrary data into a dialog instance. */
declare const DIALOG_DATA: InjectionToken;
/** Token for providing global/default dialog configuration. */
declare const DIALOG_DEFAULT_OPTIONS: InjectionToken>;
/**
* Token that provides a factory for the scroll strategy used by dialogs.
* Defaults to `createBlockScrollStrategy` which prevents body scrolling while a dialog is open.
*/
declare const DIALOG_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
/**
* High-level dialog service wrapping CDK Dialog with MDC/MEF-specific defaults.
*
* Features:
* - Merges provided config with app-level defaults.
* - Creates a global centered position strategy by default.
* - Emits streams for "after opened" and "after all closed".
* - Keeps a stack of open dialogs and coordinates teardown.
* - Bridges to a custom `MDDialogContainer` and `MefDevDialogRef`.
*/
declare class MDDialog implements OnDestroy {
/** Optional application-wide defaults injected via `DIALOG_DEFAULT_OPTIONS`. */
private _defaultOptions;
/** Factory for the body scroll strategy while a dialog is open. */
private _scrollStrategy;
/** Optional parent dialog service (supports hierarchical injectors / lazy modules). */
private _parentDialog;
/** Id generator for dialog instances. */
private _idGenerator;
/** Root injector needed for CDK helpers (position strategy, etc.). */
private _injector;
/** Underlying CDK Dialog service. */
protected _dialog: Dialog;
/** Global flag to disable dialog enter/exit animations. */
private _animationsDisabled;
/** Stack of open dialogs at the current injector level. */
private readonly _openDialogsAtThisLevel;
/** Completes after the last dialog at this level has been closed. */
private readonly _afterAllClosedAtThisLevel;
/** Emits each time a dialog is opened at this level. */
private readonly _afterOpenedAtThisLevel;
/** Class reference used for providing config to the container. */
protected dialogConfigClass: typeof MefDevDialogConfig;
/** Concrete types used to construct dialog refs/containers and provide DIALOG_DATA. */
private readonly _dialogRefConstructor;
private readonly _dialogContainerType;
private readonly _dialogDataToken;
/** Public list of open dialogs (delegates to parent if present). */
get openDialogs(): MefDevDialogRef[];
/** Stream that emits after each dialog is opened (delegates to parent if present). */
get afterOpened(): Subject>;
/** Internal accessor for the "after all closed" subject (handles parent delegation). */
private _getAfterAllClosed;
/**
* Emits when all dialogs (in this hierarchy) are closed.
* If there are no open dialogs at subscription time, it emits once immediately.
*/
readonly afterAllClosed: Observable;
constructor();
/** Overload signatures for component vs template dialogs. */
open(component: ComponentType, config?: MefDevDialogConfig): MefDevDialogRef;
open(template: TemplateRef, config?: MefDevDialogConfig): MefDevDialogRef;
open(template: ComponentType | TemplateRef, config?: MefDevDialogConfig): MefDevDialogRef;
/** Closes all currently open dialogs (in stack order). */
closeAll(): void;
/** Finds an open dialog by id (if any). */
getDialogById(id: string): MefDevDialogRef | undefined;
/** On service destroy, close dialogs owned at this injector level and complete streams. */
ngOnDestroy(): void;
/** Helper that iterates and closes dialogs without changing array identity. */
private _closeDialogs;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵprov: i0.ɵɵInjectableDeclaration;
}
/**
* Button-like directive that closes the nearest dialog when clicked.
*
* Usage:
* Close
* Save
*
* - It tries to inject the current MefDevDialogRef; if not available,
* it finds the nearest dialog container in the DOM and resolves the ref from MDDialog.openDialogs.
* - On click, it calls `_closeDialogVia` with an interaction origin ('mouse' or 'keyboard')
* so the focus can be restored appropriately.
*/
declare class MDDialogClose implements OnInit, OnChanges {
/** Injected dialog ref when available (undefined if used outside projected dialog content). */
dialogRef: MefDevDialogRef;
/** Host element reference (used for DOM traversal when ref is not injected). */
private _elementRef;
/** Dialog service used to access `openDialogs` for fallback lookup. */
private _dialog;
/** Optional aria-label for the closing button. */
ariaLabel: string;
/** Native button type; defaults to "button" to avoid accidental form submit. */
type: 'submit' | 'button' | 'reset';
/** Preferred input for a close result (dash-cased attribute). */
dialogResult: any;
/** CamelCased alias of the same input (kept for API parity & template style). */
dialogClose: any;
constructor();
/** Resolve dialogRef if it wasn't injected (e.g., directive used in a nested view). */
ngOnInit(): void;
/** Mirror `dialogClose` into `dialogResult` when either input changes. */
ngOnChanges(changes: SimpleChanges): void;
/** Click handler: close the dialog and tag the interaction origin for focus restoration. */
_onButtonClick(event: MouseEvent): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Base class for directives that represent structural sections within a dialog
* (e.g., title area, actions area). It:
* - Resolves the dialog ref by injection or DOM traversal.
* - Calls `_onAdd()` when attached to the DOM (after microtask) so the container
* can update ARIA attributes or layout counts.
* - Calls `_onRemove()` when destroyed so the container can revert those changes.
*/
declare abstract class DialogLayoutSection implements OnInit, OnDestroy {
/** Reference to the owning dialog (if any). */
protected _dialogRef: MefDevDialogRef;
/** Host element reference for DOM traversal fallback. */
private _elementRef;
/** Dialog service used for fallback dialog lookup. */
private _dialog;
constructor(...args: unknown[]);
/** Hook for subclasses to add themselves to the container (e.g., ARIA wiring, layout counters). */
protected abstract _onAdd(): void;
/** Hook for subclasses to remove themselves from the container. */
protected abstract _onRemove(): void;
ngOnInit(): void;
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration;
static ɵdir: i0.ɵɵDirectiveDeclaration;
}
/**
* Dialog title directive.
*
* - Adds semantic/title classes to the host.
* - Generates a unique id that is used to label the dialog via `aria-labelledby`.
* - Notifies the container to add/remove this id from its aria-labelledby list.
*/
declare class MDDialogTitle extends DialogLayoutSection {
/** Unique id used by the container for aria-labelledby. */
id: string;
/** Register this title id with the container for a11y. */
protected _onAdd(): void;
/** Unregister this title id on destroy. */
protected _onRemove(): void;
static ɵfac: i0.ɵɵFactoryDeclaration