@ng-matero/extensions 19.4.1 → 20.0.1

package/tooltip/index.d.ts

@@ -1,5 +1,347 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, AfterViewInit, TemplateRef, ElementRef } from '@angular/core';
+import * as i1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/cdk/overlay';
+import { ScrollStrategy, Overlay, OverlayRef, ConnectedPosition, OriginConnectionPosition, OverlayConnectionPosition } from '@angular/cdk/overlay';
+import * as i4 from '@angular/material/core';
+import * as i5 from '@ng-matero/extensions/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import * as i7 from '@angular/cdk/scrolling';
+
+/** Possible positions for a tooltip. */
+type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
 /**
- * Generated bundle index. Do not edit.
+ * Options for how the tooltip trigger should handle touch gestures.
+ * See `MtxTooltip.touchGestures` for more information.
  */
-/// <amd-module name="@ng-matero/extensions/tooltip" />
-export * from './public-api';
+type TooltipTouchGestures = 'auto' | 'on' | 'off';
+/** Possible visibility states of a tooltip. */
+type TooltipVisibility = 'initial' | 'visible' | 'hidden';
+/** Time in ms to throttle repositioning after scroll events. */
+declare const SCROLL_THROTTLE_MS = 20;
+/**
+ * Creates an error to be thrown if the user supplied an invalid tooltip position.
+ * @docs-private
+ */
+declare function getMtxTooltipInvalidPositionError(position: string): Error;
+/** Injection token that determines the scroll handling while a tooltip is visible. */
+declare const MTX_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function MTX_TOOLTIP_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare const MTX_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MTX_TOOLTIP_SCROLL_STRATEGY_FACTORY;
+};
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function MTX_TOOLTIP_DEFAULT_OPTIONS_FACTORY(): MtxTooltipDefaultOptions;
+/** Injection token to be used to override the default options for `mtxTooltip`. */
+declare const MTX_TOOLTIP_DEFAULT_OPTIONS: InjectionToken<MtxTooltipDefaultOptions>;
+/** Default `mtxTooltip` options that can be overridden. */
+interface MtxTooltipDefaultOptions {
+    /** Default delay when the tooltip is shown. */
+    showDelay: number;
+    /** Default delay when the tooltip is hidden. */
+    hideDelay: number;
+    /** Default delay when hiding the tooltip on a touch device. */
+    touchendHideDelay: number;
+    /** Time between the user putting the pointer on a tooltip trigger and the long press event being fired on a touch device. */
+    touchLongPressShowDelay?: number;
+    /** Default touch gesture handling for tooltips. */
+    touchGestures?: TooltipTouchGestures;
+    /** Default position for tooltips. */
+    position?: TooltipPosition;
+    /**
+     * Default value for whether tooltips should be positioned near the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    positionAtOrigin?: boolean;
+    /** Disables the ability for the user to interact with the tooltip element. */
+    disableTooltipInteractivity?: boolean;
+    /**
+     * Default classes to be applied to the tooltip. These default classes will not be applied if
+     * `tooltipClass` is defined directly on the tooltip element, as it will override the default.
+     */
+    tooltipClass?: string | string[];
+}
+/**
+ * CSS class that will be attached to the overlay panel.
+ * @deprecated
+ * @breaking-change 13.0.0 remove this variable
+ */
+declare const TOOLTIP_PANEL_CLASS = "mtx-mdc-tooltip-panel";
+/**
+ * Directive that attaches a material design tooltip to the host element. Animates the showing and
+ * hiding of a tooltip provided position (defaults to below the element).
+ *
+ * https://material.io/design/components/tooltips.html
+ */
+declare class MtxTooltip implements OnDestroy, AfterViewInit {
+    private _elementRef;
+    private _ngZone;
+    private _platform;
+    private _ariaDescriber;
+    private _focusMonitor;
+    protected _dir: Directionality;
+    private _injector;
+    private _viewContainerRef;
+    private _defaultOptions;
+    _overlayRef: OverlayRef | null;
+    _tooltipInstance: TooltipComponent | null;
+    private _portal;
+    private _position;
+    private _positionAtOrigin;
+    private _disabled;
+    private _tooltipClass;
+    private _viewInitialized;
+    private _pointerExitEventsInitialized;
+    private readonly _tooltipComponent;
+    private _viewportMargin;
+    private _currentPosition;
+    private readonly _cssClassPrefix;
+    private _ariaDescriptionPending;
+    private _dirSubscribed;
+    /** Allows the user to define the position of the tooltip relative to the parent element */
+    get position(): TooltipPosition;
+    set position(value: TooltipPosition);
+    /**
+     * Whether tooltip should be relative to the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    get positionAtOrigin(): boolean;
+    set positionAtOrigin(value: BooleanInput);
+    /** Disables the display of the tooltip. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /** The default delay in ms before showing the tooltip after show is called */
+    get showDelay(): number;
+    set showDelay(value: NumberInput);
+    private _showDelay;
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    get hideDelay(): number;
+    set hideDelay(value: NumberInput);
+    private _hideDelay;
+    /**
+     * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive
+     * uses a long press gesture to show and hide, however it can conflict with the native browser
+     * gestures. To work around the conflict, Angular Material disables native gestures on the
+     * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable
+     * elements). The different values for this option configure the touch event handling as follows:
+     * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native
+     *   browser gestures on particular elements. In particular, it allows text selection on inputs
+     *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.
+     * - `on` - Enables touch gestures for all elements and disables native
+     *   browser gestures with no exceptions.
+     * - `off` - Disables touch gestures. Note that this will prevent the tooltip from
+     *   showing on touch devices.
+     */
+    touchGestures: TooltipTouchGestures;
+    /** The message to be displayed in the tooltip */
+    get message(): string | TemplateRef<any>;
+    set message(value: string | TemplateRef<any>);
+    private _message;
+    /** Context to be passed to the tooltip. */
+    get tooltipContext(): any;
+    set tooltipContext(value: any);
+    private _tooltipContext;
+    /** Classes to be passed to the tooltip. Supports the same syntax as `ngClass`. */
+    get tooltipClass(): string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    set tooltipClass(value: string | string[] | Set<string> | {
+        [key: string]: any;
+    });
+    /** Manually-bound passive event listeners. */
+    private readonly _passiveListeners;
+    /** Timer started at the last `touchstart` event. */
+    private _touchstartTimeout;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    /** Whether ngOnDestroyed has been called. */
+    private _isDestroyed;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    /**
+     * Dispose the tooltip when destroyed.
+     */
+    ngOnDestroy(): void;
+    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */
+    show(delay?: number, origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */
+    hide(delay?: number): void;
+    /** Shows/hides the tooltip */
+    toggle(origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Returns true if the tooltip is currently visible to the user */
+    _isTooltipVisible(): boolean;
+    /** Create the overlay config and position strategy */
+    private _createOverlay;
+    /** Detaches the currently-attached tooltip. */
+    private _detach;
+    /** Updates the position of the current tooltip. */
+    private _updatePosition;
+    /** Adds the configured offset to a position. Used as a hook for child classes. */
+    protected _addOffset(position: ConnectedPosition): ConnectedPosition;
+    /**
+     * Returns the origin position and a fallback position based on the user's position preference.
+     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
+     */
+    _getOrigin(): {
+        main: OriginConnectionPosition;
+        fallback: OriginConnectionPosition;
+    };
+    /** Returns the overlay position and a fallback position based on the user's preference */
+    _getOverlayPosition(): {
+        main: OverlayConnectionPosition;
+        fallback: OverlayConnectionPosition;
+    };
+    /** Updates the tooltip message and repositions the overlay according to the new message length */
+    private _updateTooltipMessage;
+    /** Updates the tooltip context */
+    private _setTooltipContext;
+    /** Updates the tooltip class */
+    private _setTooltipClass;
+    /** Inverts an overlay position. */
+    private _invertPosition;
+    /** Updates the class on the overlay panel based on the current position of the tooltip. */
+    private _updateCurrentPositionClass;
+    /** Binds the pointer events to the tooltip trigger. */
+    private _setupPointerEnterEventsIfNeeded;
+    private _setupPointerExitEventsIfNeeded;
+    private _addListeners;
+    private _platformSupportsMouseEvents;
+    /** Listener for the `wheel` event on the element. */
+    private _wheelListener;
+    /** Disables the native browser gestures, based on how the tooltip has been configured. */
+    private _disableNativeGesturesIfNecessary;
+    /** Updates the tooltip's ARIA description based on it current state. */
+    private _syncAriaDescription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MtxTooltip, "[mtxTooltip]", ["mtxTooltip"], { "position": { "alias": "mtxTooltipPosition"; "required": false; }; "positionAtOrigin": { "alias": "mtxTooltipPositionAtOrigin"; "required": false; }; "disabled": { "alias": "mtxTooltipDisabled"; "required": false; }; "showDelay": { "alias": "mtxTooltipShowDelay"; "required": false; }; "hideDelay": { "alias": "mtxTooltipHideDelay"; "required": false; }; "touchGestures": { "alias": "mtxTooltipTouchGestures"; "required": false; }; "message": { "alias": "mtxTooltip"; "required": false; }; "tooltipContext": { "alias": "mtxTooltipContext"; "required": false; }; "tooltipClass": { "alias": "mtxTooltipClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Internal component that wraps the tooltip's content.
+ * @docs-private
+ */
+declare class TooltipComponent implements OnDestroy {
+    private _changeDetectorRef;
+    protected _elementRef: ElementRef<HTMLElement>;
+    _isMultiline: boolean;
+    /** Message to display in the tooltip */
+    message: string | TemplateRef<any>;
+    /** Context to be added to the tooltip */
+    tooltipContext: any;
+    /** Classes to be added to the tooltip. Supports the same syntax as `ngClass`. */
+    tooltipClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    /** The timeout ID of any current timer set to show the tooltip */
+    private _showTimeoutId;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    private _hideTimeoutId;
+    /** Element that caused the tooltip to open. */
+    _triggerElement: HTMLElement;
+    /** Amount of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay: number;
+    /** Whether animations are currently disabled. */
+    private _animationsDisabled;
+    /** Reference to the internal tooltip element. */
+    _tooltip: ElementRef<HTMLElement>;
+    /** Whether interactions on the page should close the tooltip */
+    private _closeOnInteraction;
+    /** Whether the tooltip is currently visible. */
+    private _isVisible;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    private readonly _onHide;
+    /** Name of the show animation and the class that toggles it. */
+    private readonly _showAnimation;
+    /** Name of the hide animation and the class that toggles it. */
+    private readonly _hideAnimation;
+    constructor(...args: unknown[]);
+    /**
+     * Shows the tooltip with an animation originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay: number): void;
+    /**
+     * Begins the animation to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay showing the tooltip.
+     */
+    hide(delay: number): void;
+    /** Returns an observable that notifies when the tooltip has been hidden from view. */
+    afterHidden(): Observable<void>;
+    /** Whether the tooltip is being displayed. */
+    isVisible(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction(): void;
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck(): void;
+    _handleMouseLeave({ relatedTarget }: MouseEvent): void;
+    /**
+     * Callback for when the timeout in this.show() gets completed.
+     * This method is only needed by the mdc-tooltip, and so it is only implemented
+     * in the mdc-tooltip, not here.
+     */
+    protected _onShow(): void;
+    /** Whether the tooltip text has overflown to the next line */
+    private _isTooltipMultiline;
+    /** Event listener dispatched when an animation on the tooltip finishes. */
+    _handleAnimationEnd({ animationName }: AnimationEvent): void;
+    /** Cancels any pending animation sequences. */
+    _cancelPendingAnimations(): void;
+    /** Handles the cleanup after an animation has finished. */
+    private _finalizeAnimation;
+    /** Toggles the visibility of the tooltip element. */
+    private _toggleVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "mtx-tooltip-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class MtxTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MtxTooltipModule, never, [typeof i1.A11yModule, typeof i2.CommonModule, typeof i3.OverlayModule, typeof i4.MatCommonModule, typeof i5.MtxPipesModule, typeof MtxTooltip, typeof TooltipComponent], [typeof MtxTooltip, typeof TooltipComponent, typeof i4.MatCommonModule, typeof i7.CdkScrollableModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MtxTooltipModule>;
+}
+
+/**
+ * Animations used by MatTooltip.
+ * @docs-private
+ * @deprecated No longer being used, to be removed.
+ * @breaking-change 21.0.0
+ */
+declare const matTooltipAnimations: {
+    readonly tooltipState: any;
+};
+
+export { MTX_TOOLTIP_DEFAULT_OPTIONS, MTX_TOOLTIP_DEFAULT_OPTIONS_FACTORY, MTX_TOOLTIP_SCROLL_STRATEGY, MTX_TOOLTIP_SCROLL_STRATEGY_FACTORY, MTX_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER, MtxTooltip, MtxTooltipModule, SCROLL_THROTTLE_MS, TOOLTIP_PANEL_CLASS, TooltipComponent, getMtxTooltipInvalidPositionError, matTooltipAnimations };
+export type { MtxTooltipDefaultOptions, TooltipPosition, TooltipTouchGestures, TooltipVisibility };

package/tooltip/tooltip.scss

@@ -1,6 +1,8 @@
-@use '../core/tokens/m2/mdc/plain-tooltip' as tokens-mdc-plain-tooltip;
+@use './m3-tooltip';
 @use '../core/tokens/token-utils';
 
+$fallbacks: m3-tooltip.get-tokens();
+
 .mtx-mdc-tooltip {
   // We don't use MDC's positioning so this has to be relative.
   position: relative;
@@ -58,20 +60,14 @@
   // TODO(crisbeto): these styles aren't necessary, but they were present in
   // MDC and removing them is likely to cause screenshot differences.
   will-change: transform, opacity;
-
-  @include token-utils.use-tokens(
-    tokens-mdc-plain-tooltip.$prefix,
-    tokens-mdc-plain-tooltip.get-token-slots()
-  ) {
-    @include token-utils.create-token-slot(background-color, container-color);
-    @include token-utils.create-token-slot(color, supporting-text-color);
-    @include token-utils.create-token-slot(border-radius, container-shape);
-    @include token-utils.create-token-slot(font-family, supporting-text-font);
-    @include token-utils.create-token-slot(font-size, supporting-text-size);
-    @include token-utils.create-token-slot(font-weight, supporting-text-weight);
-    @include token-utils.create-token-slot(line-height, supporting-text-line-height);
-    @include token-utils.create-token-slot(letter-spacing, supporting-text-tracking);
-  }
+  background-color: token-utils.slot(tooltip-container-color, $fallbacks);
+  color: token-utils.slot(tooltip-supporting-text-color, $fallbacks);
+  border-radius: token-utils.slot(tooltip-container-shape, $fallbacks);
+  font-family: token-utils.slot(tooltip-supporting-text-font, $fallbacks);
+  font-size: token-utils.slot(tooltip-supporting-text-size, $fallbacks);
+  font-weight: token-utils.slot(tooltip-supporting-text-weight, $fallbacks);
+  line-height: token-utils.slot(tooltip-supporting-text-line-height, $fallbacks);
+  letter-spacing: token-utils.slot(tooltip-supporting-text-tracking, $fallbacks);
 
   // Renders an outline in high contrast mode.
   &::before {

package/alert/alert-module.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "./alert";
-export declare class MtxAlertModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxAlertModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MtxAlertModule, never, [typeof i1.CommonModule, typeof i2.MtxAlert], [typeof i2.MtxAlert]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<MtxAlertModule>;
-}

package/alert/alert.d.ts

@@ -1,19 +0,0 @@
-import { EventEmitter } from '@angular/core';
-import * as i0 from "@angular/core";
-export type MtxAlertType = 'default' | 'info' | 'success' | 'warning' | 'danger';
-export declare class MtxAlert {
-    private _changeDetectorRef;
-    get hostClassList(): string;
-    /** The alert's type. Can be `default`, `info`, `success`, `warning` or `danger`. */
-    type: MtxAlertType;
-    /** Whether to display an inline close button. */
-    dismissible: boolean;
-    /** The alert's elevation (0~24). */
-    elevation: number;
-    /** Event emitted when the alert closed. */
-    closed: EventEmitter<MtxAlert>;
-    _onClosed(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxAlert, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MtxAlert, "mtx-alert", ["mtxAlert"], { "type": { "alias": "type"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "elevation": { "alias": "elevation"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
-    static ngAcceptInputType_dismissible: unknown;
-}

package/alert/public-api.d.ts

@@ -1,2 +0,0 @@
-export * from './alert-module';
-export * from './alert';

package/button/button-loading.d.ts

@@ -1,19 +0,0 @@
-import { OnChanges, SimpleChanges } from '@angular/core';
-import { ThemePalette } from '@angular/material/core';
-import * as i0 from "@angular/core";
-export declare class MatButtonLoading implements OnChanges {
-    private _elementRef;
-    private _viewContainerRef;
-    private _renderer;
-    private spinner;
-    loading: boolean;
-    disabled: boolean;
-    color: ThemePalette;
-    ngOnChanges(changes: SimpleChanges): void;
-    private createSpinner;
-    private destroySpinner;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonLoading, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonLoading, "[mat-button][loading],             [mat-raised-button][loading],             [mat-stroked-button][loading],             [mat-flat-button][loading],             [mat-icon-button][loading],             [mat-fab][loading],             [mat-mini-fab][loading]", never, { "loading": { "alias": "loading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_loading: unknown;
-    static ngAcceptInputType_disabled: unknown;
-}

package/button/button-module.d.ts

@@ -1,10 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "@angular/material/button";
-import * as i3 from "@angular/material/progress-spinner";
-import * as i4 from "./button-loading";
-export declare class MtxButtonModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxButtonModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MtxButtonModule, never, [typeof i1.CommonModule, typeof i2.MatButtonModule, typeof i3.MatProgressSpinnerModule, typeof i4.MatButtonLoading], [typeof i4.MatButtonLoading]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<MtxButtonModule>;
-}

package/button/public-api.d.ts

@@ -1,2 +0,0 @@
-export * from './button-module';
-export * from './button-loading';

package/checkbox-group/checkbox-group-module.d.ts

@@ -1,11 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "@angular/forms";
-import * as i3 from "@angular/material/checkbox";
-import * as i4 from "@ng-matero/extensions/core";
-import * as i5 from "./checkbox-group";
-export declare class MtxCheckboxGroupModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxCheckboxGroupModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MtxCheckboxGroupModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.MatCheckboxModule, typeof i4.MtxPipesModule, typeof i5.MtxCheckboxGroup], [typeof i5.MtxCheckboxGroup, typeof i4.MtxPipesModule]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<MtxCheckboxGroupModule>;
-}

package/checkbox-group/checkbox-group.d.ts

@@ -1,86 +0,0 @@
-import { AfterViewInit, EventEmitter, OnDestroy, QueryList, TrackByFunction } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
-import { MatCheckbox, MatCheckboxChange } from '@angular/material/checkbox';
-import { MtxCheckboxGroupOption } from './interfaces';
-import * as i0 from "@angular/core";
-export declare class MtxCheckboxBase {
-    label?: any | undefined;
-    value?: any | undefined;
-    constructor(label?: any | undefined, value?: any | undefined);
-}
-export declare class MtxCheckboxGroup implements AfterViewInit, OnDestroy, ControlValueAccessor {
-    private _changeDetectorRef;
-    private _focusMonitor;
-    private _elementRef;
-    _checkboxes: QueryList<MatCheckbox>;
-    /**
-     * Tracking function that will be used to check the differences in data changes. Used similarly
-     * to `ngFor` `trackBy` function. Optimize row operations by identifying a row based on its data
-     * relative to the function to know if a row should be added/removed/moved.
-     * Accepts a function that takes two parameters, `index` and `item`.
-     */
-    get trackBy(): TrackByFunction<any> | undefined;
-    set trackBy(fn: TrackByFunction<any> | undefined);
-    private _trackByFn?;
-    get items(): any[];
-    set items(value: any[]);
-    private _items;
-    private _originalItems;
-    bindLabel: string;
-    bindValue: string;
-    showSelectAll: boolean;
-    selectAllLabel: string;
-    get compareWith(): ((o1: any, o2: any) => boolean) | undefined;
-    set compareWith(fn: ((o1: any, o2: any) => boolean) | undefined);
-    private _compareWith?;
-    disabled: boolean;
-    change: EventEmitter<{
-        model: MtxCheckboxGroupOption[];
-        index: number;
-    }>;
-    selectAll: boolean;
-    selectAllIndeterminate: boolean;
-    selectedItems: MtxCheckboxGroupOption[];
-    _onChange: (value: MtxCheckboxGroupOption[]) => void;
-    _onTouched: () => void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    /**
-     * Finds and selects and option based on its value.
-     * @returns Option that has the corresponding value.
-     */
-    private _selectValue;
-    /**
-     * Sets the model value. Implemented as part of ControlValueAccessor.
-     * @param value New value to be written to the model.
-     */
-    writeValue(value: any[]): void;
-    /**
-     * Registers a callback to be triggered when the model value changes.
-     * Implemented as part of ControlValueAccessor.
-     * @param fn Callback to be registered.
-     */
-    registerOnChange(fn: (value: MtxCheckboxGroupOption[]) => Record<string, unknown>): void;
-    /**
-     * Registers a callback to be triggered when the control is touched.
-     * Implemented as part of ControlValueAccessor.
-     * @param fn Callback to be registered.
-     */
-    registerOnTouched(fn: () => Record<string, unknown>): void;
-    /**
-     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
-     * @param isDisabled Whether the control should be disabled.
-     */
-    setDisabledState(isDisabled: boolean): void;
-    private _checkMasterCheckboxState;
-    private _getSelectedItems;
-    /** Handle normal checkbox toggle */
-    _updateNormalCheckboxState(e: MatCheckboxChange, index: number): void;
-    /** Handle master checkbox toggle */
-    _updateMasterCheckboxState(e: MatCheckboxChange, index: number): void;
-    _trackBy: (index: number, item: any) => any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MtxCheckboxGroup, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MtxCheckboxGroup, "mtx-checkbox-group", ["mtxCheckboxGroup"], { "trackBy": { "alias": "trackBy"; "required": false; }; "items": { "alias": "items"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, ["_checkboxes"], never, true, never>;
-    static ngAcceptInputType_showSelectAll: unknown;
-    static ngAcceptInputType_disabled: unknown;
-}

package/checkbox-group/interfaces.d.ts

@@ -1,17 +0,0 @@
-export interface MtxCheckboxGroupOption {
-    ariaDescribedby?: string;
-    ariaLabel?: string;
-    ariaLabelledby?: string;
-    label?: any;
-    value?: any;
-    color?: string;
-    checked?: boolean;
-    disabled?: boolean;
-    disableRipple?: boolean;
-    indeterminate?: boolean;
-    labelPosition?: 'before' | 'after';
-    id?: string;
-    name?: string | null;
-    required?: boolean;
-    [k: string]: any;
-}

package/checkbox-group/public-api.d.ts

@@ -1,3 +0,0 @@
-export * from './checkbox-group-module';
-export * from './checkbox-group';
-export * from './interfaces';

package/colorpicker/colorpicker-animations.d.ts

@@ -1,9 +0,0 @@
-/**
- * Animations used by the colorpicker.
- * @docs-private
- * @deprecated No longer used, will be removed.
- * @breaking-change 21.0.0
- */
-export declare const mtxColorpickerAnimations: {
-    readonly transformPanel: any;
-};