@ng-matero/extensions 13.2.1 → 13.3.0

package/popover/popover-trigger.d.ts

@@ -1,94 +1,100 @@
-import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, ViewContainerRef, ChangeDetectorRef } from '@angular/core';
+import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
 import { Direction, Directionality } from '@angular/cdk/bidi';
-import { Overlay } from '@angular/cdk/overlay';
-import { Subject } from 'rxjs';
-import { MtxPopoverPanel, MtxTarget } from './popover-interfaces';
+import { Overlay, ScrollStrategy } from '@angular/cdk/overlay';
+import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, OnDestroy, ViewContainerRef } from '@angular/core';
+import { MtxPopoverPanel } from './popover-interfaces';
+import { MtxPopoverTarget } from './popover-target';
 import { MtxPopoverTriggerEvent } from './popover-types';
 import * as i0 from "@angular/core";
+/** Injection token that determines the scroll handling while the popover is open. */
+export declare const MTX_POPOVER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+export declare function MTX_POPOVER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+export declare const MTX_POPOVER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MTX_POPOVER_SCROLL_STRATEGY_FACTORY;
+};
 /**
- * This directive is intended to be used in conjunction with an mtx-popover tag. It is
+ * This directive is intended to be used in conjunction with an `mtx-popover` tag. It is
  * responsible for toggling the display of the provided popover instance.
  */
-export declare class MtxPopoverTrigger implements AfterViewInit, OnDestroy {
+export declare class MtxPopoverTrigger implements AfterContentInit, OnDestroy {
     private _overlay;
-    _elementRef: ElementRef;
+    private _elementRef;
     private _viewContainerRef;
     private _dir;
     private _changeDetectorRef;
-    ariaHaspopup: boolean;
-    popoverOpened$: Subject<void>;
-    popoverClosed$: Subject<void>;
-    private _portal;
+    private _focusMonitor?;
+    private _portal?;
     private _overlayRef;
     private _popoverOpen;
     private _halt;
-    private _backdropSubscription;
     private _positionSubscription;
-    private _detachmentsSubscription;
+    private _popoverCloseSubscription;
+    private _closingActionsSubscription;
+    private _scrollStrategy;
     private _mouseoverTimer;
-    private _openedByMouse;
-    private _onDestroy;
+    _openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
     /** References the popover instance that the trigger is associated with. */
-    popover: MtxPopoverPanel;
+    get popover(): MtxPopoverPanel;
+    set popover(popover: MtxPopoverPanel);
+    private _popover;
+    /** Data to be passed along to any lazily-rendered content. */
+    popoverData: any;
     /** References the popover target instance that the trigger is associated with. */
-    targetElement: MtxTarget;
+    targetElement?: MtxPopoverTarget;
     /** Popover trigger event */
-    triggerEvent: MtxPopoverTriggerEvent;
+    triggerEvent?: MtxPopoverTriggerEvent;
     /** Event emitted when the associated popover is opened. */
     popoverOpened: EventEmitter<void>;
     /** Event emitted when the associated popover is closed. */
     popoverClosed: EventEmitter<void>;
-    constructor(_overlay: Overlay, _elementRef: ElementRef, _viewContainerRef: ViewContainerRef, _dir: Directionality, _changeDetectorRef: ChangeDetectorRef);
-    ngAfterViewInit(): void;
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, scrollStrategy: any, _dir: Directionality, _changeDetectorRef: ChangeDetectorRef, _focusMonitor?: FocusMonitor | undefined);
+    ngAfterContentInit(): void;
     ngOnDestroy(): void;
     private _setCurrentConfig;
     /** Whether the popover is open. */
     get popoverOpen(): boolean;
-    onClick(event: MouseEvent): void;
-    onMouseEnter(event: MouseEvent): void;
-    onMouseLeave(event: MouseEvent): void;
+    /** The text direction of the containing app. */
+    get dir(): Direction;
+    /** Handles mouse click on the trigger. */
+    _handleClick(event: MouseEvent): void;
+    /** Handles mouse enter on the trigger. */
+    _handleMouseEnter(event: MouseEvent): void;
+    /** Handles mouse leave on the trigger. */
+    _handleMouseLeave(event: MouseEvent): void;
+    /** Handles mouse presses on the trigger. */
+    _handleMousedown(event: MouseEvent): void;
+    /** Handles key presses on the trigger. */
+    _handleKeydown(event: KeyboardEvent): void;
     /** Toggles the popover between the open and closed states. */
     togglePopover(): void;
     /** Opens the popover. */
     openPopover(): void;
     /** Closes the popover. */
     closePopover(): void;
-    /** Removes the popover from the DOM. */
-    destroyPopover(): void;
-    /** Focuses the popover trigger. */
-    focus(): void;
-    /** The text direction of the containing app. */
-    get dir(): Direction;
     /**
-     * This method ensures that the popover closes when the overlay backdrop is clicked.
-     * We do not use first() here because doing so would not catch clicks from within
-     * the popover, and it would fail to unsubscribe properly. Instead, we unsubscribe
-     * explicitly when the popover is closed or destroyed.
+     * Focuses the popover trigger.
+     * @param origin Source of the popover trigger's focus.
      */
-    private _subscribeToBackdrop;
-    private _subscribeToDetachments;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Removes the popover from the DOM. */
+    private _destroyPopover;
     /**
-     * This method sets the popover state to open and focuses the first item if
-     * the popover was opened via the keyboard.
+     * This method sets the popover state to open.
      */
     private _initPopover;
+    private _setIsPopoverOpen;
     /**
-     * This method resets the popover when it's closed, most importantly restoring
-     * focus to the popover trigger if the popover was opened via the keyboard.
-     */
-    private _resetPopover;
-    /** set state rather than toggle to support triggers sharing a popover */
-    private _setPopoverOpened;
-    /** set state rather than toggle to support triggers sharing a popover */
-    private _setPopoverClosed;
-    /**
-     *  This method checks that a valid instance of MdPopover has been passed into
-     *  mdPopoverTriggerFor. If not, an exception is thrown.
+     * This method checks that a valid instance of MdPopover has been passed into
+     * `mtxPopoverTriggerFor`. If not, an exception is thrown.
      */
     private _checkPopover;
     /**
-     *  This method creates the overlay from the provided popover's template and saves its
-     *  OverlayRef so that it can be attached to the DOM when openPopover is called.
+     * This method creates the overlay from the provided popover's template and saves its
+     * OverlayRef so that it can be attached to the DOM when openPopover is called.
      */
     private _createOverlay;
     /**
@@ -96,10 +102,7 @@ export declare class MtxPopoverTrigger implements AfterViewInit, OnDestroy {
      * @returns OverlayConfig
      */
     private _getOverlayConfig;
-    /**
-     * This method returns the scroll strategy used by the cdk/overlay.
-     */
-    private _getOverlayScrollStrategy;
+    private _getTargetElement;
     /**
      * Listens to changes in the position of the overlay and sets the correct classes
      * on the popover based on the new position. This ensures the animation origin is always
@@ -107,13 +110,15 @@ export declare class MtxPopoverTrigger implements AfterViewInit, OnDestroy {
      */
     private _subscribeToPositions;
     /**
-     * This method builds the position strategy for the overlay, so the popover is properly connected
-     * to the trigger.
-     * @returns ConnectedPositionStrategy
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param positionStrategy Strategy whose position to update.
      */
-    private _getPosition;
-    private _cleanUpSubscriptions;
-    _handleMousedown(event: MouseEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxPopoverTrigger, [null, null, null, { optional: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MtxPopoverTrigger, "[mtxPopoverTriggerFor]", ["mtxPopoverTrigger"], { "popover": "mtxPopoverTriggerFor"; "targetElement": "mtxPopoverTargetAt"; "triggerEvent": "mtxPopoverTriggerOn"; }, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never>;
+    private _setPosition;
+    /** Returns a stream that emits whenever an action that should close the popover occurs. */
+    private _popoverClosingActions;
+    /** Gets the portal that should be attached to the overlay. */
+    private _getPortal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxPopoverTrigger, [null, null, null, null, { optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MtxPopoverTrigger, "[mtx-popover-trigger-for], [mtxPopoverTriggerFor]", ["mtxPopoverTrigger"], { "popover": "mtxPopoverTriggerFor"; "popoverData": "mtxPopoverTriggerData"; "targetElement": "mtxPopoverTargetAt"; "triggerEvent": "mtxPopoverTriggerOn"; }, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never>;
 }

package/popover/popover-types.d.ts

@@ -1,5 +1,10 @@
+/** First value of popover's position. */
 export declare type MtxPopoverPositionStart = 'above' | 'below' | 'before' | 'after';
+/** Second value of popover's position. */
 export declare type MtxPopoverPositionEnd = MtxPopoverPositionStart | 'center';
+/** Popover's position. */
 export declare type MtxPopoverPosition = [MtxPopoverPositionStart, MtxPopoverPositionEnd];
+/** Popover's trigger event. */
 export declare type MtxPopoverTriggerEvent = 'click' | 'hover' | 'none';
-export declare type MtxPopoverScrollStrategy = 'noop' | 'close' | 'block' | 'reposition';
+/** Reason why the popover was closed. */
+export declare type PopoverCloseReason = void | 'click' | 'keydown' | 'tab';

package/popover/popover.d.ts

@@ -1,106 +1,122 @@
-import { EventEmitter, OnDestroy, TemplateRef, ElementRef, NgZone } from '@angular/core';
 import { AnimationEvent } from '@angular/animations';
+import { Direction } from '@angular/cdk/bidi';
 import { BooleanInput } from '@angular/cdk/coercion';
-import { Directionality } from '@angular/cdk/bidi';
-import { MtxPopoverTriggerEvent, MtxPopoverScrollStrategy, MtxPopoverPosition } from './popover-types';
-import { MtxPopoverPanel } from './popover-interfaces';
+import { ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { MtxPopoverContent } from './popover-content';
+import { MtxPopoverDefaultOptions, MtxPopoverPanel } from './popover-interfaces';
+import { MtxPopoverPosition, MtxPopoverTriggerEvent, PopoverCloseReason } from './popover-types';
 import * as i0 from "@angular/core";
-export declare class MtxPopover implements MtxPopoverPanel, OnDestroy {
-    private _dir;
+/** Injection token to be used to override the default options for `mtx-popover`. */
+export declare const MTX_POPOVER_DEFAULT_OPTIONS: InjectionToken<MtxPopoverDefaultOptions>;
+/** @docs-private */
+export declare function MTX_POPOVER_DEFAULT_OPTIONS_FACTORY(): MtxPopoverDefaultOptions;
+export declare class MtxPopover implements MtxPopoverPanel, OnInit, OnDestroy {
     private _elementRef;
-    zone: NgZone;
-    role: string;
-    /** Settings for popover, view setters and getters for more detail */
-    private _position;
+    private _ngZone;
+    private _defaultOptions;
     private _triggerEvent;
-    private _scrollStrategy;
     private _enterDelay;
     private _leaveDelay;
+    private _position;
     private _panelOffsetX;
     private _panelOffsetY;
+    private _arrowWidth;
+    private _arrowHeight;
+    private _arrowOffsetX;
+    private _arrowOffsetY;
     private _closeOnPanelClick;
     private _closeOnBackdropClick;
-    private _disableAnimation;
     private _focusTrapEnabled;
     private _focusTrapAutoCaptureEnabled;
-    private _arrowOffsetX;
-    private _arrowOffsetY;
-    private _arrowWidth;
-    private _arrowHeight;
-    /** Config object to be passed into the popover's ngClass */
+    private _hasBackdrop;
+    private _elevation;
+    private _previousElevation?;
+    private _elevationPrefix;
+    /** Config object to be passed into the popover's ngClass. */
     _classList: {
         [key: string]: boolean;
     };
-    /** Whether popover's `targetElement` is defined */
-    containerPositioning: boolean;
+    /** Current state of the panel animation. */
+    _panelAnimationState: 'void' | 'enter';
+    /** Emits whenever an animation on the popover completes. */
+    readonly _animationDone: Subject<AnimationEvent>;
+    /** Whether the popover is animating. */
+    _isAnimating: boolean;
     /** Closing disabled on popover */
     closeDisabled: boolean;
     /** Config object to be passed into the popover's arrow ngStyle */
-    popoverPanelStyles: Record<string, unknown>;
-    /** Config object to be passed into the popover's arrow ngStyle */
-    popoverArrowStyles: Record<string, unknown>;
-    /** Config object to be passed into the popover's content ngStyle */
-    popoverContentStyles: Record<string, unknown>;
-    /** Emits the current animation state whenever it changes. */
-    _onAnimationStateChange: EventEmitter<AnimationEvent>;
-    /** Position of the popover. */
-    get position(): MtxPopoverPosition;
-    set position(value: MtxPopoverPosition);
-    /** Popover trigger event */
+    arrowStyles: Record<string, unknown> | null;
+    /** Layout direction of the popover. */
+    direction?: Direction;
+    /** Class or list of classes to be added to the overlay panel. */
+    overlayPanelClass: string | string[];
+    /** Class to be added to the backdrop element. */
+    backdropClass: string | undefined;
+    /** aria-label for the popover panel. */
+    ariaLabel?: string;
+    /** aria-labelledby for the popover panel. */
+    ariaLabelledby?: string;
+    /** aria-describedby for the popover panel. */
+    ariaDescribedby?: string;
+    /** Popover's trigger event. */
     get triggerEvent(): MtxPopoverTriggerEvent;
     set triggerEvent(value: MtxPopoverTriggerEvent);
-    /** Popover scroll strategy */
-    get scrollStrategy(): MtxPopoverScrollStrategy;
-    set scrollStrategy(value: MtxPopoverScrollStrategy);
-    /** Popover enter delay */
+    /** Popover's enter delay. */
     get enterDelay(): number;
     set enterDelay(value: number);
-    /** Popover leave delay */
+    /** Popover's leave delay. */
     get leaveDelay(): number;
     set leaveDelay(value: number);
-    /** Popover target offset x */
+    /** Popover's position. */
+    get position(): MtxPopoverPosition;
+    set position(value: MtxPopoverPosition);
+    /** Popover-panel's X offset. */
     get xOffset(): number;
     set xOffset(value: number);
-    /** Popover target offset y */
+    /** Popover-panel's Y offset. */
     get yOffset(): number;
     set yOffset(value: number);
-    /** Popover arrow offset x */
-    get arrowOffsetX(): number;
-    set arrowOffsetX(value: number);
-    /** Popover arrow offset y */
-    get arrowOffsetY(): number;
-    set arrowOffsetY(value: number);
-    /** Popover arrow width */
+    /** Popover-arrow's width. */
     get arrowWidth(): number;
     set arrowWidth(value: number);
-    /** Popover arrow height */
+    /** Popover-arrow's height. */
     get arrowHeight(): number;
     set arrowHeight(value: number);
-    /** Popover close on container click */
+    /** Popover-arrow's X offset. */
+    get arrowOffsetX(): number;
+    set arrowOffsetX(value: number);
+    /** Popover-arrow's Y offset. */
+    get arrowOffsetY(): number;
+    set arrowOffsetY(value: number);
+    /** Whether popover can be closed when click the popover-panel. */
     get closeOnPanelClick(): boolean;
     set closeOnPanelClick(value: boolean);
-    /** Popover close on backdrop click */
+    /** Whether popover can be closed when click the backdrop. */
     get closeOnBackdropClick(): boolean;
     set closeOnBackdropClick(value: boolean);
-    /** Disable animations of popover and all child elements */
-    get disableAnimation(): boolean;
-    set disableAnimation(value: boolean);
-    /** Popover focus trap using cdkTrapFocus */
+    /** Whether enable focus trap using `cdkTrapFocus`. */
     get focusTrapEnabled(): boolean;
     set focusTrapEnabled(value: boolean);
-    /** Popover focus trap auto capture using cdkTrapFocusAutoCapture */
+    /** Whether enable focus trap auto capture using `cdkTrapFocusAutoCapture`. */
     get focusTrapAutoCaptureEnabled(): boolean;
     set focusTrapAutoCaptureEnabled(value: boolean);
+    /** Whether the popover has a backdrop. It will always be false if the trigger event is hover. */
+    get hasBackdrop(): boolean | undefined;
+    set hasBackdrop(value: boolean | undefined);
+    /** Popover-panel's elevation (0~24). */
+    get elevation(): number;
+    set elevation(value: number);
     /**
      * This method takes classes set on the host md-popover element and applies them on the
-     * popover template that displays in the overlay container.  Otherwise, it's difficult
+     * popover template that displays in the overlay container. Otherwise, it's difficult
      * to style the containing popover from outside the component.
      * @param classes list of class names
      */
     set panelClass(classes: string);
     /**
      * This method takes classes set on the host md-popover element and applies them on the
-     * popover template that displays in the overlay container.  Otherwise, it's difficult
+     * popover template that displays in the overlay container. Otherwise, it's difficult
      * to style the containing popover from outside the component.
      * @deprecated Use `panelClass` instead.
      * @breaking-change 8.0.0
@@ -108,35 +124,47 @@ export declare class MtxPopover implements MtxPopoverPanel, OnDestroy {
     get classList(): string;
     set classList(classes: string);
     /** Event emitted when the popover is closed. */
-    closed: EventEmitter<void>;
+    closed: EventEmitter<PopoverCloseReason>;
+    /** @docs-private */
     templateRef: TemplateRef<any>;
-    constructor(_dir: Directionality, _elementRef: ElementRef, zone: NgZone);
+    /**
+     * Popover content that will be rendered lazily.
+     * @docs-private
+     */
+    lazyContent?: MtxPopoverContent;
+    readonly panelId: string;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone, _defaultOptions: MtxPopoverDefaultOptions);
+    ngOnInit(): void;
     ngOnDestroy(): void;
     /** Handle a keyboard event from the popover, delegating to the appropriate action. */
     _handleKeydown(event: KeyboardEvent): void;
-    /**
-     * This emits a close event to which the trigger is subscribed. When emitted, the
-     * trigger will close the popover.
-     */
-    _emitCloseEvent(): void;
-    /** Close popover on click if closeOnPanelClick is true */
-    onClick(): void;
-    /** Disables close of popover when leaving trigger element and mouse over the popover */
-    onMouseOver(): void;
-    /** Enables close of popover when mouse leaving popover element */
-    onMouseLeave(): void;
-    /** Sets the current styles for the popover to allow for dynamically changing settings */
+    /** Close popover on click if `closeOnPanelClick` is true. */
+    _handleClick(): void;
+    /** Disables close of popover when leaving trigger element and mouse over the popover. */
+    _handleMouseOver(): void;
+    /** Enables close of popover when mouse leaving popover element. */
+    _handleMouseLeave(): void;
+    /** Sets the current styles for the popover to allow for dynamically changing settings. */
     setCurrentStyles(pos?: MtxPopoverPosition): void;
     /**
      * It's necessary to set position-based classes to ensure the popover panel animation
      * folds out from the correct direction.
      */
     setPositionClasses(pos?: MtxPopoverPosition): void;
+    /** Sets the popover-panel's elevation. */
+    setElevation(): void;
+    /** Starts the enter animation. */
+    _startAnimation(): void;
+    /** Resets the panel animation to its initial state. */
+    _resetAnimation(): void;
+    /** Callback that is invoked when the panel animation completes. */
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
     static ngAcceptInputType_closeOnPanelClick: BooleanInput;
     static ngAcceptInputType_closeOnBackdropClick: BooleanInput;
-    static ngAcceptInputType_disableAnimation: BooleanInput;
     static ngAcceptInputType_focusTrapEnabled: BooleanInput;
     static ngAcceptInputType_focusTrapAutoCaptureEnabled: BooleanInput;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxPopover, [{ optional: true; }, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MtxPopover, "mtx-popover", ["mtxPopover"], { "position": "position"; "triggerEvent": "triggerEvent"; "scrollStrategy": "scrollStrategy"; "enterDelay": "enterDelay"; "leaveDelay": "leaveDelay"; "xOffset": "xOffset"; "yOffset": "yOffset"; "arrowOffsetX": "arrowOffsetX"; "arrowOffsetY": "arrowOffsetY"; "arrowWidth": "arrowWidth"; "arrowHeight": "arrowHeight"; "closeOnPanelClick": "closeOnPanelClick"; "closeOnBackdropClick": "closeOnBackdropClick"; "disableAnimation": "disableAnimation"; "focusTrapEnabled": "focusTrapEnabled"; "focusTrapAutoCaptureEnabled": "focusTrapAutoCaptureEnabled"; "panelClass": "class"; "classList": "classList"; }, { "closed": "closed"; }, never, ["*"]>;
+    static ngAcceptInputType_hasBackdrop: BooleanInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxPopover, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MtxPopover, "mtx-popover", ["mtxPopover"], { "backdropClass": "backdropClass"; "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; "ariaDescribedby": "aria-describedby"; "triggerEvent": "triggerEvent"; "enterDelay": "enterDelay"; "leaveDelay": "leaveDelay"; "position": "position"; "xOffset": "xOffset"; "yOffset": "yOffset"; "arrowWidth": "arrowWidth"; "arrowHeight": "arrowHeight"; "arrowOffsetX": "arrowOffsetX"; "arrowOffsetY": "arrowOffsetY"; "closeOnPanelClick": "closeOnPanelClick"; "closeOnBackdropClick": "closeOnBackdropClick"; "focusTrapEnabled": "focusTrapEnabled"; "focusTrapAutoCaptureEnabled": "focusTrapAutoCaptureEnabled"; "hasBackdrop": "hasBackdrop"; "elevation": "elevation"; "panelClass": "class"; "classList": "classList"; }, { "closed": "closed"; }, ["lazyContent"], ["*"]>;
 }

package/popover/popover.scss

@@ -1,10 +1,12 @@
 $arrow-size: 1em; // 16px default
 
 .mtx-popover-panel {
+  position: relative;
   max-height: calc(100vh - 48px);
   padding: 8px;
   border-radius: 4px;
   font-size: 16px; // It can change the arrow size
+  outline: 0;
 
   &[class*='mtx-popover-below'] {
     margin-top: calc(#{$arrow-size * .5} + 2px);

package/popover/public-api.d.ts

@@ -1,5 +1,6 @@
 export * from './popover-module';
 export * from './popover';
+export * from './popover-content';
 export * from './popover-trigger';
 export * from './popover-target';
 export * from './popover-animations';

package/select/option.component.d.ts

@@ -1,24 +1,25 @@
+import { BooleanInput } from '@angular/cdk/coercion';
 import { AfterViewChecked, ElementRef, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class MtxOptionComponent implements OnChanges, AfterViewChecked, OnDestroy {
     elementRef: ElementRef<HTMLElement>;
     value: any;
-    get disabled(): any;
-    set disabled(value: any);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    get label(): string;
+    private _previousLabel?;
     readonly stateChange$: Subject<{
         value: any;
         disabled: boolean;
         label?: string | undefined;
     }>;
-    private _disabled;
-    private _previousLabel;
     constructor(elementRef: ElementRef<HTMLElement>);
-    get label(): string;
     ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewChecked(): void;
     ngOnDestroy(): void;
-    private _isDisabled;
+    static ngAcceptInputType_disabled: BooleanInput;
     static ɵfac: i0.ɵɵFactoryDeclaration<MtxOptionComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MtxOptionComponent, "mtx-option", ["mtxOption"], { "value": "value"; "disabled": "disabled"; }, {}, never, ["*"]>;
 }