@natec/mef-dev-ui-kit 20.0.0-beta.1 → 20.0.1

package/index.d.ts

@@ -0,0 +1,4418 @@
+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 } from '@angular/core';
+import * as i2 from '@angular/common';
+import { Observable, Subscription, Subject } from 'rxjs';
+import * as i6 from '@angular/cdk/overlay';
+import { CdkConnectedOverlay, ConnectedOverlayPositionChange, ScrollStrategy, ComponentType, ViewportRuler, Overlay, ConnectedPosition } from '@angular/cdk/overlay';
+import * as i5 from '@angular/forms';
+import { ControlValueAccessor, AbstractControl, FormGroupDirective, NgForm, NgControl } from '@angular/forms';
+import { Directionality, Direction } from '@angular/cdk/bidi';
+import { FocusableOption, FocusOrigin, ActiveDescendantKeyManager, FocusKeyManager } from '@angular/cdk/a11y';
+import { CdkAccordion, CdkAccordionItem } from '@angular/cdk/accordion';
+import * as i3 from '@angular/cdk/portal';
+import { TemplatePortal, ComponentPortal, CdkPortalOutlet, CdkPortal } from '@angular/cdk/portal';
+import * as i1$1 from '@angular/cdk/dialog';
+import { DialogConfig, CdkDialogContainer, DialogRef, Dialog } from '@angular/cdk/dialog';
+import * as i1 from '@angular/cdk/scrolling';
+import * as i3$1 from '@angular/cdk/stepper';
+import { CdkStepLabel, StepState, CdkStepHeader, CdkStep, CdkStepper, CdkStepperNext, CdkStepperPrevious } from '@angular/cdk/stepper';
+export { StepState, StepperOrientation } from '@angular/cdk/stepper';
+import { SelectionModel } from '@angular/cdk/collections';
+
+/**
+  * Component for displaying a collapsible content.
+  *
+  *
+  * Example of usage:
+  *```
+  * <mefdev-collapse [Disabled]="false" [Active]="true" (stateChange)="onStateChange($event)">
+  *   <ng-template #CardTitle>
+  *     <!-- Content for the card title -->
+  *     <h3>Card Title</h3>
+  *   </ng-template>
+  *
+  *   <!-- Content for the collapsible section -->
+  *   <div>
+        Content inside collapse
+  *   </div>
+  * </mefdev-collapse>
+  *
+  *```
+    * <example-url>https://platform.mef.dev/ui_kit_demo/view/page_components/collapse</example-url>
+
+  */
+declare class CollapseComponent {
+    private _collapseSet;
+    private _elementRef;
+    private _disabled;
+    _active: boolean;
+    _el: any;
+    /**
+     * ContentChild for the template of the card title.
+     *
+     * Example:
+     * ```
+     * <ng-template #CardTitle>
+     *   <h3>Card Title</h3>
+     * </ng-template>
+     * ```
+     */
+    CardTitle: TemplateRef<void>;
+    /**
+     * 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:
+     * ```
+     * <mefdev-collapse (stateChange)="onStateChange($event)"></mefdev-collapse>
+     * ```
+     */
+    stateChange: EventEmitter<boolean>;
+    /**
+     * 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<CollapseComponent, [{ host: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollapseComponent, "mefdev-collapse", never, { "Disabled": { "alias": "Disabled"; "required": false; }; "Active": { "alias": "Active"; "required": false; }; }, { "stateChange": "stateChange"; }, ["CardTitle"], ["*"], false, never>;
+}
+
+/**
+* Component representing a set of collapsible panels.
+*
+* Example of usage:
+*
+*```
+* <mefdev-collapse-set [Accordion]="true" [Horizontal]="true" [expandAny]="false">
+*   <mefdev-collapse [Disabled]="false" [Active]="true">
+*       <!-- Content for the collapse panel -->
+*       <h3>Panel 1</h3>
+*       <p>Panel 1 content...</p>
+*   </mefdev-collapse>
+
+*   <mefdev-collapse [Disabled]="false" [Active]="false">
+*       <!-- Content for the collapse panel -->
+*       <h3>Panel 2</h3>
+*       <p>Panel 2 content...</p>
+*   </mefdev-collapse>
+
+*   <mefdev-collapse [Disabled]="false" [Active]="false">
+*       <!-- Content for the collapse panel -->
+*       <h3>Panel 3</h3>
+*       <p>Panel 3 content...</p>
+*   </mefdev-collapse>
+* </mefdev-collapse-set>
+*```
+*/
+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<CollapseSetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollapseSetComponent, "mefdev-collapse-set", never, { "expandAny": { "alias": "expandAny"; "required": false; }; "Accordion": { "alias": "Accordion"; "required": false; }; "Horizontal": { "alias": "Horizontal"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare const mefDevCollapseModuleComponents: (typeof CollapseSetComponent | typeof CollapseComponent)[];
+declare class MefDevCollapseModule {
+    static forRoot(): ModuleWithProviders<MefDevCollapseModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevCollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevCollapseModule, [typeof CollapseSetComponent, typeof CollapseComponent], [typeof i2.CommonModule], [typeof CollapseSetComponent, typeof CollapseComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevCollapseModule>;
+}
+
+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<FiltredItemModel>;
+    /**
+   * 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<FiltredItemModel>;
+    /**
+   * Sends a new filter item event with the specified item.
+   * @param item The filtered item model.
+   */
+    sendNewFilterItem(item: FiltredItemModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilteredFieldService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilteredFieldService>;
+}
+
+/**
+* A container component for filtered fields.
+*
+* Example of usage:
+* ```
+* <mefdev-filtered-field-container>
+*
+* <mefdev-filtered-field-item [item]="filterItem" (discard)="onDiscardFilter($event)" (openFilter)="onOpenFilter()">
+* </mefdev-filtered-field-item>
+*
+* </mefdev-filtered-field-container>
+* ```
+* Example of usage:
+* <example-url>https://platform.mef.dev/ui_kit_demo/view/utils/filtered_field</example-url>
+*/
+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<FilteredFieldContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilteredFieldContainerComponent, "mefdev-filtered-field-container", never, {}, {}, never, never, false, never>;
+}
+
+/**
+  * Component representing a filtered field item.
+  *
+  * Example of usage:
+  * ```
+  * <mefdev-filtered-field-item [item]="filterItem" (discard)="onDiscardFilter($event)" (openFilter)="onOpenFilter()">
+  * </mefdev-filtered-field-item>
+  *```
+  *
+*/
+declare class FilteredFieldItemComponent implements OnInit {
+    /**
+     * The filtered item model.
+     * ```
+     * <mefdev-filtered-field-item [item]="filterItem">
+     * Content goes here...
+     * </mefdev-filtered-field-item>
+     * ```
+     */
+    item: FiltredItemModel;
+    /**
+     * Event emitted when the filter is discarded.
+     * ```
+     * <mefdev-filtered-field-item (discard)="onDiscardFilter($event)">
+     * Content goes here...
+     * </mefdev-filtered-field-item>
+     * ```
+     */
+    discard: EventEmitter<FiltredItemModel>;
+    /**
+     * Event emitted when the filter is opened.
+     * ```
+     * <mefdev-filtered-field-item (openFilter)="onOpenFilter()">
+     * Content goes here...
+     * </mefdev-filtered-field-item>
+     * ```
+     */
+    openFilter: EventEmitter<any>;
+    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<FilteredFieldItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilteredFieldItemComponent, "mefdev-filtered-field-item", never, { "item": { "alias": "item"; "required": false; }; }, { "discard": "discard"; "openFilter": "openFilter"; }, never, never, false, never>;
+}
+
+declare class MefDevFilteredFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevFilteredFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevFilteredFieldModule, [typeof FilteredFieldContainerComponent, typeof FilteredFieldItemComponent], [typeof i2.CommonModule], [typeof FilteredFieldItemComponent, typeof FilteredFieldContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevFilteredFieldModule>;
+}
+
+/**
+  * Component for displaying a simple card with a title.
+  *
+  * Example of usage:
+  *```
+  * <mefdev-card-simple [disabled]="true">
+  *   <ng-template #card_title>
+  *     <!-- Content for the card title -->
+  *   </ng-template>
+  * </mefdev-card-simple>
+  *```
+  *
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/page_components/card/card_simple</example-url>
+  */
+declare class CardSimpleComponent implements OnInit {
+    /**
+     * Determines whether the card is disabled or not.
+     */
+    isDisabled: boolean;
+    /**
+     * Template for displaying the title of the card.
+     *```
+     * <mefdev-card-simple>
+     *   <ng-template #card_title>
+     *     <h3>Card Title</h3>
+     *   </ng-template>
+     * </mefdev-card-simple>
+     *```
+     */
+    card_title: TemplateRef<void>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardSimpleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardSimpleComponent, "mefdev-card-simple", never, { "isDisabled": { "alias": "disabled"; "required": false; }; }, {}, ["card_title"], ["*", "[card-actions]"], false, never>;
+}
+
+/**
+  * Example of usage:
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/controls/select</example-url>
+  */
+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<MefDevOptionComponent>;
+    _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<string>;
+    change: EventEmitter<string>;
+    OpenChange: EventEmitter<boolean>;
+    ScrollToBottom: EventEmitter<boolean>;
+    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<MefDevOptionComponent>, 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<MefDevSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevSelectComponent, "mefdev-select", never, { "Filter": { "alias": "Filter"; "required": false; }; "MaxMultiple": { "alias": "MaxMultiple"; "required": false; }; "FirstDefault": { "alias": "FirstDefault"; "required": false; }; "AllowClear": { "alias": "AllowClear"; "required": false; }; "KeepUnListOptions": { "alias": "KeepUnListOptions"; "required": false; }; "Mode": { "alias": "Mode"; "required": false; }; "Multiple": { "alias": "Multiple"; "required": false; }; "PlaceHolder": { "alias": "PlaceHolder"; "required": false; }; "NotFoundContent": { "alias": "NotFoundContent"; "required": false; }; "Size": { "alias": "Size"; "required": false; }; "ShowSearch": { "alias": "ShowSearch"; "required": false; }; "Tags": { "alias": "Tags"; "required": false; }; "Disabled": { "alias": "Disabled"; "required": false; }; "Open": { "alias": "Open"; "required": false; }; }, { "SearchChange": "SearchChange"; "change": "change"; "OpenChange": "OpenChange"; "ScrollToBottom": "ScrollToBottom"; }, never, never, false, never>;
+}
+
+/**
+ * @skipTemplateDoc true
+ * Component for representing an option in a dropdown list.
+ *
+ *```
+ * <mefdev-select>
+ * <mefdev-option Value="1" Label="Option 1"></mefdev-option>
+ * <mefdev-option Value="2" Label="Option 2"></mefdev-option>
+ * <mefdev-option Value="3" Label="Option 3"></mefdev-option>
+ * </mefdev-select>
+ *```
+ *
+ */
+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<MefDevOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevOptionComponent, "mefdev-option", never, { "Value": { "alias": "Value"; "required": false; }; "Label": { "alias": "Label"; "required": false; }; "Disabled": { "alias": "Disabled"; "required": false; }; }, {}, ["OptionTemplate"], ["*"], false, never>;
+}
+
+declare class OptionPipe implements PipeTransform {
+    transform(options: MefDevOptionComponent[], value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<OptionPipe, "OptionPipe", false>;
+}
+
+declare class MefDevSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevSelectModule, [typeof OptionPipe, typeof MefDevOptionComponent, typeof MefDevSelectComponent], [typeof i2.CommonModule, typeof i5.FormsModule, typeof i6.OverlayModule], [typeof OptionPipe, typeof MefDevOptionComponent, typeof MefDevSelectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevSelectModule>;
+}
+
+declare const mefDevCardComponents: (typeof CardSimpleComponent)[];
+declare class MefDevCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevCardModule, [typeof CardSimpleComponent], [typeof i2.CommonModule, typeof MefDevCollapseModule, typeof MefDevSelectModule], [typeof CardSimpleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevCardModule>;
+}
+
+/**
+  * Fill Component for a modal window.
+  *
+  * Example of usage:
+  * ```
+  * <mefdev-fill-modal #pin_modal>
+  *   <!-- Modal header content -->
+  *   <ng-template #modal_header>
+  *     <!-- Header content goes here -->
+  *   </ng-template>
+  *
+  *   <!-- Modal footer content -->
+  *   <ng-template #modal_footer>
+  *     <!-- Footer content goes here -->
+  *   </ng-template>
+  * </mefdev-fill-modal>
+  * ```
+  *
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/page_components/modals/fill</example-url>
+  */
+declare class FillComponent implements OnInit {
+    protected visible: boolean;
+    protected dialog?: ElementRef;
+    /**
+    * The header template of the modal window.
+    * ```
+    * <mefdev-fill-modal #pin_modal>
+     *   <ng-template #modal_header>
+     *     <!-- Header content goes here -->
+     *   </ng-template>
+     * </mefdev-fill-modal>
+    * ```
+    */
+    modal_header: TemplateRef<void>;
+    /**
+    * The footer template of the modal window.
+    * ```
+    * <mefdev-fill-modal #pin_modal>
+     *   <ng-template #modal_footer>
+     *     <!-- Footer content goes here -->
+     *   </ng-template>
+     * </mefdev-fill-modal>
+    * ```
+    */
+    modal_footer: TemplateRef<void>;
+    /**
+     * 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:
+     * ```
+     * <mefdev-fill-modal (visibleChange)="onModalClosed($event)"></mefdev-fill-modal>
+     * ```
+     */
+    visibleChange: EventEmitter<boolean>;
+    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<FillComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FillComponent, "mefdev-fill-modal", never, { "show": { "alias": "show"; "required": false; }; }, { "visibleChange": "visibleChange"; }, ["modal_header", "modal_footer"], ["*"], false, never>;
+}
+
+/**
+* A component representing a slide-up modal window.
+*
+* Example of usage:
+*
+* ```
+* <mefdev-slide-up-modal [show]="showModal">
+*   <ng-template #modal_header>
+*     <h4>Modal Header</h4>
+*   </ng-template>
+*   <ng-template #modal_footer>
+*     <button (click)="closeModal()">Close</button>
+*   </ng-template>
+*   <div class="modal-body">
+*     Content goes here...
+*   </div>
+* </mefdev-slide-up-modal>
+* ```
+* <example-url>https://platform.mef.dev/ui_kit_demo/view/page_components/modals/slide_up</example-url>
+*/
+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<void>;
+    /**
+     * Reference to the template for the modal footer.
+     * Use this template to customize the footer of the modal.
+     */
+    modal_footer: TemplateRef<void>;
+    /**
+     * 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<boolean>;
+    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<SlideUpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlideUpComponent, "mefdev-slide-up-modal", never, { "show": { "alias": "show"; "required": false; }; }, { "visibleChange": "visibleChange"; }, ["modal_header", "modal_footer"], ["*"], false, never>;
+}
+
+declare const enum ModalSize {
+    sm = "sm",
+    md = "md",
+    lg = "lg"
+}
+
+/**
+   * A component representing a slide-right modal window.
+  *
+  * Example of usage:
+  *
+  * ```
+  * <mefdev-slide-right-modal [size]="ModalSize.lg" [show]="showModal">
+  *   <ng-template #modal_header>
+  *     <h4>Modal Header</h4>
+  *   </ng-template>
+  *   <ng-template #modal_footer>
+  *     <button (click)="closeModal()">Close</button>
+  *   </ng-template>
+  *   <div class="modal-body">
+  *     Content goes here...
+  *   </div>
+  * </mefdev-slide-right-modal>
+  * ```
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/page_components/modals/slide_right</example-url>
+  */
+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<void>;
+    /**
+     * Reference to the template for the modal footer.
+     * Use this template to customize the footer of the modal.
+     */
+    modal_footer: TemplateRef<void>;
+    /**
+     * 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:
+     * ```
+     * <mefdev-fill-modal (visibleChange)="onModalClosed($event)"></mefdev-fill-modal>
+     * ```
+     */
+    visibleChange: EventEmitter<boolean>;
+    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<SlideRightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlideRightComponent, "mefdev-slide-right-modal", never, { "size": { "alias": "size"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, { "visibleChange": "visibleChange"; }, ["modal_header", "modal_footer"], ["*"], false, never>;
+}
+
+/**
+ * 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<RightFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RightFilterComponent, "mefdev-right-filter", never, { "showStandartOpenButton": { "alias": "showStandartOpenButton"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MefDevModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevModalModule, [typeof FillComponent, typeof SlideUpComponent, typeof SlideRightComponent, typeof RightFilterComponent], [typeof i2.CommonModule, typeof MefDevSelectModule], [typeof FillComponent, typeof SlideUpComponent, typeof SlideRightComponent, typeof RightFilterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevModalModule>;
+}
+
+/**
+  * A component representing a central page layout.
+  *
+  * Example of usage:
+  *
+  * ```
+  * <mefdev-central-page [width]="'80%'">
+  *   Content goes here...
+  * </mefdev-central-page>
+  * ```
+  *
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/page_layouts/central_page</example-url>
+  */
+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<CentralPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CentralPageComponent, "mefdev-central-page", never, { "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+/**
+ * A component representing a central page layout.
+ *
+ * Example of usage:
+ *
+ * ```
+ * <mefdev-central-page>
+ *   <mefdev-central-page-row>
+ *     Content goes here...
+ *   </mefdev-central-page-row>
+ * </mefdev-central-page>
+ * ```
+*/
+declare class CentralPageRowComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CentralPageRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CentralPageRowComponent, "mefdev-central-page-row", never, {}, {}, never, ["*"], false, never>;
+}
+
+/**
+* A component representing a table page layout.
+*
+* Example of usage:
+*
+* ```
+* <mefdev-table-page>
+*   <ng-template #filter_colum>
+*     <!-- Content for the filter column -->
+*   </ng-template>
+* </mefdev-table-page>
+* ```
+*
+* <example-url>https://platform.mef.dev/ui_kit_demo/view/page_layouts/table_page</example-url>
+*/
+declare class TablePageComponent implements OnInit {
+    /**
+      * The template reference to the content of the filter column.
+      * ```
+      *   <ng-template #filter_colum>
+      *     <!-- Content for the filter column -->
+      *   </ng-template>
+      * ```
+    */
+    filter_colum: TemplateRef<void>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TablePageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TablePageComponent, "mefdev-table-page", never, {}, {}, ["filter_colum"], ["*"], false, never>;
+}
+
+/**
+* A component representing a manage page layout.
+*
+* Example of usage:
+*
+* ```
+* <mefdev-manage-page [startTabInd]="0">
+*   <ng-template #card_title>
+*     Title of the card
+*   </ng-template>
+*   <ng-template #tabs_block>
+*     Content of the tabs block
+*   </ng-template>
+* </mefdev-manage-page>
+* ```
+*
+* Example of usage:
+* <example-url>https://platform.mef.dev/ui_kit_demo/view/page_layouts/manage_page</example-url>
+*/
+declare class ManagePageComponent implements OnInit {
+    /**
+     * The template reference to the card title.
+     * ```
+     * <mefdev-manage-page>
+     *   <ng-template #card_title>
+     *     Title of the card
+     *   </ng-template>
+     * </mefdev-manage-page>
+     * ```
+     */
+    card_title: TemplateRef<void>;
+    /**
+     * The template reference to the tabs block.
+     * ```
+     * <mefdev-manage-page>
+     *   <ng-template #tabs_block>
+     *     Content of the tabs block
+     *   </ng-template>
+     * </mefdev-manage-page>
+     * ```
+     */
+    tabs_block: TemplateRef<void>;
+    /**
+     * The index of the starting tab.
+     * ```
+     * <mefdev-manage-page [startTabInd]="0">
+     *      Content goes here...
+     * </mefdev-manage-page>
+     * ```
+     */
+    startTabInd: number;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManagePageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ManagePageComponent, "mefdev-manage-page", never, { "startTabInd": { "alias": "startTabInd"; "required": false; }; }, {}, ["card_title", "tabs_block"], ["*"], false, never>;
+}
+
+declare class MefDevPageLayoutsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevPageLayoutsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevPageLayoutsModule, [typeof CentralPageComponent, typeof CentralPageRowComponent, typeof TablePageComponent, typeof ManagePageComponent], [typeof i2.CommonModule], [typeof CentralPageComponent, typeof CentralPageRowComponent, typeof TablePageComponent, typeof ManagePageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevPageLayoutsModule>;
+}
+
+/**
+ * @ignore
+ */
+declare class StageComponent {
+    currentExecutorStep: number;
+    isRightModal: boolean;
+    isCompleted: boolean;
+    title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StageComponent, "mefdev-stage", never, { "currentExecutorStep": { "alias": "currentExecutorStep"; "required": false; }; "isRightModal": { "alias": "isRightModal"; "required": false; }; "isCompleted": { "alias": "isCompleted"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * 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:
+ *
+ * ```
+ *  <mefdev-executor-page
+ *     [title]="'Executor title 1'"
+ *     [isActive]="mainExecutor.activePageInd === 0"
+ *     [isCompleted]="mainExecutor.activePageInd >= 0"
+ *     class="yourClass">
+ *      <!-- Content of the first executor step -->
+ *  </mefdev-executor-page>
+ *  <mefdev-executor-page
+ *     [title]="'Executor title 2'"
+ *     [isActive]="mainExecutor.activePageInd === 1"
+ *     [isCompleted]="mainExecutor.activePageInd >= 1"
+ *     class="yourClass">
+ *      <!-- Content of the second executor step -->
+ *  </mefdev-executor-page>
+ *  <mefdev-executor-page
+ *     [title]="'Executor title 3'"
+ *     [isActive]="mainExecutor.activePageInd === 2"
+ *     [isCompleted]="mainExecutor.activePageInd >= 2"
+ *     class="yourClass">
+ *      <!-- Content of the third executor step -->
+ *  </mefdev-executor-page>
+ * ```
+ *
+  */
+declare class MefdevExecutorPageComponent implements OnChanges {
+    private _mainExecutor;
+    private _elementRef;
+    /**
+     * The title of the step
+     * @usageNotes
+     * ```
+     *  <mefdev-executor-page [title]="'Description of situation 1'"></mefdev-executor-page>
+     * ```
+     */
+    title: string;
+    /**
+     * The input parameter that corresponds to whether the current step matches the respective page.
+     * The value of the active page is passed by reference from the specific component StepExecutorComponent.
+     *
+     * @usageNotes
+     * ```
+     *  <mefdev-step-executor #mainExecutor>
+     *    <mefdev-executor-page [isActive]="mainExecutor.activePageInd === 0">
+     *    <mefdev-executor-page [isActive]="mainExecutor.activePageInd === 1">
+     *    <mefdev-executor-page [isActive]="mainExecutor.activePageInd === 2">
+     *  </<mefdev-step-executor>
+     *
+     * ```
+     */
+    isActive: boolean;
+    /**
+     * The input parameter that checks whether the step is completed.
+     *
+     * @usageNotes
+     * ```
+     *  <mefdev-executor-page [isCompleted]="mainExecutor.activePageInd >= 0"></mefdev-executor-page>
+     * ```
+     */
+    isCompleted: boolean;
+    /**
+     * The output parameter that emits a boolean value indicating whether our completed step has changed.
+     *
+     * @usageNotes
+     * ```
+     *  <mefdev-executor-page (isCompletedChange)="onStepChanged($event)"></mefdev-executor-page>
+     * ```
+     */
+    isCompletedChange: EventEmitter<boolean>;
+    elRef: ElementRef;
+    constructor(_mainExecutor: StepExecutorComponent, _elementRef: ElementRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefdevExecutorPageComponent, [{ host: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefdevExecutorPageComponent, "mefdev-executor-page", never, { "title": { "alias": "title"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "isCompleted": { "alias": "isCompleted"; "required": false; }; }, { "isCompletedChange": "isCompletedChange"; }, never, ["*"], false, never>;
+}
+
+/**
+ * Wrapper component that represents a specific encapsulated executor.
+ *
+ * Example of usage:
+ *```
+ * <mefdev-step-executor #mainExecutor [view]="'regular'">
+ *
+ *  <ng-template #title>
+ *    <!-- Content for the executor title -->
+ *  </ng-template>
+ *  <ng-template #description>
+ *    <!-- Content for the executor description -->
+ *  </ng-template>
+ *
+ *  <mefdev-executor-page
+ *     [title]="'Description of situation 1'"
+ *     [isActive]="mainExecutor.activePageInd === 0"
+ *     [isCompleted]="mainExecutor.activePageInd >= 0">
+ *      <!-- Content of the first executor step -->
+ *  </mefdev-executor-page>
+ *  <mefdev-executor-page
+ *    [title]="'Description of situation 2'"
+ *    [isActive]="mainExecutor.activePageInd === 1"
+ *    [isCompleted]="mainExecutor.activePageInd >= 1">
+ *     <!-- Content of the second executor step -->
+ *  </mefdev-executor-page>
+ *  <mefdev-executor-page
+ *    [title]="'Description of situation 3'"
+ *    [isActive]="mainExecutor.activePageInd === 2"
+ *    [isCompleted]="mainExecutor.activePageInd >= 2">
+ *      <!-- Content of the third executor step -->
+ *  </mefdev-executor-page>
+ *
+ *  <ng-template #footer>
+ *    <!-- Content for the executor footer -->
+ *  <ng-template>
+ *
+ * </mefdev-step-executor>
+ *
+ *```
+ * <example-url>https://platform.mef.dev/ui_kit_demo/view/utils/main_executor</example-url>
+ */
+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
+     * ```
+     *  <mefdev-step-executor #mainExecutor [view]="'regular'"></mefdev-step-executor>
+     * ```
+     */
+    view: string;
+    /**
+     * An optional input parameter that specifies whether to show your executor.
+     * Usually used when you have a slideup or right executor view
+     *
+     * @usageNotes
+     * ```
+     *  <mefdev-step-executor [show]="true" [view]="'right'" #mainExecutor></mefdev-step-executor>
+     * ```
+     */
+    show: boolean;
+    /**
+     * ViewChild reference to the host executor content.
+     */
+    container: ElementRef<HTMLElement>;
+    /**
+     * Template for displaying the content of the executor title.
+     *
+     * @usageNotes
+     * ```
+     * <ng-template #title>
+     *   <!-- Content for the executor title -->
+     * </ng-template>
+     * ```
+     */
+    title: TemplateRef<void>;
+    /**
+     * Template for displaying the content of the executor description.
+     *
+     * @usageNotes
+     * ```
+     * <ng-template #description>
+     *  <!-- Content for the executor description -->
+     * </ng-template>
+     * ```
+     */
+    description: TemplateRef<void>;
+    /**
+     * Template for displaying the content of the executor footer.
+     *
+     * @usageNotes
+     * ```
+     * <ng-template #footer>
+     *    <!-- Content for the executor footer -->
+     * </ng-template>
+     * ```
+     */
+    footer: TemplateRef<void>;
+    /**
+     * The output parameter that emits the class of the active page - active step.
+     *
+     * @usageNotes
+     * ```
+     *  <mefdev-step-executor #mainExecutor (onActivePageChange)="getActiveStep($event)"></mefdev-step-executor>
+     * ```
+     */
+    onActivePageChange: EventEmitter<MefdevExecutorPageComponent>;
+    /**
+     * An output parameter that conveys the current state of the stepper in modal view
+     *
+     * @usageNotes
+     * ```
+     * <mefdev-step-executor [view]="'modal'" (modalStepExecutorStateChange)="getModalExecutorStateValue($event)" #modalExecutor></mefdev-step-executor>
+     * ```
+     */
+    modalStepExecutorStateChange: EventEmitter<boolean>;
+    /**
+     * An output parameter that conveys the current state of the stepper in right view
+     *
+     * @usageNotes
+     * ```
+     * <mefdev-step-executor [view]="'right'" (modalStepExecutorStateChange)="getModalExecutorStateValue($event)" #rightExecutor></mefdev-step-executor>
+     * ```
+     */
+    rightStepExecutorStateChange: EventEmitter<boolean>;
+    _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<StepExecutorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepExecutorComponent, "mefdev-step-executor", never, { "view": { "alias": "view"; "required": true; }; "show": { "alias": "show"; "required": false; }; }, { "onActivePageChange": "onActivePageChange"; "modalStepExecutorStateChange": "modalStepExecutorStateChange"; "rightStepExecutorStateChange": "rightStepExecutorStateChange"; }, ["title", "description", "footer"], never, false, never>;
+}
+
+declare class MefDevStepExecutorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevStepExecutorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevStepExecutorModule, [typeof StepExecutorComponent, typeof MefdevExecutorPageComponent, typeof StageComponent], [typeof MefDevModalModule, typeof i2.CommonModule, typeof i5.FormsModule], [typeof StepExecutorComponent, typeof MefdevExecutorPageComponent, typeof StageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevStepExecutorModule>;
+}
+
+declare class MefdevDropdownMenuComponent {
+    private _eref;
+    label: TemplateRef<void>;
+    protected isOpen: boolean;
+    constructor(_eref: ElementRef);
+    onClick($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefdevDropdownMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefdevDropdownMenuComponent, "mefdev-dropdown-menu", never, {}, {}, ["label"], ["*"], false, never>;
+}
+
+declare class MefDevDropDownMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevDropDownMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevDropDownMenuModule, [typeof MefdevDropdownMenuComponent], [typeof i2.CommonModule], [typeof MefdevDropdownMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevDropDownMenuModule>;
+}
+
+/**
+ * Component representing a progress bar.
+ *
+ * Example of usage:
+ *
+ * ```
+ * <mefdev-progress type="linear" color="blue" [thick]="true"></mefdev-progress>
+ * <mefdev-progress type="circle" color="red" [indeterminate]="true"></mefdev-progress>
+ * ```
+ */
+declare class MefDevProgressComponent {
+    _value: number;
+    _value2: any;
+    /**
+     * The type of progress bar.
+     * Possible values: "linear" | "circle".
+     * Default value: "linear".
+     */
+    type: string;
+    /**
+     * The color of the progress bar.
+     * Possible values: any valid CSS color value.
+     * Default value: none.
+     */
+    color: string;
+    /**
+     * Determines whether the progress bar is thick.
+     * Default value: false.
+     */
+    thick: boolean;
+    /**
+     * Determines whether the progress bar is indeterminate.
+     * Default value: false.
+     */
+    indeterminate: boolean;
+    /**
+     * The value of the progress bar.
+     * For the "circle" type, it should be a number between 0 and 100.
+     */
+    set value(value: number);
+    get value(): number;
+    /**
+     * Additional value property.
+     */
+    get value2(): any;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevProgressComponent, "mefdev-progress", never, { "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; "thick": { "alias": "thick"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProgressConfig {
+    color: string;
+    thickness: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressConfig, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressConfig>;
+}
+
+declare class MefDevProgressModule {
+    static forRoot(): ModuleWithProviders<MefDevProgressModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevProgressModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevProgressModule, [typeof MefDevProgressComponent], [typeof i2.CommonModule], [typeof MefDevProgressComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevProgressModule>;
+}
+
+/**
+  * @component
+  * @skipTemplateDoc: true
+  * Example of usage:
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/controls/switch</example-url>
+*/
+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:
+   * ```
+   * <mefdev-switch (onChange)="handleSwitchChange($event)"></mefdev-switch>
+   * ```
+   */
+    onChange: (value: boolean) => void;
+    onTouched: () => void;
+    /**
+   * Sets the value of the switch.
+   *
+   * @input
+   * @param value The value of the switch.
+   *
+   * Usage example:
+   * ```
+   * <mefdev-switch [Value]="true"></mefdev-switch>
+   * ```
+   */
+    set Value(value: boolean);
+    /**
+   * Sets the size of the switch.
+   *
+   * @input
+   * @param value The size of the switch (e.g., "small", "large").
+   *
+   * Usage example:
+   * ```
+   * <mefdev-switch [Size]="'small'"></mefdev-switch>
+   * ```
+   */
+    set Size(value: string);
+    /**
+   * Sets the color of the switch.
+   *
+   * @input
+   * @param value The color of the switch (e.g., "primary", "secondary").
+   *
+   * Usage example:
+   * ```
+   * <mefdev-switch [Color]="'primary'"></mefdev-switch>
+   * ```
+   */
+    set Color(value: string);
+    /**
+   * Gets the current size of the switch.
+   *
+   * @input
+   * @returns The size of the switch.
+   *
+   * Usage example:
+   * ```
+   * const size = mySwitchComponent.Size;
+   * ```
+   */
+    get Size(): string;
+    /**
+   * Sets the disabled state of the switch.
+   *
+   * @input
+   * @param value The disabled state of the switch.
+   *
+   * Usage example:
+   * ```
+   * <mefdev-switch [Disabled]="true"></mefdev-switch>
+   * ```
+   */
+    set Disabled(value: boolean);
+    /**
+ * Gets the current disabled state of the switch.
+ *
+ * @input
+ * @returns The disabled state of the switch.
+ *
+ * Usage example:
+ * ```
+ * const disabled = mySwitchComponent.Disabled;
+ * ```
+ */
+    get Disabled(): boolean;
+    /**
+   * Handles the click event of the switch.
+   *
+   * @param e The click event object.
+   *
+   * Usage example:
+   * ```
+   * <mefdev-switch (click)="handleSwitchClick($event)"></mefdev-switch>
+   * ```
+   */
+    onClick(e: MouseEvent): void;
+    /**
+     * Updates the value of the switch.
+     *
+     * @param value The new value of the switch.
+     *
+     * Usage example:
+     * ```
+     * this.updateValue(true);
+     * ```
+     */
+    updateValue(value: boolean): void;
+    /**
+   * Sets the class map for the switch.
+   *
+   * Usage example:
+   * ```
+   * this.setClassMap();
+   * ```
+   */
+    setClassMap(): void;
+    /**
+     * Writes a new value to the switch.
+     *
+     * @param value The new value of the switch.
+     *
+     * Usage example:
+     * ```
+     * this.writeValue(true);
+     * ```
+     */
+    writeValue(value: boolean): void;
+    /**
+   * Registers a callback function to be executed when the switch value changes.
+   *
+   * @param fn The callback function.
+   *
+   * Usage example:
+   * ```
+   * this.registerOnChange(value => {
+   *   // Do something with the new value
+   * });
+   * ```
+   */
+    registerOnChange(fn: (_: boolean) => void): void;
+    /**
+   * Registers a callback function to be executed when the switch is touched.
+   *
+   * @param fn The callback function.
+   *
+   * Usage example:
+   * ```
+   * this.registerOnTouched(() => {
+   *   // Do something when the switch is touched
+   * });
+   * ```
+   */
+    registerOnTouched(fn: () => void): void;
+    /**
+   * Sets the disabled state of the switch.
+   *
+   * @param isDisabled The disabled state of the switch.
+   *
+   * Usage example:
+   * ```
+   * this.setDisabledState(true);
+   * ```
+   */
+    setDisabledState(isDisabled: boolean): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevSwitchComponent, "mefdev-switch", never, { "Value": { "alias": "Value"; "required": false; }; "Size": { "alias": "Size"; "required": false; }; "Color": { "alias": "Color"; "required": false; }; "Disabled": { "alias": "Disabled"; "required": false; }; }, { "onChange": "onChange"; }, never, ["[checked]", "[unchecked]"], false, never>;
+}
+
+declare class MefDevSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevSwitchModule, [typeof MefDevSwitchComponent], [typeof i2.CommonModule], [typeof MefDevSwitchComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevSwitchModule>;
+}
+
+/**
+ * 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<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevTabBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevTabBodyComponent, "mefdev-tab-body", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+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<MefDevTabLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MefDevTabLabelDirective, "[mefdev-tab-label]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+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<MefDevTabsInkBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MefDevTabsInkBarDirective, "[mefdev-tabs-ink-bar]", never, { "Animated": { "alias": "Animated"; "required": false; }; "PositionMode": { "alias": "PositionMode"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/** 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<void>;
+    _labelWrappers: QueryList<MefDevTabLabelDirective>;
+    _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<MefDevTabsNavComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevTabsNavComponent, "mefdev-tabs-nav", never, { "Size": { "alias": "Size"; "required": false; }; "Animated": { "alias": "Animated"; "required": false; }; "Position": { "alias": "Position"; "required": false; }; "HideBar": { "alias": "HideBar"; "required": false; }; "Type": { "alias": "Type"; "required": false; }; "ShowPagination": { "alias": "ShowPagination"; "required": false; }; "PositionMode": { "alias": "PositionMode"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, {}, ["_tabBarExtraContent", "_labelWrappers"], ["*"], false, never>;
+}
+
+/** 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
+  * <mefdev-tabset TabPosition="top" Animated="true" ShowPagination="true">
+  *   <mefdev-tab label="Tab 1">Tab 1 content</mefdev-tab>
+  *   <mefdev-tab label="Tab 2">Tab 2 content</mefdev-tab>
+  * </mefdev-tabset>
+  *
+  * Example of usage:
+  * <example-url>https://platform.mef.dev/ui_kit_demo/view/page_components/tabset</example-url>
+  */
+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<void>;
+    TabBarExtraContent: TemplateRef<void>;
+    _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<number>;
+    /**
+     * Event emitted when a tab is selected.
+     * @example
+     * <mefdev-tabset (SelectChange)="onTabSelect($event)"></mefdev-tabset>
+     */
+    SelectChange: EventEmitter<TabChangeEvent>;
+    /**
+     * 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.
+     * ```
+     * <button (click)="clickLabel(0)">Select Tab 1</button>
+     *```
+     */
+    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<MefDevTabSetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevTabSetComponent, "mefdev-tabset", never, { "TabBarExtraTemplate": { "alias": "TabBarExtraTemplate"; "required": false; }; "Animated": { "alias": "Animated"; "required": false; }; "ShowPagination": { "alias": "ShowPagination"; "required": false; }; "Hide": { "alias": "Hide"; "required": false; }; "SelectedIndex": { "alias": "SelectedIndex"; "required": false; }; "Size": { "alias": "Size"; "required": false; }; "TabPosition": { "alias": "TabPosition"; "required": false; }; "extraTabClass": { "alias": "extraTabClass"; "required": false; }; "extraTabContentClass": { "alias": "extraTabContentClass"; "required": false; }; "Type": { "alias": "Type"; "required": false; }; "tabAnimation": { "alias": "tabAnimation"; "required": false; }; }, { "SelectedIndexChange": "SelectedIndexChange"; "SelectChange": "SelectChange"; }, ["TabBarExtraContent"], never, false, never>;
+}
+
+declare class MefDevTabComponent implements OnDestroy, OnInit {
+    private MefDevTabSetComponent;
+    private disabled;
+    position: number | null;
+    origin: number | null;
+    /**
+     * Sets the disabled state of the tab.
+     *```html
+     * <mefdev-tab [Disabled]="true"></mefdev-tab>
+     * ```
+     */
+    set Disabled(value: boolean);
+    /**
+    * Gets the disabled state of the tab.
+    */
+    get Disabled(): boolean;
+    /**
+     * Event emitted when the tab is selected.
+     *```html
+     * <mefdev-tab (pgSelect)="onTabSelect()"></mefdev-tab>
+     * ```
+     */
+    pgSelect: EventEmitter<any>;
+    /**
+     * Event emitted when the tab is clicked.
+     *```html
+     * <mefdev-tab (pgClick)="onTabClick()"></mefdev-tab>
+     * ```
+     */
+    pgClick: EventEmitter<any>;
+    /**
+     * Event emitted when the tab is deselected.
+     *```html
+     * <mefdev-tab (pgDeselect)="onTabDeselect()"></mefdev-tab>
+     *```
+     */
+    pgDeselect: EventEmitter<any>;
+    /**
+     * Reference to the template for the tab heading.
+     */
+    _tabHeading: TemplateRef<void>;
+    /**
+     * Reference to the template for the tab content.
+     */
+    _content: TemplateRef<void>;
+    /**
+     * Gets the template for the tab content.
+     *```html
+     * <ng-container *ngTemplateOutlet="content"></ng-container>
+     *```
+     */
+    get content(): TemplateRef<void> | 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<MefDevTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MefDevTabComponent, "mefdev-tab", never, { "Disabled": { "alias": "Disabled"; "required": false; }; }, { "pgSelect": "pgSelect"; "pgClick": "pgClick"; "pgDeselect": "pgDeselect"; }, ["_tabHeading"], ["*"], false, never>;
+}
+
+declare class MefDevTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MefDevTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MefDevTabsModule, [typeof MefDevTabComponent, typeof MefDevTabSetComponent, typeof MefDevTabsNavComponent, typeof MefDevTabLabelDirective, typeof MefDevTabsInkBarDirective, typeof MefDevTabBodyComponent], [typeof i2.CommonModule], [typeof MefDevTabComponent, typeof MefDevTabSetComponent, typeof MefDevTabsNavComponent, typeof MefDevTabLabelDirective, typeof MefDevTabsInkBarDirective, typeof MefDevTabBodyComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MefDevTabsModule>;
+}
+
+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<AccordionBase>;
+
+interface ExpansionPanelBase extends CdkAccordionItem {
+    hideToggle: boolean;
+}
+declare const MD_EXPANSION_PANEL: InjectionToken<ExpansionPanelBase>;
+
+declare class MDExpansionPanelContent {
+    _template: TemplateRef<any>;
+    _expansionPanel: ExpansionPanelBase | null;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDExpansionPanelContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDExpansionPanelContent, "ng-template[mdExpansionPanelContent]", never, {}, {}, never, never, true, never>;
+}
+
+/** 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<ExpansionPanelDefaultOptions>;
+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<void>;
+    /** Fires after the collapse transition completes. */
+    readonly afterCollapse: EventEmitter<void>;
+    /** Emits whenever any @Input changes (for consumers to react). */
+    readonly _inputChanges: Subject<SimpleChanges>;
+    /** Optional parent accordion context (if inside an accordion). */
+    accordion: AccordionBase;
+    /** Lazily-projected body content (<ng-template mdExpansionPanelContent>). */
+    _lazyContent: MDExpansionPanelContent;
+    /** Body host element (focus containment & transition target). */
+    _body: ElementRef<HTMLElement>;
+    /** Wrapper element that handles the grid/height transition. */
+    protected _bodyWrapper: ElementRef<HTMLElement> | 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<MDExpansionPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDExpansionPanel, "md-expansion-panel", ["expansionPanel"], { "hideToggle": { "alias": "hideToggle"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; }, { "afterExpand": "afterExpand"; "afterCollapse": "afterCollapse"; }, ["_lazyContent"], ["md-expansion-panel-header", "*", "action-row"], true, never>;
+    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<ExpansionPanelActionRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpansionPanelActionRow, "action-row", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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<MDExpansionPanelHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDExpansionPanelHeader, "md-expansion-panel-header", never, { "expandedHeight": { "alias": "expandedHeight"; "required": false; }; "collapsedHeight": { "alias": "collapsedHeight"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, never, ["md-panel-title", "md-panel-description", "*"], true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+}
+/** Projected description container inside the header (styling hook). */
+declare class ExpansionPanelDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpansionPanelDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpansionPanelDescription, "panel-description", never, {}, {}, never, never, true, never>;
+}
+/** Projected title container inside the header (styling hook). */
+declare class ExpansionPanelTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpansionPanelTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpansionPanelTitle, "panel-title", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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 Accordion 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<MDExpansionPanelHeader>;
+    /** 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<Accordion, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Accordion, "md-accordion", ["mdAccordion"], { "hideToggle": { "alias": "hideToggle"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; }, {}, ["_headers"], never, true, never>;
+    static ngAcceptInputType_hideToggle: unknown;
+}
+
+declare const components: (typeof ExpansionPanelDescription)[];
+declare class MDCollapseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDCollapseModule, never, [typeof i2.CommonModule, typeof Accordion, typeof MDExpansionPanel, typeof ExpansionPanelActionRow, typeof MDExpansionPanelHeader, typeof ExpansionPanelTitle, typeof ExpansionPanelDescription, typeof MDExpansionPanelContent], [typeof Accordion, typeof MDExpansionPanel, typeof ExpansionPanelActionRow, typeof MDExpansionPanelHeader, typeof ExpansionPanelTitle, typeof ExpansionPanelDescription, typeof MDExpansionPanelContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDCollapseModule>;
+}
+
+/**
+ * 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<CardConfig>;
+/**
+ * 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 'raised' (or {@link CARD_CONFIG}.appearance if provided)
+     */
+    appearance: CardAppearance;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDCard, "md-card", ["mdCard"], { "appearance": { "alias": "appearance"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Title directive.
+ *
+ * @example
+ * ```html
+ * <md-card-title>Title</md-card-title>
+ * <div md-card-title>Title</div>
+ * <div [mdCardTitle]>Title</div>
+ * ```
+ *
+ * Adds a semantic class for styling the title area.
+ */
+declare class MDCardTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardTitle, "md-card-title, [md-card-title], [mdCardTitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * 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<MDCardTitleGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDCardTitleGroup, "md-card-title-group", never, {}, {}, never, ["card-title, card-subtitle,\n      [card-title], [card-subtitle],\n      [cardTitle], [cardSubtitle]", "[card-image], [cardImage],\n                    [card-sm-image], [cardImageSmall],\n                    [card-md-image], [cardImageMedium],\n                    [card-lg-image], [cardImageLarge],\n                    [card-xl-image], [cardImageXLarge]", "*"], true, never>;
+}
+/**
+ * Content directive for the main textual/body area of the card.
+ *
+ * @example
+ * ```html
+ * <md-card-content>...</md-card-content>
+ * ```
+ */
+declare class MDCardContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardContent, "md-card-content", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Subtitle directive.
+ *
+ * @example
+ * ```html
+ * <md-card-subtitle>Subtitle</md-card-subtitle>
+ * <div md-card-subtitle>Subtitle</div>
+ * <div [mdCardSubtitle]>Subtitle</div>
+ * ```
+ *
+ * Adds a semantic class for styling the subtitle text.
+ */
+declare class MDCardSubtitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardSubtitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardSubtitle, "md-card-subtitle, [md-card-subtitle], [mdCardSubtitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * 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
+     * <md-card-actions align="end">
+     *   <button md-button>Save</button>
+     * </md-card-actions>
+     * ```
+     */
+    align: 'start' | 'end';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardActions, "md-card-actions", ["mdCardActions"], { "align": { "alias": "align"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * 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<MDCardHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDCardHeader, "md-card-header", never, {}, {}, never, ["[card-avatar], [cardAvatar]", "card-title, card-subtitle,\n      [card-title], [card-subtitle],\n      [cardTitle], [cardSubtitle]", "*"], true, never>;
+}
+/**
+ * Footer directive.
+ * A semantic area for card footers—secondary info, meta, or supplementary actions.
+ */
+declare class MDCardFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardFooter, "md-card-footer", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Image directive (default size).
+ * Applies media-related classes to display a cover/media area inside the card.
+ *
+ * @example
+ * ```html
+ * <div md-card-image style="background-image:url(...)"></div>
+ * <div [mdCardImage]></div>
+ * ```
+ *
+ * Note: Actual sizing (height/ratio) should be defined in `card.scss`.
+ */
+declare class MDCardImage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardImage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardImage, "[md-card-image], [mdCardImage]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Small image directive.
+ * Adds the same base media classes; size differences should be implemented in CSS.
+ */
+declare class MDCardSmImage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardSmImage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardSmImage, "[md-card-sm-image], [mdCardImageSmall]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Medium image directive.
+ * Adds the same base media classes; size differences should be implemented in CSS.
+ */
+declare class MDCardMdImage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardMdImage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardMdImage, "[md-card-md-image], [mdCardImageMedium]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Large image directive.
+ * Adds the same base media classes; size differences should be implemented in CSS.
+ */
+declare class MDCardLgImage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardLgImage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardLgImage, "[md-card-lg-image], [mdCardImageLarge]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Extra-large image directive.
+ * Adds the same base media classes; size differences should be implemented in CSS.
+ */
+declare class MDCardXlImage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardXlImage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardXlImage, "[md-card-xl-image], [mdCardImageXLarge]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * 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<MDCardAvatar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDCardAvatar, "[md-card-avatar], [mdCardAvatar]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MDCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDCardModule, never, [typeof MDCard, typeof MDCardActions, typeof MDCardAvatar, typeof MDCardContent, typeof MDCardFooter, typeof MDCardHeader, typeof MDCardImage, typeof MDCardLgImage, typeof MDCardMdImage, typeof MDCardSmImage, typeof MDCardSubtitle, typeof MDCardTitle, typeof MDCardTitleGroup, typeof MDCardXlImage], [typeof MDCard, typeof MDCardActions, typeof MDCardAvatar, typeof MDCardContent, typeof MDCardFooter, typeof MDCardHeader, typeof MDCardImage, typeof MDCardLgImage, typeof MDCardMdImage, typeof MDCardSmImage, typeof MDCardSubtitle, typeof MDCardTitle, typeof MDCardTitleGroup, typeof MDCardXlImage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDCardModule>;
+}
+
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+type DialogRole = 'dialog' | 'alertdialog';
+interface DialogPosition {
+    top?: string;
+    bottom?: string;
+    left?: string;
+    right?: string;
+}
+declare class MefDevDialogConfig<D = any> {
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+    id?: string;
+    role?: DialogRole;
+    panelClass?: string | string[];
+    hasBackdrop?: boolean;
+    backdropClass?: string | string[];
+    disableClose?: boolean;
+    closePredicate?: <Result = unknown, Component = unknown, Config extends DialogConfig = MefDevDialogConfig>(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<MefDevDialogConfig> implements OnDestroy {
+    /** Emits animation lifecycle states understood by the dialog ref. */
+    _animationStateChanged: EventEmitter<LegacyDialogAnimationEvent>;
+    /** 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<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDDialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDDialogContainer, "md-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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<T, R = any> {
+    /** 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<T> | 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<R, T>, 
+    /** 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<void>;
+    /** Stream that emits the result after the dialog is fully closed and disposed. */
+    afterClosed(): Observable<R | undefined>;
+    /** Stream that emits right before the dialog starts closing with the result (if any). */
+    beforeClosed(): Observable<R | undefined>;
+    /** Backdrop click stream (useful for custom close logic / analytics). */
+    backdropClick(): Observable<MouseEvent>;
+    /** Keydown stream scoped to the dialog overlay (e.g., listen for ESC). */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * 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<R>(ref: MefDevDialogRef<R>, interactionType: FocusOrigin, result?: R): void;
+
+/** Injection token used to pass arbitrary data into a dialog instance. */
+declare const DIALOG_DATA: InjectionToken<any>;
+/** Token for providing global/default dialog configuration. */
+declare const DIALOG_DEFAULT_OPTIONS: InjectionToken<MefDevDialogConfig<any>>;
+/**
+ * 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<any>[];
+    /** Stream that emits after each dialog is opened (delegates to parent if present). */
+    get afterOpened(): Subject<MefDevDialogRef<any>>;
+    /** 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<void>;
+    constructor();
+    /** Overload signatures for component vs template dialogs. */
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: MefDevDialogConfig<D>): MefDevDialogRef<T, R>;
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: MefDevDialogConfig<D>): MefDevDialogRef<T, R>;
+    open<T, D = any, R = any>(template: ComponentType<T> | TemplateRef<T>, config?: MefDevDialogConfig<D>): MefDevDialogRef<T, R>;
+    /** Closes all currently open dialogs (in stack order). */
+    closeAll(): void;
+    /** Finds an open dialog by id (if any). */
+    getDialogById(id: string): MefDevDialogRef<any> | 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<MDDialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MDDialog>;
+}
+
+/**
+ * Button-like directive that closes the nearest dialog when clicked.
+ *
+ * Usage:
+ *   <button md-dialog-close>Close</button>
+ *   <button mdDialogClose="resultValue">Save</button>
+ *
+ * - 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<any, any>;
+    /** 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<MDDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDDialogClose, "[md-dialog-close], [mdDialogClose]", ["mdDialogClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "dialogResult": { "alias": "dialog-close"; "required": false; }; "dialogClose": { "alias": "dialogClose"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * 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<any, any>;
+    /** 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<DialogLayoutSection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogLayoutSection, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * 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<MDDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDDialogTitle, "[md-dialog-title], [mdDialogTitle]", ["mdDialogTitle"], { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Scrollable content section of the dialog.
+ * - Applies MDC content classes.
+ * - Attaches `CdkScrollable` so consumers/tools can query/observe scroll.
+ */
+declare class MDDialogContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDDialogContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDDialogContent, "[md-dialog-content], md-dialog-content, [mdDialogContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Action row of the dialog (typically hosts buttons).
+ * - Applies alignment classes based on `align` input.
+ * - Notifies the container about the presence of an actions section so it can
+ *   adjust layout (e.g., paddings, separators).
+ */
+declare class MDDialogActions extends DialogLayoutSection {
+    /** Horizontal alignment for the action buttons. */
+    align?: 'start' | 'center' | 'end';
+    /** Tell the container an actions section was added. */
+    protected _onAdd(): void;
+    /** Tell the container an actions section was removed. */
+    protected _onRemove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDDialogActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDDialogActions, "[md-dialog-actions], md-dialog-actions, [mdDialogActions]", never, { "align": { "alias": "align"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MDModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDModalModule, never, [typeof i1$1.DialogModule, typeof i6.OverlayModule, typeof i3.PortalModule, typeof MDDialogContainer, typeof MDDialogClose, typeof MDDialogTitle, typeof MDDialogActions, typeof MDDialogContent], [typeof MDDialogContainer, typeof MDDialogClose, typeof MDDialogTitle, typeof MDDialogActions, typeof MDDialogContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDModalModule>;
+}
+
+/**
+ * Marks an embedded template as the label for a step.
+ *
+ * Usage:
+ *   <ng-template mdStepLabel>Custom label</ng-template>
+ *
+ * Extends Angular CDK's CdkStepLabel so the stepper can project
+ * and render this template in the step header area.
+ */
+declare class MDStepLabel extends CdkStepLabel {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDStepLabel, "[mdStepLabel]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Intl/i18n service for the stepper.
+ * Holds user-facing strings and exposes a `changes` stream so components
+ * can re-render when labels are updated at runtime.
+ */
+declare class StepperIntl {
+    /** Emits whenever any of the labels change. Consumers should mark for check on emission. */
+    readonly changes: Subject<void>;
+    /** Label shown next to steps that are marked as optional. */
+    optionalLabel: string;
+    /** Label used to announce or describe completed steps. */
+    completedLabel: string;
+    /** Label indicating that a step is editable. */
+    editableLabel: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepperIntl>;
+}
+/**
+ * Factory that returns the closest parent StepperIntl if available,
+ * otherwise creates a new instance.
+ *
+ * This allows apps/libraries to provide a single shared StepperIntl
+ * higher in the injector tree and have all steppers reuse it.
+ */
+declare function STEPPER_INTL_PROVIDER_FACTORY(parentIntl: StepperIntl): StepperIntl;
+/**
+ * Provider that prefers an ancestor StepperIntl, falling back to a fresh one
+ * created via the factory above when none is found.
+ *
+ * Usage in a module or component:
+ *   providers: [STEPPER_INTL_PROVIDER]
+ */
+declare const STEPPER_INTL_PROVIDER: {
+    provide: typeof StepperIntl;
+    deps: Optional[][];
+    useFactory: typeof STEPPER_INTL_PROVIDER_FACTORY;
+};
+
+/**
+ * Context passed into a custom stepper icon template.
+ * Consumers can use these values inside the template to
+ * render state-aware icons (e.g., different glyphs/colors).
+ */
+interface StepperIconContext {
+    /** 0-based index of the step. */
+    index: number;
+    /** True if this step is currently active/selected. */
+    active: boolean;
+    /** True if this step is marked as optional. */
+    optional: boolean;
+}
+/**
+ * Marks an <ng-template> as a custom icon for a particular step state.
+ *
+ * Usage:
+ *   <ng-template mdStepperIcon="done" let-ctx>
+ *     <!-- ctx: StepperIconContext -->
+ *     <my-done-icon [highlight]="ctx.active"></my-done-icon>
+ *   </ng-template>
+ *
+ * Bind the `stepperIcon` input to one of the StepState values
+ * (e.g., 'number' | 'edit' | 'done' | 'error'), and the stepper
+ * will project this template when the step is in that state.
+ */
+declare class MDStepperIcon {
+    /** Reference to the provided template, instantiated by the stepper as needed. */
+    templateRef: TemplateRef<StepperIconContext>;
+    /** Step state that this icon template should represent. */
+    name: StepState;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepperIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDStepperIcon, "ng-template[mdStepperIcon]", never, { "name": { "alias": "stepperIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Header (tab) for a step in the stepper.
+ * Responsibilities:
+ * - Renders label, state icon/text, and optional/error hints.
+ * - Manages focus (including origin-aware focus for a11y styling).
+ * - Reacts to i18n changes from StepperIntl and marks for check.
+ */
+declare class MDStepHeader extends CdkStepHeader implements AfterViewInit, OnDestroy {
+    /** Stepper i18n service (emits when labels change). */
+    _intl: StepperIntl;
+    /** Focus monitor to track focus origin on the host element. */
+    private _focusMonitor;
+    /** Subscription to StepperIntl changes for OnPush CD. */
+    private _intlSubscription;
+    /** Visual/logical state of this step (e.g., 'number' | 'done' | 'error' | 'edit'). */
+    state: StepState;
+    /** Label can be a template (MDStepLabel) or plain string. */
+    label: MDStepLabel | string;
+    /** Error message displayed when state === 'error'. */
+    errorMessage: string;
+    /** Optional templates to override the default icons by state. */
+    iconOverrides: {
+        [key: string]: TemplateRef<StepperIconContext>;
+    };
+    /** 0-based index of the step within the stepper. */
+    index: number;
+    /** Whether this step is selected (active tab). */
+    selected: boolean;
+    /** Whether this step is currently active (focused/engaged). */
+    active: boolean;
+    /** Marks the step as optional (affects label rendering). */
+    optional: boolean;
+    /** Disables ripple effects on header interactions. */
+    disableRipple: boolean;
+    constructor();
+    /** Begin monitoring focus on the header to apply origin-aware styles. */
+    ngAfterViewInit(): void;
+    /** Cleanup subscriptions and focus monitoring. */
+    ngOnDestroy(): void;
+    /**
+     * Programmatic focus with optional origin (mouse/keyboard/touch/program).
+     * Falls back to direct focus if no origin is provided.
+     */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Returns string label if provided directly, otherwise null. */
+    _stringLabel(): string | null;
+    /** Returns template label if provided, otherwise null. */
+    _templateLabel(): MDStepLabel | null;
+    /** Host element getter used by base classes/templates. */
+    _getHostElement(): HTMLElement;
+    /**
+     * Default text for built-in states when an icon template isn’t provided.
+     * - 'number' → (index + 1) as text
+     * - 'edit'   → 'create'
+     * - 'error'  → 'warning'
+     * - otherwise returns the state string itself
+     */
+    _getDefaultTextForState(state: StepState): string;
+    /** True if no label, no optional/error labels — used for styling empty headers. */
+    protected _hasEmptyLabel(): boolean;
+    /** True if the step is optional and not in error state. */
+    protected _hasOptionalLabel(): boolean;
+    /** True if the current state is 'error'. */
+    protected _hasErrorLabel(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDStepHeader, "md-step-header", never, { "state": { "alias": "state"; "required": false; }; "label": { "alias": "label"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "iconOverrides": { "alias": "iconOverrides"; "required": false; }; "index": { "alias": "index"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "active": { "alias": "active"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Marks an <ng-template> as the content for a step.
+ * Usage:
+ *   <ng-template mdStepContent> ... </ng-template>
+ *
+ * The directive exposes the underlying TemplateRef so parent
+ * components (e.g., a stepper) can instantiate it on demand.
+ */
+declare class MDStepContent {
+    /** Reference to the template to be rendered for this step. */
+    _template: TemplateRef<any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDStepContent, "ng-template[mdStepContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MDStepFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDStepFooter, "[mdStepFooter]", never, {}, {}, never, never, true, never>;
+}
+
+type MDPaginatedStepHeaderItem = FocusableOption & {
+    elementRef: ElementRef;
+};
+/**
+ * ErrorStateMatcher that shows errors only once a control is dirty
+ * (or when the parent form was submitted). Useful for “show on edit”.
+ */
+declare class ShowOnDirtyErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowOnDirtyErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowOnDirtyErrorStateMatcher>;
+}
+/**
+ * Default ErrorStateMatcher used across the stepper.
+ * Marks error when a control is invalid and touched, or the form is submitted.
+ */
+declare class ErrorStateMatcher {
+    isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorStateMatcher>;
+}
+/**
+ * Single step inside the stepper.
+ * - Extends CdkStep and plugs in lazy content via <ng-template mdStepContent>.
+ * - Provides ErrorStateMatcher so the step can decide its own error state.
+ */
+declare class MDStep extends CdkStep implements ErrorStateMatcher, AfterContentInit, OnDestroy {
+    /** Parent-provided matcher used as a baseline in isErrorState. */
+    private _errorStateMatcher;
+    /** View container used to create a portal for lazy content. */
+    private _viewContainerRef;
+    /** Subscription to selected-state changes (to attach lazy content). */
+    private _isSelected;
+    /** Optional projected label for the step header. */
+    stepLabel: MDStepLabel;
+    /** Optional lazy body content template: <ng-template mdStepContent>…</ng-template> */
+    _lazyContent: MDStepContent;
+    /** Portal instance created when the step first becomes selected. */
+    _portal: TemplatePortal;
+    /** Attach lazy content when this step becomes selected for the first time. */
+    ngAfterContentInit(): void;
+    /** Cleanup subscription on destroy. */
+    ngOnDestroy(): void;
+    /**
+     * ErrorStateMatcher implementation for this step.
+     * Combines the injected default matcher with “interacted” state so that
+     * a step can show errors after the user interacted with the step controls.
+     */
+    isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDStep, "md-step", ["mdStep"], {}, {}, ["stepLabel", "_lazyContent"], ["*"], true, never>;
+}
+/**
+ * The stepper container that manages a sequence of md-step children.
+ * - Handles orientation, header/label positioning, and animations.
+ * - Tracks and emits animation lifecycle.
+ * - Supports custom icon overrides via <ng-template mdStepperIcon name="...">.
+ */
+declare class MDStepper extends CdkStepper implements AfterViewInit, AfterContentInit, AfterViewChecked, OnDestroy {
+    /** Run transition listeners outside Angular for perf. */
+    private _ngZone;
+    /** Used to set up/tear down transitionend listeners. */
+    private _renderer;
+    /** Disable animations flag (useful for testing or SSR). */
+    private _animationsDisabled;
+    /** Cleanup handle for the transitionend listener. */
+    private _cleanupTransition;
+    /** Reactive animating flag used by host binding. */
+    protected _isAnimating: i0.WritableSignal<boolean>;
+    /** All step headers rendered by the template. */
+    _stepHeader: QueryList<MDStepHeader>;
+    /** Animated containers used to detect when transitions finish. */
+    _animatedContainers: QueryList<ElementRef>;
+    /** All descendant steps (supports nested usage; CdkStepper handles scoping). */
+    _steps: QueryList<MDStep>;
+    /** Public alias of _steps used by base class. */
+    readonly steps: QueryList<MDStep>;
+    /** Any custom icon templates projected via mdStepperIcon. */
+    _icons: QueryList<MDStepperIcon>;
+    /** Emits when a view transition animation has completed. */
+    readonly animationDone: EventEmitter<void>;
+    footer: MDStepFooter;
+    /** Horizontal label position (end/bottom when orientation is horizontal). */
+    labelPosition: 'bottom' | 'end';
+    /** Step header position (top/bottom). */
+    headerPosition: 'top' | 'bottom';
+    /** Map of step state → custom icon template overrides. */
+    _iconOverrides: Record<string, TemplateRef<StepperIconContext>>;
+    /** Duration for transitions (e.g. "500ms" | "0ms"). */
+    get animationDuration(): string;
+    set animationDuration(value: string);
+    private _animationDuration;
+    /** SSR guard (avoid DOM APIs when not in browser). */
+    protected _isServer: boolean;
+    private _sharedResizeObserver;
+    constructor();
+    /**
+     * After content init:
+     * - Collect custom icon templates.
+     * - React to step list changes to recalc state.
+     * - Toggle animating flag on selected index changes and prepare CSS listeners.
+     */
+    ngAfterContentInit(): void;
+    ngAfterViewChecked(): void;
+    private _stopScrolling;
+    private _eventCleanups;
+    private _selectedIndexChanged;
+    private _stepLabelCount;
+    private changeDetectorRef;
+    private _platform;
+    disablePagination: boolean;
+    get selectedIndex(): number;
+    set selectedIndex(v: number);
+    _stepHeaderElRef: ElementRef<HTMLElement>;
+    _stepListContainer: ElementRef<HTMLElement>;
+    _stepList: ElementRef<HTMLElement>;
+    _stepListInner: ElementRef<HTMLElement>;
+    _nextPaginator: ElementRef<HTMLElement>;
+    _previousPaginator: ElementRef<HTMLElement>;
+    private _scrollDistanceChanged;
+    private _scrollDistance;
+    _showPaginationControls: boolean;
+    _disableScrollAfter: boolean;
+    _disableScrollBefore: boolean;
+    get scrollDistance(): number;
+    set scrollDistance(value: number);
+    _handlePaginatorClick(direction: ScrollDirection$1): void;
+    _handlePaginatorPress(direction: ScrollDirection$1, mouseEvent?: MouseEvent): void;
+    _scrollHeader(direction: ScrollDirection$1): {
+        maxScrollDistance: number;
+        distance: number;
+    };
+    _stopInterval(): void;
+    _scrollToLabel(labelIndex: number): void;
+    private _itemsResized;
+    private _scrollTo;
+    _checkScrollingControls(): void;
+    _getMaxScrollDistance(): number;
+    _updateTabScrollPosition(): void;
+    updatePagination(): void;
+    _checkPaginationEnabled(): void;
+    /**
+     * After view init:
+     * - Emit initial animationDone once containers are rendered.
+     * - Recompute alignment/layout on container list changes.
+     */
+    ngAfterViewInit(): void;
+    /** Tear down transition listener on destroy. */
+    ngOnDestroy(): void;
+    /** Resolve the effective animation duration string applied to CSS. */
+    _getAnimationDuration(): string;
+    /**
+     * Global transitionend handler:
+     * - Detects the active animated container based on orientation and CSS properties.
+     * - Calls _onAnimationDone when the relevant transition completes.
+     */
+    private _handleTransitionend;
+    /** Clear the animating flag and emit animationDone to consumers. */
+    private _onAnimationDone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDStepper, "md-stepper, md-vertical-stepper, md-horizontal-stepper, [mdStepper]", ["mdStepper", "mdVerticalStepper", "mdHorizontalStepper"], { "labelPosition": { "alias": "labelPosition"; "required": false; }; "headerPosition": { "alias": "headerPosition"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "disablePagination": { "alias": "disablePagination"; "required": false; }; }, { "animationDone": "animationDone"; }, ["footer", "_steps", "_icons"], ["*"], true, never>;
+}
+
+/**
+ * Button directive that advances the stepper to the next step.
+ *
+ * Usage:
+ *   <button mdStepperNext>Next</button>
+ *
+ * Extends CDK's CdkStepperNext; this wrapper only provides
+ * a semantic selector and host classes/attrs for styling.
+ */
+declare class MDStepperNext extends CdkStepperNext {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepperNext, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDStepperNext, "button[mdStepperNext]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Button directive that moves the stepper to the previous step.
+ *
+ * Usage:
+ *   <button mdStepperPrevious>Back</button>
+ *
+ * Extends CDK's CdkStepperPrevious; this wrapper only provides
+ * a semantic selector and host classes/attrs for styling.
+ */
+declare class MDStepperPrevious extends CdkStepperPrevious {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepperPrevious, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDStepperPrevious, "button[mdStepperPrevious]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MDStepExecutorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDStepExecutorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDStepExecutorModule, never, [typeof i2.CommonModule, typeof i3.PortalModule, typeof i3$1.CdkStepperModule, typeof MDStep, typeof MDStepLabel, typeof MDStepper, typeof MDStepperNext, typeof MDStepperPrevious, typeof MDStepHeader, typeof MDStepperIcon, typeof MDStepContent, typeof MDStepFooter], [typeof i2.CommonModule, typeof MDStep, typeof MDStepLabel, typeof MDStepper, typeof MDStepperNext, typeof MDStepperPrevious, typeof MDStepHeader, typeof MDStepperIcon, typeof MDStepContent, typeof MDStepFooter]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDStepExecutorModule>;
+}
+
+declare class MDOptionGroup {
+    /** Visible group header shown above the contained options. */
+    label: string;
+    /**
+     * Disables the entire group (non-interactive/inert rendering).
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * Unique id used to associate the rendered label with the grouped options for a11y.
+     * Useful as `aria-labelledby` target on the options container.
+     */
+    _labelId: string;
+    /**
+     * Internal flag for templates to make the group non-interactive without altering ARIA.
+     * Can be toggled by the parent template if additional gating is needed.
+     * @internal
+     */
+    _inert: boolean;
+    /**
+     * Optional reference to the parent select; useful for contextual checks in the template.
+     * Kept for side-effects/context only; not required for basic grouping behavior.
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDOptionGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDOptionGroup, "md-option-group", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*", "md-option, ng-container"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Event payload emitted when an option's selection state changes.
+ *
+ * @template T Model value type.
+ */
+declare class MDOptionSelectionChange<T = any> {
+    source: MDOption<T>;
+    isUserInput: boolean;
+    constructor(source: MDOption<T>, isUserInput?: boolean);
+}
+declare class MDOption<T = any> {
+    /** Host element reference for focus & DOM access. */
+    private _element;
+    /** Change detector for OnPush-friendly manual marks. */
+    _changeDetectorRef: ChangeDetectorRef;
+    /** Optional parent select to derive `multiple` and for coordination. */
+    private _parent;
+    /** Optional parent group to inherit disabled state. */
+    group: MDOptionGroup | null;
+    /** Internal selection state. */
+    private _selected;
+    /** Internal active (highlighted) state used by typeahead/keyboard nav. */
+    private _active;
+    /** Model value associated with this option. */
+    value: T;
+    /** Unique id for the option (used by host/id bindings). */
+    id: string;
+    /**
+     * Disabled state: `true` if the group is disabled OR the individual disabled signal is `true`.
+     * Group-level disabled takes precedence and is observed reactively.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Internal reactive flag for individual disabled state. */
+    private _disabled;
+    /** Whether the parent select is in multi-selection mode. */
+    get multiple(): boolean | null;
+    /** Public read-only selection flag. */
+    get selected(): boolean;
+    /** Emits whenever selection state changes (user or programmatic). */
+    readonly onSelectionChange: EventEmitter<MDOptionSelectionChange<T>>;
+    /**
+     * Reference to the visible text node inside option.
+     * Used to compute {@link viewValue} / {@link getLabel}.
+     */
+    _text: ElementRef<HTMLElement> | undefined;
+    /** Stream used by parent components to observe state changes. */
+    readonly _stateChanges: Subject<void>;
+    constructor();
+    /** Whether this option is currently "active" (keyboard highlight). */
+    get active(): boolean;
+    /**
+     * Select this option programmatically.
+     * @param emitEvent When `true` (default), emits {@link onSelectionChange}.
+     */
+    select(emitEvent?: boolean): void;
+    /**
+     * Handle keyboard selection: `ENTER`/`SPACE` toggles selection
+     * when no modifier keys are pressed.
+     */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Toggle/select via click or keyboard; respects disabled and multiple modes.
+     * Marks for check and emits user-input-flavored selection event.
+     */
+    _selectViaInteraction(): void;
+    /**
+     * Deselect this option programmatically.
+     * @param emitEvent When `true` (default), emits {@link onSelectionChange}.
+     */
+    deselect(emitEvent?: boolean): void;
+    /**
+     * Move focus to this option's host element.
+     * @param _origin Optional {@link FocusOrigin} (not used by default).
+     * @param options Standard {@link FocusOptions}.
+     */
+    focus(_origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Visible string representation of the option (trimmed text content). */
+    get viewValue(): string;
+    /** Alias for {@link viewValue}; kept for API parity with other option components. */
+    getLabel(): string;
+    /** Apply "active" visual styles (used by parent for keyboard navigation). */
+    setActiveStyles(): void;
+    /** Remove "active" visual styles. */
+    setInactiveStyles(): void;
+    /** Return the underlying host `HTMLElement`. */
+    _getHostElement(): HTMLElement;
+    /**
+     * Emit selection change payload; optionally mark as user-driven.
+     * @param isUserInput Whether the change originated from user interaction.
+     */
+    private _emitSelectionChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDOption<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDOption<any>, "md-option", never, { "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["icon", "*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+/**
+ * Count how many group labels appear before a given option index.
+ * Useful for computing aria-posinset / active-descendant offsets when groups are present.
+ *
+ * @param optionIndex Index of the target option among all rendered options.
+ * @param options     `QueryList` of all `MDOption` items (in render order).
+ * @param optionGroups `QueryList` of `MDOptionGroup` (in render order).
+ * @returns Number of group headers preceding the option.
+ */
+declare function _countGroupLabelsBeforeOption(optionIndex: number, options: QueryList<MDOption>, optionGroups: QueryList<MDOptionGroup>): number;
+/**
+ * Compute the `scrollTop` needed to bring an option fully into view inside a panel.
+ *
+ * @param optionOffset          Distance (px) from top of panel to the top of the option.
+ * @param optionHeight          Height of the option (px).
+ * @param currentScrollPosition Current `scrollTop` of the panel.
+ * @param panelHeight           Visible height of the panel (px).
+ * @returns Desired `scrollTop` to ensure full visibility (or current if already visible).
+ */
+declare function _getOptionScrollPosition(optionOffset: number, optionHeight: number, currentScrollPosition: number, panelHeight: number): number;
+
+/** Event payload emitted when the select's value changes. */
+declare class SelectChange<T = any> {
+    source: MDSelect;
+    value: T;
+    constructor(source: MDSelect, value: T);
+}
+/** Token for projecting a custom trigger template (optional). */
+declare const MD_SELECT_TRIGGER: InjectionToken<MDSelectTrigger>;
+declare class MDSelect implements OnInit, OnChanges, OnDestroy, ControlValueAccessor {
+    /** Viewport ruler for resize/orientation tracking to recompute overlay width. */
+    protected _viewportRuler: ViewportRuler;
+    /** Change detector for OnPush; used throughout for manual marks. */
+    protected _changeDetectorRef: ChangeDetectorRef;
+    /** Host element reference. */
+    readonly _elementRef: ElementRef<HTMLElement>;
+    /** CDK Overlay service. */
+    readonly _overlay: Overlay;
+    /** RTL/LTR direction (optional). */
+    private _dir;
+    /** Emits once content is fully initialized. */
+    private _initialized;
+    /** Control accessor hookup (if used inside forms). */
+    ngControl: NgControl;
+    /** Id generator for trigger/value elements. */
+    private _idGenerator;
+    /** Cleanup fn for overlay detach (animation end / fallback). */
+    private _cleanupDetach;
+    /** Renderer for low-level DOM ops. */
+    private _renderer;
+    /** CSS class(es) applied to the overlay panel container. */
+    panelClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    /** Disabled state for the whole control. */
+    disabled: boolean;
+    /** Multiple selection toggle. */
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    private _multiple;
+    /** Current model value (single or array for multiple). */
+    get value(): any;
+    set value(newValue: any);
+    private _value;
+    /** Host tabindex (applies when not disabled). */
+    tabIndex: number;
+    /**
+     * Required flag; auto-derives from `Validators.required` on the bound control
+     * if not provided explicitly.
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    /** Custom comparator for complex option values. */
+    get compareWith(): (o1: any, o2: any) => boolean;
+    set compareWith(fn: (o1: any, o2: any) => boolean);
+    private _compareWith;
+    /** Placeholder/label when nothing is selected. */
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    /** Allow selecting null/undefined values in single mode. */
+    canSelectNullableOptions: boolean;
+    /** Optional custom sorting for selected values (multiple mode). */
+    sortComparator: (a: MDOption, b: MDOption, options: MDOption[]) => number;
+    /** Emits raw value whenever internal value changes. */
+    readonly valueChange: EventEmitter<any>;
+    /** Emits {@link SelectChange} with source/value when selection changes. */
+    readonly selectionChange: EventEmitter<SelectChange<any>>;
+    /** Emits `true/false` when panel opens/closes. */
+    readonly openedChange: EventEmitter<boolean>;
+    /** Convenience stream: fires once on open. */
+    readonly _openedStream: Observable<void>;
+    /** Convenience stream: fires once on close. */
+    readonly _closedStream: Observable<void>;
+    /** Trigger element ref (default trigger template). */
+    trigger: ElementRef;
+    /** Panel container ref. */
+    panel: ElementRef;
+    /** Overlay directive for positioning/attach/detach. */
+    protected _overlayDir: CdkConnectedOverlay;
+    /** Optional projected custom trigger via injection token. */
+    customTrigger: MDSelectTrigger;
+    /** Descendant options in the content. */
+    options: QueryList<MDOption>;
+    /** Descendant option groups in the content. */
+    optionGroups: QueryList<MDOptionGroup>;
+    /** Preferred connected positions for overlay. */
+    _positions: ConnectedPosition[];
+    /** True when host is focused or panel is open. */
+    get focused(): boolean;
+    private _focused;
+    /** Emits when any input that affects layout/state changes. */
+    readonly stateChanges: Subject<void>;
+    /** Destroy notifier for subscriptions. */
+    protected readonly _destroy: Subject<void>;
+    /** Panel visibility flag. */
+    private _panelOpen;
+    /** Computed overlay width (synced on viewport size changes). */
+    _overlayWidth: string | number;
+    /** Scroll strategy for overlay panel. */
+    _scrollStrategy: ScrollStrategy;
+    /** Selected options model. */
+    _selectionModel: SelectionModel<any>;
+    /** ControlValueAccessor change fn. */
+    _onChange: (value: any) => void;
+    /** ControlValueAccessor touched fn. */
+    _onTouched: () => void;
+    /** Keyboard manager for activeDescendant/roving focus/typeahead. */
+    _keyManager: ActiveDescendantKeyManager<MDOption>;
+    /** Stream of child option selection events, lazily wired. */
+    readonly optionSelectionChanges: Observable<MDOptionSelectionChange>;
+    /** Id for the trigger value region (for aria). */
+    _valueId: string;
+    /** True when no selection is present. */
+    get empty(): boolean;
+    constructor();
+    /** Lifecycle: react to `@Input` changes (reserved for future use). */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** After content init: wire key manager, selection model synchronization. */
+    ngAfterContentInit(): void;
+    /** Initialize selection model and subscribe to viewport changes. */
+    ngOnInit(): void;
+    /** Cleanup listeners/subscriptions. */
+    ngOnDestroy(): void;
+    /** Public: whether the panel is currently open. */
+    get panelOpen(): boolean;
+    /** Public: current selection (single `MDOption` or array for multiple). */
+    get selected(): MDOption | MDOption[];
+    /** Human-readable value for the trigger display. */
+    get triggerValue(): string;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => {}): void;
+    /** Guard: can we open now (not disabled, have options, overlay ready)? */
+    protected _canOpen(): boolean;
+    /** Open the panel and prepare keyboard/scroll state. */
+    open(): void;
+    /** Pick initial active item on open (first enabled or selected). */
+    private _highlightCorrectOption;
+    /** After attach: ensure active option is scrolled into view. */
+    private _positioningSettled;
+    /** Close panel, restore orientation, mark touched, and emit. */
+    close(): void;
+    /** Play exit animation (if available), then detach overlay. */
+    private _exitAndDetach;
+    /** Detach overlay and request change detection. */
+    private _detachOverlay;
+    /** RTL helper. */
+    _isRtl(): boolean;
+    _handleKeydown(event: KeyboardEvent): void;
+    /** When closed: open with Enter/Space; navigate single selection. */
+    private _handleClosedKeydown;
+    /** When open: navigate/select, Ctrl+A (multiple), Alt+Arrow closes. */
+    private _handleOpenKeydown;
+    /** For overlay container keydown (ESC closes). */
+    protected _handleOverlayKeydown(event: KeyboardEvent): void;
+    /** Assign value and synchronize selection from external model. */
+    private _assignValue;
+    /** Compute overlay width from host bounding box. */
+    private _getOverlayWidth;
+    /** Update selection based on a (possibly array) value. */
+    private _setSelectionByValue;
+    /** Find option that matches value (using compareWith) and select it. */
+    private _selectOptionByValue;
+    /** Move focus to host (useful after closing). */
+    focus(options?: FocusOptions): void;
+    /** Default container click behavior: focus + open. */
+    onContainerClick(): void;
+    /** Initialize selection from bound form control or internal value. */
+    private _initializeSelection;
+    /** Skip disabled options while panel is closed (for key manager). */
+    private _skipPredicate;
+    /** Ensure a given option index is fully visible inside the panel. */
+    _scrollOptionIntoView(index: number): void;
+    /** Wire option streams and handle user-driven selection/changes. */
+    private _resetOptions;
+    /** Handle a single option's (de)selection and propagate changes. */
+    private _onSelect;
+    /** Sort selected values using custom comparator or DOM order. */
+    private _sortValues;
+    /** Build `SelectChange` payload. */
+    private _getChangeEvent;
+    /** Emit valueChange, call CVA onChange, emit selectionChange, mark for check. */
+    private _propagateChanges;
+    /** Initialize keyboard manager for navigation, typeahead, and tabOut. */
+    private _initKeyManager;
+    /** `aria-activedescendant` points to the active option when panel is open. */
+    _getAriaActiveDescendant(): string | null;
+    /** Focus-in handler: set focused state (unless disabled). */
+    _onFocus(): void;
+    /** Focus-out handler: mark touched when closed; cancel typeahead. */
+    _onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDSelect, "md-select", never, { "panelClass": { "alias": "panelClass"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "required": { "alias": "required"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "canSelectNullableOptions": { "alias": "canSelectNullableOptions"; "required": false; }; "sortComparator": { "alias": "sortComparator"; "required": false; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; "openedChange": "openedChange"; "_openedStream": "opened"; "_closedStream": "closed"; }, ["customTrigger", "options", "optionGroups"], ["select-trigger", "*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_canSelectNullableOptions: unknown;
+}
+/** Optional directive to project a custom trigger area for the select. */
+declare class MDSelectTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDSelectTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDSelectTrigger, "select-trigger", never, {}, {}, never, never, false, never>;
+}
+
+/** Visual states for the pseudo checkbox glyph. */
+type PseudoCheckboxState = 'unchecked' | 'checked' | 'indeterminate';
+declare class PseudoCheckbox {
+    /**
+     * Visual state of the glyph.
+     * Affects host classes only; no behavior is implied.
+     * @default 'checked'
+     */
+    state: PseudoCheckboxState;
+    /**
+     * Applies a disabled look.
+     * Parent/consumer is responsible for actual interactivity.
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * Size/style variant of the glyph.
+     * - `'minimal'` — compact indicator
+     * - `'full'`    — standard checkbox visuals
+     * @default 'full'
+     */
+    appearance: 'minimal' | 'full';
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<PseudoCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PseudoCheckbox, "pseudo-checkbox", never, { "state": { "alias": "state"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MDSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDSelectModule, never, [typeof i2.CommonModule, typeof i5.FormsModule, typeof i6.OverlayModule, typeof MDOption, typeof MDOptionGroup, typeof MDSelect, typeof PseudoCheckbox], [typeof MDOption, typeof MDOptionGroup, typeof MDSelect]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDSelectModule>;
+}
+
+declare class BaseEditableHolder implements ControlValueAccessor {
+    /** Change detector used by children to mark for check after updates. */
+    cd: ChangeDetectorRef;
+    /**
+     * Reactive internal value for the control (Signal).
+     * @default undefined
+     */
+    modelValue: i0.WritableSignal<any>;
+    /**
+     * Optional "required" flag as a signalized input.
+     * @remarks Value is transformed via `booleanAttribute`.
+     */
+    required: i0.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * Optional "invalid" flag as a signalized input (used for UI state).
+     * @remarks Value is transformed via `booleanAttribute`.
+     */
+    invalid: i0.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * Disabled input as a signal (explicit/external).
+     * @remarks Value is transformed via `booleanAttribute`.
+     */
+    disabled: i0.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Optional control name (useful for forms & a11y attributes). */
+    name: i0.InputSignal<string | undefined>;
+    /**
+     * Internal disabled state set via CVA's `setDisabledState`.
+     * @default false
+     * @internal
+     */
+    _disabled: i0.WritableSignal<boolean>;
+    /**
+     * Effective disabled state:
+     * `true` if either the input `disabled()` is truthy OR `setDisabledState(true)` was called.
+     */
+    $disabled: i0.Signal<boolean>;
+    /** CVA onChange callback (assigned by Angular Forms). */
+    onModelChange: Function;
+    /** CVA onTouched callback (assigned by Angular Forms). */
+    onModelTouched: Function;
+    /**
+     * Programmatically set the internal disabled state (used by `setDisabledState`).
+     * @param value New disabled state.
+     */
+    writeDisabledState(value: boolean): void;
+    /**
+     * Overridable hook invoked by `writeValue`.
+     * Child components can coerce or transform incoming values here.
+     * Call `setModelValue(value)` to persist.
+     *
+     * @param value Incoming value from the external model.
+     * @param setModelValue Callback to update the internal `modelValue`.
+     * @protected
+     */
+    protected writeControlValue(value: any, setModelValue?: (value: any) => void): void;
+    /**
+     * CVA: writes an external value into the control.
+     * Delegates to {@link writeControlValue} so children can customize behavior.
+     *
+     * @param value Value coming from the Angular Forms model.
+     */
+    writeValue(value: any): void;
+    /**
+     * Updates the internal value signal (`modelValue`) from the component itself
+     * (e.g., on user input). This does **not** notify the Forms API by itself.
+     * Invoke {@link onModelChange} after this to propagate when appropriate.
+     *
+     * @param value New internal value to set.
+     */
+    writeModelValue(value: any): void;
+    /**
+     * CVA: registers the callback to propagate value changes to Angular Forms.
+     * @param fn Callback invoked when the control's value changes.
+     */
+    registerOnChange(fn: Function): void;
+    /**
+     * CVA: registers the callback to mark the control as touched.
+     * @param fn Callback invoked when the control is touched.
+     */
+    registerOnTouched(fn: Function): void;
+    /**
+     * CVA: enables/disables the control from the Forms API.
+     * @param val `true` to disable, `false` to enable.
+     */
+    setDisabledState(val: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseEditableHolder, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseEditableHolder, never, never, { "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MDSwitch extends BaseEditableHolder implements OnInit, OnDestroy, ControlValueAccessor {
+    /**
+     * Backing unique id used as a default for {@link id}.
+     * @internal
+     */
+    private _uniqueId;
+    /**
+     * Host element id. Can be overridden by the consumer.
+     * @default auto-generated value like `"slide-toggle-..."`
+     */
+    id: string;
+    /**
+     * Keyboard tab order for the internal input.
+     * @remarks Value is transformed via `numberAttribute`.
+     */
+    tabindex: number | undefined;
+    /**
+     * Read-only mode: prevents user interaction while still allowing focus.
+     * @remarks Value is transformed via `booleanAttribute`.
+     */
+    readonly: boolean | undefined;
+    /**
+     * Host click handler.
+     *
+     * @param event Browser `MouseEvent`.
+     * @remarks Delegates to {@link _handleClick}.
+     * @internal
+     */
+    onHostClick(event: MouseEvent): void;
+    /**
+     * Emits when the user toggles the switch via UI interaction.
+     *
+     * @example
+     * ```html
+     * <md-switch (onChange)="handleChange($event)"></md-switch>
+     * ```
+     */
+    onChange: EventEmitter<ToggleSwitchChangeEvent>;
+    /**
+     * Template reference to the internal input element (for focus management).
+     * @internal
+     */
+    input: ElementRef;
+    /**
+     * Focus ring helper for template/styles.
+     * @internal
+     */
+    focused: boolean;
+    constructor();
+    /** Lifecycle: initialization (reserved for future use). */
+    ngOnInit(): void;
+    /**
+     * Synchronous validator hook (provided via `NG_VALIDATORS`).
+     * @remarks Currently a stub.
+     */
+    validate(): void;
+    /** Lifecycle: teardown (reserved for future use). */
+    ngOnDestroy(): void;
+    /**
+     * ControlValueAccessor: write an external value into the component.
+     *
+     * @param value Value coming from the form model.
+     * @param setModelValue Callback to update the base class model value.
+     * @remarks Calls `markForCheck` to ensure change detection runs.
+     */
+    writeControlValue(value: any, setModelValue: (value: any) => void): void;
+    /** Focus-in handler (called from the template). */
+    onFocus(): void;
+    /**
+     * Focus-out handler (called from the template).
+     * @remarks Triggers `onModelTouched()` for forms.
+     */
+    onBlur(): void;
+    /**
+     * Centralized click logic:
+     * - toggles the model via `BaseEditableHolder`;
+     * - calls `onModelChange()` for the form;
+     * - emits {@link onChange} with details;
+     * - returns focus to the input for accessible keyboard flow.
+     *
+     * @param event Original browser `Event`.
+     * @internal
+     */
+    _handleClick(event: Event): void;
+    /**
+     * Convenience getter for host class binding.
+     * @returns Current checked state.
+     */
+    checked(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDSwitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDSwitch, "md-switch", never, { "id": { "alias": "id"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "onChange": "onChange"; }, never, never, false, never>;
+    static ngAcceptInputType_tabindex: unknown;
+    static ngAcceptInputType_readonly: unknown;
+}
+/**
+ * Event emitted by {@link MDSwitch} on user-initiated change.
+ */
+interface ToggleSwitchChangeEvent {
+    /** Original browser event. */
+    originalEvent: Event;
+    /** New checked state. */
+    checked: boolean;
+}
+
+declare class MDSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDSwitchModule, [typeof MDSwitch], [typeof i2.CommonModule], [typeof MDSwitch]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDSwitchModule>;
+}
+
+/** Direction to scroll the header when paginating. */
+type ScrollDirection = 'after' | 'before';
+/**
+ * Contract for focusable tab header items used by the header.
+ * Must expose an `elementRef` for measurement/positioning.
+ */
+type PaginatedTabHeaderItem = FocusableOption & {
+    elementRef: ElementRef;
+};
+declare abstract class PaginatedTabHeader implements AfterContentChecked, AfterContentInit, AfterViewInit, OnDestroy {
+    /** Root host element (the header wrapper). */
+    protected _elementRef: ElementRef<HTMLElement>;
+    /** For OnPush marking when values change. */
+    protected _changeDetectorRef: ChangeDetectorRef;
+    /** Viewport ruler for resize/scrollbar metrics. */
+    private _viewportRuler;
+    /** Optional RTL service to flip layout. */
+    private _dir;
+    /** For running timers/listeners outside Angular. */
+    private _ngZone;
+    /** Platform detection (legacy engines). */
+    private _platform;
+    /** Efficient ResizeObserver sharing. */
+    private _sharedResizeObserver;
+    /** Injector for `afterNextRender` scheduling. */
+    private _injector;
+    /** Renderer for native event listeners & styles. */
+    private _renderer;
+    /** Cleanup callbacks for host-level listeners. */
+    private _eventCleanups;
+    /** List of focusable items (tab labels). */
+    abstract _items: QueryList<PaginatedTabHeaderItem>;
+    /** Ink bar API for alignment/hide. */
+    abstract _inkBar: {
+        hide: () => void;
+        alignToElement: (element: HTMLElement) => void;
+    };
+    /** Container that clips the scrollable tab list. */
+    abstract _tabListContainer: ElementRef<HTMLElement>;
+    /** The horizontally translated list element. */
+    abstract _tabList: ElementRef<HTMLElement>;
+    /** Inner list wrapper used for measurements. */
+    abstract _tabListInner: ElementRef<HTMLElement>;
+    /** Next paginator button element. */
+    abstract _nextPaginator: ElementRef<HTMLElement>;
+    /** Previous paginator button element. */
+    abstract _previousPaginator: ElementRef<HTMLElement>;
+    /** Current horizontal scroll translation in px (LTR positive moves content left). */
+    private _scrollDistance;
+    /** Flag to know when selectedIndex changed between content checks. */
+    private _selectedIndexChanged;
+    /** Teardown notifier for streams. */
+    protected readonly _destroyed: Subject<void>;
+    /** Whether to render/show pagination controls. */
+    _showPaginationControls: boolean;
+    /** Disable "scroll after" paginator. */
+    _disableScrollAfter: boolean;
+    /** Disable "scroll before" paginator. */
+    _disableScrollBefore: boolean;
+    /** Cached count of tab labels to detect additions/removals. */
+    private _tabLabelCount;
+    /** Marker to apply pending scroll distance change to DOM. */
+    private _scrollDistanceChanged;
+    /** Keyboard manager for roving focus. */
+    protected _keyManager: FocusKeyManager<PaginatedTabHeaderItem> | undefined;
+    /** Used to detect text-content changes affecting layout. */
+    private _currentTextContent;
+    /** Emits when auto-scrolling should stop (mouseleave or end). */
+    private _stopScrolling;
+    hideInkBar: boolean;
+    /**
+     * Disable pagination and force-fit all tabs (no scroll).
+     * @default false
+     */
+    disablePagination: boolean;
+    /**
+     * Currently selected tab index (drives ink bar & scroll-to-visible).
+     */
+    get selectedIndex(): number;
+    set selectedIndex(v: number);
+    private _selectedIndex;
+    /**
+     * Emits requested selection when user presses Enter/Space on a focused tab.
+     * Consumers typically update `selectedIndex` in response.
+     */
+    readonly selectFocusedIndex: EventEmitter<number>;
+    /** Emits when focus moves to a different tab header item. */
+    readonly indexFocused: EventEmitter<number>;
+    constructor();
+    /**
+     * Subclass must implement: what happens when user "selects"
+     * the focused item via keyboard (Enter/Space).
+     */
+    protected abstract _itemSelected(event: KeyboardEvent): void;
+    /** Lifecycle: attach touch handlers for press-and-hold scrolling. */
+    ngAfterViewInit(): void;
+    /** Lifecycle: set up keyboard manager, observers and initial alignment. */
+    ngAfterContentInit(): void;
+    /**
+     * Observe when any header item has (re)measured to a non-zero size.
+     * Helps re-evaluate pagination after lazy content/label changes.
+     */
+    private _itemsResized;
+    /** Lifecycle: react to item count/selection/scroll changes and flush DOM updates. */
+    ngAfterContentChecked(): void;
+    /** Lifecycle: teardown listeners/streams. */
+    ngOnDestroy(): void;
+    /**
+     * Handle keydown on the header container.
+     * Space/Enter select the focused tab; arrows/home/end are delegated to the key manager.
+     */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Called when projected content text changes may affect layout/widths. */
+    _onContentChanges(): void;
+    /** Recompute pagination state and apply current scroll position. */
+    updatePagination(): void;
+    /** Index of the currently focused item in the key manager. */
+    get focusIndex(): number;
+    set focusIndex(value: number);
+    /** Returns whether the given index is valid for the items list. */
+    _isValidIndex(index: number): boolean;
+    /**
+     * Moves focus to a given tab and ensures it is visible within the scroll container.
+     * Also snaps container scroll to an edge (LTR/RTL) to avoid native scroll drift.
+     */
+    _setTabFocus(tabIndex: number): void;
+    /** Current layout direction derived from `Directionality`. */
+    _getLayoutDirection(): Direction;
+    /** Applies the current scroll transform to the tab list element. */
+    _updateTabScrollPosition(): void;
+    /** Current scroll distance (px). Setting it clamps to valid range and flags for DOM update. */
+    get scrollDistance(): number;
+    set scrollDistance(value: number);
+    /** Scrolls the header by one third of the visible width in the given direction. */
+    _scrollHeader(direction: ScrollDirection): {
+        maxScrollDistance: number;
+        distance: number;
+    };
+    /** Single-click paginator handler. */
+    _handlePaginatorClick(direction: ScrollDirection): void;
+    /**
+     * Ensures the tab at `labelIndex` is fully visible within the scroll range.
+     * Adjusts `scrollDistance` as needed based on LTR/RTL calculations.
+     */
+    _scrollToLabel(labelIndex: number): void;
+    /** Evaluates whether pagination controls should be shown based on content width. */
+    _checkPaginationEnabled(): void;
+    /** Enables/disables paginator buttons based on current scroll position. */
+    _checkScrollingControls(): void;
+    /** Maximum scrollable distance of the tab list (px). */
+    _getMaxScrollDistance(): number;
+    /** Aligns the ink bar to the selected tab or hides it if no selection. */
+    _alignInkBarToSelectedTab(): void;
+    /** Stops any ongoing auto-scroll interval. */
+    _stopInterval(): void;
+    /**
+     * Handles press-and-hold on a paginator button for continuous scrolling.
+     * Uses a delay before repeating to avoid accidental long-press.
+     */
+    _handlePaginatorPress(direction: ScrollDirection, mouseEvent?: MouseEvent): void;
+    /**
+     * Clamps and applies a new scroll position.
+     * @returns The max scroll distance and the clamped distance for convenience.
+     */
+    private _scrollTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatedTabHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginatedTabHeader, never, never, { "hideInkBar": { "alias": "hideInkBar"; "required": false; }; "disablePagination": { "alias": "disablePagination"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectFocusedIndex": "selectFocusedIndex"; "indexFocused": "indexFocused"; }, never, never, true, never>;
+    static ngAcceptInputType_disablePagination: unknown;
+    static ngAcceptInputType_selectedIndex: unknown;
+}
+
+declare class TabBodyPortal extends CdkPortalOutlet implements OnInit, OnDestroy {
+    /** The owning tab body that drives attach/detach. */
+    private _host;
+    /** Subscription to the "before centering" notifier. */
+    private _centeringSub;
+    /** Subscription to the "after leaving center" notifier. */
+    private _leavingSub;
+    constructor();
+    /** Wires up listeners to mount/unmount the portal at the right lifecycle moments. */
+    ngOnInit(): void;
+    /** Cleans up subscriptions and outlet resources. */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabBodyPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabBodyPortal, "[mdTabBodyHost]", never, {}, {}, never, never, true, never>;
+}
+/** Position of a tab body relative to the active (center) body. */
+type TabBodyPositionState = 'left' | 'center' | 'right';
+/** Direction from which the tab body originated (reserved for animations). */
+type TabBodyOriginState = 'left' | 'right';
+declare class MDTabBody implements OnInit, OnDestroy {
+    /** Host element reference for class toggles and measurement. */
+    private _elementRef;
+    /** Optional bidi service to map positions in RTL. */
+    private _dir;
+    /** For scheduling and transition fallback timers. */
+    private _ngZone;
+    /** Injector used by `afterNextRender` callbacks. */
+    private _injector;
+    /** Renderer for passive DOM event bindings (transition events). */
+    private _renderer;
+    /** Stored cleanup callbacks for event listeners. */
+    private _eventCleanups?;
+    /** Whether OnInit finished; used to guard transition fallbacks. */
+    private _initialized;
+    /** Fallback timer to simulate transitions if needed. */
+    private _fallbackTimer;
+    /** Relative position index provided by parent: -1, 0, +1, ... */
+    private _positionIndex;
+    /** Directionality subscription to recompute when RTL changes. */
+    private _dirChangeSubscription;
+    /** Current position state ('left' | 'center' | 'right'). */
+    _position: TabBodyPositionState;
+    /** Previous position state to know if we're entering/leaving center. */
+    protected _previousPosition: TabBodyPositionState;
+    /**
+     * Emits the tab body's `clientHeight` when starting to center.
+     * Useful for parent to resize the container.
+     */
+    readonly _onCentering: EventEmitter<number>;
+    /** Indicates whether we're about to center (`true`) or not (`false`). */
+    readonly _beforeCentering: EventEmitter<boolean>;
+    /** Fires after we've left the center position. */
+    readonly _afterLeavingCenter: EventEmitter<void>;
+    /** Emits when the body has finished centering transition. */
+    readonly _onCentered: EventEmitter<void>;
+    /** Outlet that actually attaches/detaches the `TemplatePortal`. */
+    _portalHost: TabBodyPortal;
+    /** Reference to the element with the transition (the inner content). */
+    _contentElement: ElementRef<HTMLElement> | undefined;
+    /** The content portal to render for this tab body. */
+    _content: TemplatePortal;
+    /** Duration of CSS transitions (e.g., `"500ms"`, `"0ms"`). */
+    animationDuration: string;
+    /** Whether to leave the content attached when not centered. */
+    preserveContent: boolean;
+    /**
+     * Relative position index set by parent (negative = left, 0 = center, positive = right).
+     * This setter maps index → position state considering layout direction (LTR/RTL).
+     */
+    set position(position: number);
+    constructor();
+    /**
+     * Binds transition listeners and emits initial centering height if already centered.
+     * Lifecycle: `OnInit`.
+     */
+    ngOnInit(): void;
+    /** Removes listeners, timers, and subscriptions. */
+    ngOnDestroy(): void;
+    /**
+     * Attaches listeners for CSS transition lifecycle.
+     * These run outside Angular to avoid change detection storms.
+     */
+    private _bindTransitionEvents;
+    /**
+     * Called when a transition starts; emits sizing and "beforeCentering" status.
+     * Triggers `_onCentering` when entering the center position.
+     */
+    private _transitionStarted;
+    /**
+     * Called when a transition completes; emits `_onCentered` or `_afterLeavingCenter`
+     * depending on the current/previous positions.
+     */
+    private _transitionDone;
+    /**
+     * Toggles the active CSS class for the currently selected tab body.
+     * @param isActive Whether this body is currently active (centered).
+     */
+    _setActiveClass(isActive: boolean): void;
+    /** Resolves current layout direction (LTR/RTL). */
+    _getLayoutDirection(): Direction;
+    /** True when this body is the centered (active) one. */
+    _isCenterPosition(): boolean;
+    /**
+     * Maps the numeric index to a semantic position state and handles fallback simulation
+     * in cases where animations are disabled or the transition might not fire.
+     *
+     * @param dir Optional direction override; defaults to current {@link Directionality}.
+     */
+    private _computePositionAnimationState;
+    /** Fires synthetic transitionstart/transitionend callbacks in sequence. */
+    private _simulateTransitionEvents;
+    /** Whether animations are effectively disabled by config. */
+    private _animationsDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDTabBody, "md-tab-body", never, { "_content": { "alias": "content"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "preserveContent": { "alias": "preserveContent"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "_onCentering": "_onCentering"; "_beforeCentering": "_beforeCentering"; "_onCentered": "_onCentered"; }, never, never, true, never>;
+}
+
+/**
+ * Configuration options for the Tabs module.
+ *
+ * @remarks
+ * Provide this via the {@link TABS_CONFIG} injection token at the app or feature level.
+ * Each field is optional; omit to use component defaults.
+ *
+ * @example Provide defaults app-wide
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     { provide: TABS_CONFIG, useValue: {
+ *         animationDuration: '250ms',
+ *         fitInkBarToContent: true,
+ *         alignTabs: 'center'
+ *     } as TabsConfig }
+ *   ]
+ * });
+ * ```
+ */
+interface TabsConfig {
+    /**
+     * Duration of tab header/ink bar animations.
+     * @example "200ms", "300ms ease-out"
+     */
+    animationDuration?: string;
+    /**
+     * Disables header pagination arrows when there are many tabs.
+     * If `true`, all tabs must fit without scrolling.
+     * @default false
+     */
+    disablePagination?: boolean;
+    /**
+     * If `true`, ink bar width matches the label content rather than the full tab.
+     * @default false
+     */
+    fitInkBarToContent?: boolean;
+    /**
+     * Automatically resizes the tab-body container to match the active tab's height.
+     * @default false
+     */
+    dynamicHeight?: boolean;
+    /**
+     * `tabindex` applied to the tab body content container for accessibility.
+     * @default 0
+     */
+    contentTabIndex?: number;
+    /**
+     * Preserves inactive tab contents in the DOM instead of destroying them.
+     * Useful for keeping component state or form controls alive.
+     * @default false
+     */
+    preserveContent?: boolean;
+    /**
+     * Stretches tabs to evenly fill the header width.
+     * @default false
+     */
+    stretchTabs?: boolean;
+    /**
+     * Horizontal alignment of tab labels in the header.
+     * @default 'start'
+     */
+    alignTabs?: 'start' | 'center' | 'end';
+}
+/**
+ * Injection token for providing {@link TabsConfig} defaults.
+ *
+ * @example Feature-level override
+ * ```ts
+ * @NgModule({
+ *   providers: [{ provide: TABS_CONFIG, useValue: { stretchTabs: true } }]
+ * })
+ * export class TabsFeatureModule {}
+ * ```
+ *
+ * @example Injecting the config
+ * ```ts
+ * @Component({...})
+ * export class TabsHeaderComponent {
+ *   constructor(@Inject(TABS_CONFIG) readonly cfg: TabsConfig) {}
+ * }
+ * ```
+ */
+declare const TABS_CONFIG: InjectionToken<TabsConfig>;
+
+declare const TAB_CONTENT: InjectionToken<MDTabContent>;
+declare class MDTabContent {
+    template: TemplateRef<any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDTabContent, "[mdTabContent]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Injection token bound to the current {@link MDTabLabel} instance.
+ * Useful for querying/injecting the label from descendants.
+ */
+declare const MD_TAB_LABEL: InjectionToken<MDTabLabel>;
+/** Token representing the closest parent Tab instance (provided by the Tab). */
+declare const MD_TAB: InjectionToken<any>;
+declare class MDTabLabel extends CdkPortal {
+    /**
+     * Reference to the nearest parent tab instance if provided via {@link MD_TAB}.
+     * `undefined` when used outside of a tab context.
+     */
+    _closestTab: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDTabLabel, "[md-tab-label], [mdTabLabel]", never, {}, {}, never, never, true, never>;
+}
+
+/** Injection token for the closest parent tab-group (provided by the group). */
+declare const TAB_GROUP: InjectionToken<any>;
+declare class MDTab {
+    /** View container used as the portal outlet context for tab content. */
+    private _viewContainerRef;
+    /** Optional reference to the closest parent tab group (for coordination). */
+    _closestTabGroup: any;
+    /**
+     * Disables this tab.
+     * Header becomes non-interactive and body is not focusable.
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * Explicit tab body provided via `<ng-template md-tab-content>`.
+     * If absent, the component's own template (implicit content) is used.
+     */
+    private _explicitContent;
+    /** Implicit content template captured from the component template. */
+    _implicitContent: TemplateRef<any>;
+    /** Plain text label for the tab header (alternative to template label). */
+    textLabel: string;
+    /** Accessible label for the tab header element. */
+    ariaLabel: string;
+    /** Id of element that labels the tab header (for a11y). */
+    ariaLabelledby: string;
+    /** Additional CSS class(es) applied to the label host. */
+    labelClass: string | string[];
+    /** Additional CSS class(es) applied to the body/content host. */
+    bodyClass: string | string[];
+    /** Optional id for this tab; can be used for linking and testing. */
+    id: string | null;
+    /**
+     * Custom label template projected via `<ng-template md-tab-label>`.
+     * Setter ensures the template belongs to this tab instance.
+     */
+    get templateLabel(): MDTabLabel;
+    set templateLabel(value: MDTabLabel);
+    private _templateLabel;
+    /** Lazily-created portal wrapping either explicit or implicit content. */
+    private _contentPortal;
+    /** Public getter for the content portal (used by parent tab group). */
+    get content(): TemplatePortal | null;
+    /** Notifies parent/consumers that an input affecting rendering has changed. */
+    readonly _stateChanges: Subject<void>;
+    /** Position relative to the active tab (used for ink bar/animations). */
+    position: number | null;
+    /** Index from which this tab originated during a transition. */
+    origin: number | null;
+    /** Whether this tab is currently the active/selected one. */
+    isActive: boolean;
+    constructor();
+    /** Emits `stateChanges` when key inputs mutate. */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Completes internal subject to avoid leaks. */
+    ngOnDestroy(): void;
+    /** Initializes the content portal using explicit or implicit template. */
+    ngOnInit(): void;
+    /** Accepts a label template only if it belongs to this `MDTab` instance. */
+    private _setTemplateLabelInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDTab, "md-tab", never, { "disabled": { "alias": "disabled"; "required": false; }; "textLabel": { "alias": "label"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "labelClass": { "alias": "labelClass"; "required": false; }; "bodyClass": { "alias": "bodyClass"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, ["_explicitContent", "templateLabel"], ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Contract that an item must implement to participate in ink-bar activation.
+ * Typically implemented by tab header items.
+ */
+interface InkBarItemContract extends OnInit, OnDestroy {
+    /** Reference to the host element used for positioning and class toggles. */
+    elementRef: ElementRef<HTMLElement>;
+    /**
+     * Activates the ink bar on this item, optionally animating from the
+     * previous indicator's client rect (for smooth transitions).
+     */
+    activateInkBar(previousIndicatorClientRect?: DOMRect): void;
+    /** Deactivates the ink bar on this item. */
+    deactivateInkBar(): void;
+    /** Whether the ink bar should fit the label content rather than full width. */
+    fitInkBarToContent: boolean;
+}
+/**
+ * Controller for moving the ink bar between a set of items.
+ * Keeps track of the currently active item and coordinates activation/deactivation.
+ */
+declare class InkBar {
+    private _items;
+    private _currentItem;
+    /**
+     * @param _items QueryList of items that can host the ink bar.
+     */
+    constructor(_items: QueryList<InkBarItemContract>);
+    /** Hides the ink bar and clears the current item reference. */
+    hide(): void;
+    /**
+     * Aligns the ink bar to the given element, if there is a corresponding item.
+     * Performs a smooth transition from the previously active item when possible.
+     *
+     * @param element Host element to align the ink bar with.
+     */
+    alignToElement(element: HTMLElement): void;
+}
+/**
+ * Abstract base for an element that can host an ink bar.
+ * Responsible for creating/attaching the indicator DOM and handling transitions.
+ */
+declare abstract class InkBarItem implements OnInit, OnDestroy {
+    /** Host element reference. */
+    private _elementRef;
+    /** Root element of the ink bar indicator. */
+    private _inkBarElement;
+    /** Inner content element of the ink bar (underline). */
+    private _inkBarContentElement;
+    /** Whether the ink bar attaches to content width instead of full host width. */
+    private _fitToContent;
+    /**
+     * When `true`, append the ink bar inside `.mdc-tab__content` to fit label width,
+     * otherwise append directly to the host for full-width underline.
+     */
+    get fitInkBarToContent(): boolean;
+    set fitInkBarToContent(newValue: boolean);
+    /**
+     * Activates the ink bar and, if `previousIndicatorClientRect` is provided,
+     * animates from the previous position/width for a smooth transition.
+     */
+    activateInkBar(previousIndicatorClientRect?: DOMRect): void;
+    /** Deactivates the ink bar from this host item. */
+    deactivateInkBar(): void;
+    /** Lifecycle: create the indicator DOM on init. */
+    ngOnInit(): void;
+    /** Lifecycle: remove indicator DOM on destroy. */
+    ngOnDestroy(): void;
+    /** Creates the ink bar root and content elements and appends them. */
+    private _createInkBarElement;
+    /**
+     * Appends the ink bar into the appropriate container depending on
+     * {@link fitInkBarToContent} value.
+     */
+    private _appendInkBarElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InkBarItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InkBarItem, never, never, { "fitInkBarToContent": { "alias": "fitInkBarToContent"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_fitInkBarToContent: unknown;
+}
+/**
+ * Computes the left/width style values for positioning an ink bar
+ * under the given element.
+ */
+interface _InkBarPositioner {
+    /**
+     * @param element Host element to measure.
+     * @returns CSS `left` and `width` values (in pixels with `px` suffix).
+     */
+    (element: HTMLElement): {
+        left: string;
+        width: string;
+    };
+}
+/**
+ * Factory returning a default ink bar positioner based on `offsetLeft/offsetWidth`.
+ * Useful as the default strategy; can be overridden via DI.
+ */
+declare function INK_BAR_POSITIONER_FACTORY(): _InkBarPositioner;
+/**
+ * Injection token for providing an ink bar positioner function.
+ *
+ * @example Override in a module
+ * ```ts
+ * providers: [
+ *   { provide: INK_BAR_POSITIONER, useFactory: myCustomPositionerFactory }
+ * ]
+ * ```
+ *
+ * @example Inject and use
+ * ```ts
+ * constructor(@Inject(INK_BAR_POSITIONER) private pos: _InkBarPositioner) {}
+ * ```
+ */
+declare const INK_BAR_POSITIONER: InjectionToken<_InkBarPositioner>;
+
+declare class MDTabLabelWrapper extends InkBarItem {
+    /** Native element reference for focus & measurement. */
+    elementRef: ElementRef<any>;
+    /**
+     * Disables the tab label (affects CSS and sets `aria-disabled`).
+     * @default false
+     */
+    disabled: boolean;
+    /** Programmatically moves focus to the label element. */
+    focus(): void;
+    /** Horizontal offset used to position the ink bar. */
+    getOffsetLeft(): number;
+    /** Element width used to size the ink bar. */
+    getOffsetWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabLabelWrapper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MDTabLabelWrapper, "[mdTabLabelWrapper]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class MDTabHeader extends PaginatedTabHeader implements AfterContentChecked, AfterContentInit, AfterViewInit, OnDestroy {
+    /** All direct tab label wrappers (no deep descendants). */
+    _items: QueryList<MDTabLabelWrapper>;
+    /** Container element around the scrolling tab list (used for clipping/scroll). */
+    _tabListContainer: ElementRef;
+    /** The scrollable tab list element. */
+    _tabList: ElementRef;
+    /** Inner wrapper of the tab list (helps with measurements). */
+    _tabListInner: ElementRef;
+    /** Next-page paginator button element (when overflow occurs). */
+    _nextPaginator: ElementRef<HTMLElement>;
+    /** Previous-page paginator button element (when overflow occurs). */
+    _previousPaginator: ElementRef<HTMLElement>;
+    /** Ink bar instance responsible for active-underline positioning. */
+    _inkBar: InkBar;
+    /** Accessible name for the tablist region (if no external labelling). */
+    ariaLabel: string;
+    /** Id of element that labels this tablist for a11y. */
+    ariaLabelledby: string;
+    /**
+     * After content is available, initialize the ink bar with current items
+     * and let the base header wire scrolling/pagination behaviors.
+     */
+    ngAfterContentInit(): void;
+    /**
+     * Keyboard selection handler at the header level.
+     * Prevents default browser behavior; actual selection logic is handled
+     * by the parent container or the base class.
+     */
+    protected _itemSelected(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDTabHeader, "md-tab-header", never, { "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, {}, ["_items"], ["*"], true, never>;
+}
+
+/** Interface exposed by tab header implementations used by the group. */
+interface TabGroupBaseHeader {
+    _alignInkBarToSelectedTab(): void;
+    updatePagination(): void;
+    focusIndex: number;
+}
+/** Where to render the tab header relative to the body. */
+type TabHeaderPosition = 'above' | 'below';
+declare class MDTabGroup implements AfterViewInit, AfterContentInit, AfterContentChecked, OnDestroy {
+    /** Root element ref for size/host-class interactions. */
+    readonly _elementRef: ElementRef<any>;
+    private _changeDetectorRef;
+    private _ngZone;
+    /** Subscriptions to various tab/label/body change streams. */
+    private _tabsSubscription;
+    private _tabLabelSubscription;
+    private _tabBodySubscription;
+    /** All candidate tabs in content (including nested); filtered to own group below. */
+    _allTabs: QueryList<MDTab>;
+    /** Projected tab body components and wrapper/child references. */
+    _tabBodies: QueryList<MDTabBody> | undefined;
+    _tabBodyWrapper: ElementRef;
+    _tabHeader: MDTabHeader;
+    /** Tabs belonging to this group (excludes nested/foreign groups). */
+    _tabs: QueryList<MDTab>;
+    /** Next index requested by inputs/user actions; reconciled each content check. */
+    private _indexToSelect;
+    /** Last header-focused tab index (for roving tabindex). */
+    private _lastFocusedTabIndex;
+    /** Cached wrapper height for dynamicHeight animations. */
+    private _tabBodyWrapperHeight;
+    isLegacyMode: boolean;
+    hideInkBar: boolean;
+    /**
+     * Fit ink bar width to the text content of the label rather than the full tab.
+     * @default false
+     */
+    get fitInkBarToContent(): boolean;
+    set fitInkBarToContent(value: boolean);
+    private _fitInkBarToContent;
+    /**
+     * Stretch tabs across the header row (attribute alias).
+     * @alias stretch-tabs
+     * @default true
+     */
+    stretchTabs: boolean;
+    /**
+     * Alignment of tab headers: `'start' | 'center' | 'end'` (attribute alias).
+     * @alias align-tabs
+     * @default null (use header default)
+     */
+    alignTabs: string | null;
+    /** Animate container height to fit active body. @default false */
+    dynamicHeight: boolean;
+    /**
+     * Two-way bound selected index.
+     * @remarks Setter stores a pending request; actual selection happens during checks.
+     */
+    get selectedIndex(): number | null;
+    set selectedIndex(value: number);
+    private _selectedIndex;
+    /** Header position relative to body. @default 'above' */
+    headerPosition: TabHeaderPosition;
+    /**
+     * Duration applied to transitions; accepts `'500ms'` or number (ms).
+     * Numbers are normalized to `"Xms"`.
+     * @default '500ms' (or DI default)
+     */
+    get animationDuration(): string;
+    set animationDuration(value: string | number);
+    private _animationDuration;
+    /**
+     * `tabindex` for the active tab content container.
+     * @default null (browser default)
+     */
+    get contentTabIndex(): number | null;
+    set contentTabIndex(value: number);
+    private _contentTabIndex;
+    /** Disable header pagination controls and related layout. @default false */
+    disablePagination: boolean;
+    /** Reserved flag for ripple styling/integration. @default false */
+    disableRipple: boolean;
+    /** Keep inactive tab bodies attached in the DOM. @default false */
+    preserveContent: boolean;
+    /** A11y labeling for the tablist region. */
+    ariaLabel: string;
+    ariaLabelledby: string;
+    /** Emits when selected index changes (two-way binding helper). */
+    readonly selectedIndexChange: EventEmitter<number>;
+    /** Emits when header focus changes between tabs (keyboard nav). */
+    readonly focusChange: EventEmitter<MDTabChangeEvent>;
+    /** Emits after content wrapper height animation completes. */
+    readonly animationDone: EventEmitter<void>;
+    /**
+     * Emits when a new tab is selected (async; not emitted on initial render).
+     * @see selectedIndexChange for 2-way binding signal.
+     */
+    readonly selectedTabChange: EventEmitter<MDTabChangeEvent>;
+    /** Group id used for aria-controls/label linking. */
+    private _groupId;
+    /** SSR guard to avoid DOM operations when not in the browser. */
+    protected _isServer: boolean;
+    constructor();
+    /**
+     * Reconcile desired index with available tabs; update selection & positions.
+     * Emits change events and manages wrapper height for smooth transitions.
+     */
+    ngAfterContentChecked(): void;
+    /** Wire up tabs list and labels after initial content projection. */
+    ngAfterContentInit(): void;
+    /** Watch body list to keep active class centered after view init. */
+    ngAfterViewInit(): void;
+    /** Filter nested tabs and keep only those belonging to this group. */
+    private _subscribeToAllTabChanges;
+    /** Cleanup resources. */
+    ngOnDestroy(): void;
+    /** Realign ink bar to the current selected tab. */
+    realignInkBar(): void;
+    /** Recompute pagination (e.g., after resize). */
+    updatePagination(): void;
+    /** Move focus to a specific tab header index. */
+    focusTab(index: number): void;
+    /** Emits `focusChange` when header focus moves. */
+    _focusChanged(index: number): void;
+    /** Creates a reusable change event object for selection/focus updates. */
+    private _createChangeEvent;
+    /** Subscribe to label/template changes to trigger CD when they update. */
+    private _subscribeToTabLabels;
+    /** Ensure the target index is within `[0, tabs.length - 1]`. */
+    private _clampTabIndex;
+    /** Build a unique id for each tab label element (aria-labelledby). */
+    _getTabLabelId(tab: MDTab, index: number): string;
+    /** Build a unique id for each tab content region (aria-controls). */
+    _getTabContentId(index: number): string;
+    /** Manage body wrapper height during `dynamicHeight` animations. */
+    _setTabBodyWrapperHeight(tabHeight: number): void;
+    /** Clear height lock and emit `animationDone` once the cycle completes. */
+    _removeTabBodyWrapperHeight(): void;
+    /** Handle header click: focus header item and (if enabled) select it. */
+    _handleClick(tab: MDTab, tabHeader: TabGroupBaseHeader, index: number): void;
+    /** Roving tabindex: only selected/last-focused tab is tabbable. */
+    _getTabIndex(index: number): number;
+    /** When header item receives non-mouse focus, update `focusIndex`. */
+    _tabFocusChanged(focusOrigin: FocusOrigin, index: number): void;
+    /** Toggle active class on bodies when centering is enabled. */
+    protected _bodyCentered(isCenter: boolean): void;
+    /** Disable animations when duration is explicitly zero. */
+    protected _animationsDisabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MDTabGroup, "md-tab-group", ["mdTabGroup"], { "isLegacyMode": { "alias": "isLegacyMode"; "required": false; }; "hideInkBar": { "alias": "hideInkBar"; "required": false; }; "fitInkBarToContent": { "alias": "fitInkBarToContent"; "required": false; }; "stretchTabs": { "alias": "stretch-tabs"; "required": false; }; "alignTabs": { "alias": "align-tabs"; "required": false; }; "dynamicHeight": { "alias": "dynamicHeight"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "headerPosition": { "alias": "headerPosition"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "contentTabIndex": { "alias": "contentTabIndex"; "required": false; }; "disablePagination": { "alias": "disablePagination"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "preserveContent": { "alias": "preserveContent"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "focusChange": "focusChange"; "animationDone": "animationDone"; "selectedTabChange": "selectedTabChange"; }, ["_allTabs"], ["*"], true, never>;
+    static ngAcceptInputType_fitInkBarToContent: unknown;
+    static ngAcceptInputType_stretchTabs: unknown;
+    static ngAcceptInputType_dynamicHeight: unknown;
+    static ngAcceptInputType_selectedIndex: unknown;
+    static ngAcceptInputType_contentTabIndex: unknown;
+    static ngAcceptInputType_disablePagination: unknown;
+    static ngAcceptInputType_disableRipple: unknown;
+    static ngAcceptInputType_preserveContent: unknown;
+}
+/** Change event emitted by MDTabGroup for selection/focus updates. */
+declare class MDTabChangeEvent {
+    /** Index of the tab that changed. */
+    index: number;
+    /** Reference to the tab instance. */
+    tab: MDTab;
+}
+
+declare class MDTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MDTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MDTabsModule, never, [typeof i2.CommonModule, typeof MDTabContent, typeof MDTabLabel, typeof MDTab, typeof MDTabGroup], [typeof MDTabContent, typeof MDTabLabel, typeof MDTab, typeof MDTabGroup]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MDTabsModule>;
+}
+
+export { ACCORDION, Accordion, CARD_CONFIG, CardSimpleComponent, CentralPageComponent, CentralPageRowComponent, CollapseComponent, CollapseSetComponent, DIALOG_DATA, DIALOG_DEFAULT_OPTIONS, DIALOG_SCROLL_STRATEGY, DialogState, EXPANSION_PANEL_DEFAULT_OPTIONS, ErrorStateMatcher, ExpansionPanelActionRow, ExpansionPanelDescription, ExpansionPanelTitle, FillComponent, FilteredFieldContainerComponent, FilteredFieldItemComponent, FilteredFieldService, FiltredItemModel, INK_BAR_POSITIONER, INK_BAR_POSITIONER_FACTORY, InkBar, MDCard, MDCardActions, MDCardAvatar, MDCardContent, MDCardFooter, MDCardHeader, MDCardImage, MDCardLgImage, MDCardMdImage, MDCardModule, MDCardSmImage, MDCardSubtitle, MDCardTitle, MDCardTitleGroup, MDCardXlImage, MDCollapseModule, MDDialog, MDDialogActions, MDDialogClose, MDDialogContainer, MDDialogContent, MDDialogTitle, MDExpansionPanel, MDExpansionPanelContent, MDExpansionPanelHeader, MDModalModule, MDOption, MDOptionGroup, MDOptionSelectionChange, MDSelect, MDSelectModule, MDSelectTrigger, MDStep, MDStepContent, MDStepExecutorModule, MDStepFooter, MDStepHeader, MDStepLabel, MDStepper, MDStepperIcon, MDStepperNext, MDStepperPrevious, MDSwitch, MDSwitchModule, MDTab, MDTabBody, MDTabChangeEvent, MDTabContent, MDTabGroup, MDTabHeader, MDTabLabel, MDTabLabelWrapper, MDTabsModule, MD_EXPANSION_PANEL, MD_SELECT_TRIGGER, MD_TAB, MD_TAB_LABEL, ManagePageComponent, MefDevCardModule, MefDevCollapseModule, MefDevDialogConfig, MefDevDialogRef, MefDevDropDownMenuModule, MefDevFilteredFieldModule, MefDevModalModule, MefDevOptionComponent, MefDevPageLayoutsModule, MefDevProgressComponent, MefDevProgressModule, MefDevSelectComponent, MefDevSelectModule, MefDevStepExecutorModule, MefDevSwitchComponent, MefDevSwitchModule, MefDevTabBodyComponent, MefDevTabComponent, MefDevTabLabelDirective, MefDevTabSetComponent, MefDevTabsInkBarDirective, MefDevTabsModule, MefDevTabsNavComponent, MefdevDropdownMenuComponent, MefdevExecutorPageComponent, ModalSize, OptionPipe, PaginatedTabHeader, ProgressConfig, PseudoCheckbox, RightFilterComponent, STEPPER_INTL_PROVIDER, STEPPER_INTL_PROVIDER_FACTORY, SelectChange, ShowOnDirtyErrorStateMatcher, SlideRightComponent, SlideUpComponent, StageComponent, StepExecutorComponent, StepperIntl, TABS_CONFIG, TAB_CONTENT, TAB_GROUP, TabBodyPortal, TabChangeEvent, TablePageComponent, _closeDialogVia, _countGroupLabelsBeforeOption, _getOptionScrollPosition, components, mefDevCardComponents, mefDevCollapseModuleComponents };
+export type { AccordionBase, AccordionDisplayMode, AccordionTogglePosition, AnimatedInterface, AutoFocusTarget, CardAppearance, CardConfig, DialogPosition, DialogRole, ExpansionPanelBase, ExpansionPanelDefaultOptions, ExpansionPanelState, MDPaginatedStepHeaderItem, PseudoCheckboxState, ScrollDirection, StepperIconContext, TabBodyOriginState, TabBodyPositionState, TabGroupBaseHeader, TabHeaderPosition, TabPosition, TabPositionMode, TabType, TabsConfig, ToggleSwitchChangeEvent };
+//# sourceMappingURL=index.d.ts.map