@depup/angular__material 21.2.2-depup.19

package/tooltip/_tooltip-theme.scss

@@ -0,0 +1,76 @@
+@use '../core/theming/inspection';
+@use '../core/tokens/token-utils';
+@use '../core/typography/typography';
+@use './m2-tooltip';
+@use './m3-tooltip';
+@use 'sass:map';
+
+@mixin base($theme) {
+  $tokens: map.get(m2-tooltip.get-tokens($theme), base);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tooltip.get-tokens($theme), base);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+@mixin color($theme) {
+  $tokens: map.get(m2-tooltip.get-tokens($theme), color);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tooltip.get-tokens($theme), color);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+@mixin typography($theme) {
+  $tokens: map.get(m2-tooltip.get-tokens($theme), typography);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tooltip.get-tokens($theme), typography);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+@mixin density($theme) {
+  $tokens: map.get(m2-tooltip.get-tokens($theme), density);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tooltip.get-tokens($theme), density);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+/// Defines the tokens that will be available in the `overrides` mixin and for docs extraction.
+@function _define-overrides() {
+  @return (
+    (
+      namespace: tooltip,
+      tokens: token-utils.get-overrides(m3-tooltip.get-tokens(), tooltip)
+    ),
+  );
+}
+
+@mixin overrides($tokens: ()) {
+    @include token-utils.batch-create-token-values($tokens, _define-overrides());
+}
+
+@mixin theme($theme) {
+  @if inspection.get-theme-version($theme) == 1 {
+    @include base($theme);
+    @include color($theme);
+    @include density($theme);
+    @include typography($theme);
+  } @else {
+    @include base($theme);
+    @if inspection.theme-has($theme, color) {
+      @include color($theme);
+    }
+    @if inspection.theme-has($theme, density) {
+      @include density($theme);
+    }
+    @if inspection.theme-has($theme, typography) {
+      @include typography($theme);
+    }
+  }
+}

package/tree/_m2-tree.scss

@@ -0,0 +1,30 @@
+@use 'sass:map';
+@use '../core/theming/theming';
+@use '../core/tokens/m2-utils';
+
+@function get-tokens($theme) {
+  $system: m2-utils.get-system($theme);
+  $density-scale: theming.clamp-density(map.get($system, density-scale), -4);
+
+  @return (
+    base: (),
+    color: (
+      tree-container-background-color: map.get($system, surface),
+      tree-node-text-color: map.get($system, on-surface),
+    ),
+    typography: (
+      // TODO(crisbeto): provide tokens for line height and letter spacing
+      tree-node-text-font: map.get($system, body-medium-font),
+      tree-node-text-size: map.get($system, body-medium-size),
+      tree-node-text-weight: map.get($system, body-medium-weight),),
+    density: (
+      tree-node-min-height: map.get((
+        0: 48px,
+        -1: 44px,
+        -2: 40px,
+        -3: 36px,
+        -4: 28px,
+      ), $density-scale)
+    ),
+  );
+}

package/tree/_m3-tree.scss

@@ -0,0 +1,37 @@
+@use 'sass:map';
+@use 'sass:list';
+@use '../core/tokens/m3-utils';
+@use '../core/theming/theming';
+@use '../core/tokens/m3';
+
+// The prefix used to generate the fully qualified name for tokens in this file.
+$prefix: (mat, tree);
+
+/// Generates custom tokens for the mat-tree.
+@function get-tokens($theme: m3.$sys-theme) {
+  $system: m3-utils.get-system($theme);
+
+  @return (
+    base: (),
+    color: (
+      tree-container-background-color: map.get($system, surface),
+      tree-node-text-color: map.get($system, on-surface),
+    ),
+    typography: (
+      tree-node-text-font: map.get($system, body-large-font),
+      tree-node-text-size: map.get($system, body-large-size),
+      tree-node-text-weight: map.get($system, body-large-weight),
+    ),
+    density: get-density-tokens(map.get($system, density-scale)),
+  );
+}
+
+// Tokens that can be configured through Angular Material's density theming API.
+@function get-density-tokens($scale) {
+  $scale: theming.clamp-density($scale, -4);
+  $index: ($scale * -1) + 1;
+
+  @return (
+    tree-node-min-height: list.nth((48px, 44px, 40px, 36px, 28px), $index),
+  );
+}

package/tree/_tree-theme.scss

@@ -0,0 +1,76 @@
+@use 'sass:map';
+@use '../core/theming/inspection';
+@use '../core/typography/typography';
+@use '../core/tokens/token-utils';
+@use './m2-tree';
+@use './m3-tree';
+
+@mixin base($theme) {
+  $tokens: map.get(m2-tree.get-tokens($theme), base);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tree.get-tokens($theme), base);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+@mixin color($theme) {
+  $tokens: map.get(m2-tree.get-tokens($theme), color);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tree.get-tokens($theme), color);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+@mixin typography($theme) {
+  $tokens: map.get(m2-tree.get-tokens($theme), typography);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tree.get-tokens($theme), typography);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+@mixin density($theme) {
+  $tokens: map.get(m2-tree.get-tokens($theme), density);
+  @if inspection.get-theme-version($theme) == 1 {
+    $tokens: map.get(m3-tree.get-tokens($theme), density);
+  }
+
+  @include token-utils.values($tokens);
+}
+
+/// Defines the tokens that will be available in the `overrides` mixin and for docs extraction.
+@function _define-overrides() {
+  @return (
+    (
+      namespace: tree,
+      tokens: token-utils.get-overrides(m3-tree.get-tokens(), tree)
+    ),
+  );
+}
+
+@mixin overrides($tokens: ()) {
+    @include token-utils.batch-create-token-values($tokens, _define-overrides());
+}
+
+@mixin theme($theme) {
+  @if inspection.get-theme-version($theme) == 1 {
+    @include base($theme);
+    @include color($theme);
+    @include density($theme);
+    @include typography($theme);
+  } @else {
+    @include base($theme);
+    @if inspection.theme-has($theme, color) {
+      @include color($theme);
+    }
+    @if inspection.theme-has($theme, density) {
+      @include density($theme);
+    }
+    @if inspection.theme-has($theme, typography) {
+      @include typography($theme);
+    }
+  }
+}

package/types/_badge-chunk.d.ts

@@ -0,0 +1,100 @@
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy } from '@angular/core';
+import { ThemePalette } from './_palette-chunk.js';
+
+/** Allowed position options for matBadgePosition */
+type MatBadgePosition = 'above after' | 'above before' | 'below before' | 'below after' | 'before' | 'after' | 'above' | 'below';
+/** Allowed size options for matBadgeSize */
+type MatBadgeSize = 'small' | 'medium' | 'large';
+/**
+ * Component used to load the structural styles of the badge.
+ * @docs-private
+ */
+declare class _MatBadgeStyleLoader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MatBadgeStyleLoader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<_MatBadgeStyleLoader, "ng-component", never, {}, {}, never, never, true, never>;
+}
+/** Directive to display a text badge. */
+declare class MatBadge implements OnInit, AfterViewInit, OnDestroy {
+    private _ngZone;
+    private _elementRef;
+    private _ariaDescriber;
+    private _renderer;
+    private _animationsDisabled;
+    private _idGenerator;
+    /**
+     * Theme color of the badge. This API is supported in M2 themes only, it
+     * has no effect in M3 themes. For color customization in M3, see https://material.angular.dev/components/badge/styling.
+     *
+     * For information on applying color variants in M3, see
+     * https://material.angular.dev/guide/material-2-theming#optional-add-backwards-compatibility-styles-for-color-variants
+     */
+    get color(): ThemePalette;
+    set color(value: ThemePalette);
+    private _color;
+    /** Whether the badge should overlap its contents or not */
+    overlap: boolean;
+    /** Whether the badge is disabled. */
+    disabled: boolean;
+    /**
+     * Position the badge should reside.
+     * Accepts any combination of 'above'|'below' and 'before'|'after'
+     */
+    position: MatBadgePosition;
+    /** The content for the badge */
+    get content(): string | number | undefined | null;
+    set content(newContent: string | number | undefined | null);
+    private _content;
+    /** Message used to describe the decorated element via aria-describedby */
+    get description(): string;
+    set description(newDescription: string);
+    private _description;
+    /** Size of the badge. Can be 'small', 'medium', or 'large'. */
+    size: MatBadgeSize;
+    /** Whether the badge is hidden. */
+    hidden: boolean;
+    /** Visible badge element. */
+    private _badgeElement;
+    /** Inline badge description. Used when the badge is applied to non-interactive host elements. */
+    private _inlineBadgeDescription;
+    /** Whether the OnInit lifecycle hook has run yet */
+    private _isInitialized;
+    /** InteractivityChecker to determine if the badge host is focusable. */
+    private _interactivityChecker;
+    private _document;
+    constructor(...args: unknown[]);
+    /** Whether the badge is above the host or not */
+    isAbove(): boolean;
+    /** Whether the badge is after the host or not */
+    isAfter(): boolean;
+    /**
+     * Gets the element into which the badge's content is being rendered. Undefined if the element
+     * hasn't been created (e.g. if the badge doesn't have content).
+     */
+    getBadgeElement(): HTMLElement | undefined;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Gets whether the badge's host element is interactive. */
+    private _isHostInteractive;
+    /** Creates the badge element */
+    private _createBadgeElement;
+    /** Update the text content of the badge element in the DOM, creating the element if necessary. */
+    private _updateRenderedContent;
+    /** Updates the host element's aria description via AriaDescriber. */
+    private _updateDescription;
+    private _updateInlineDescription;
+    private _removeInlineDescription;
+    /** Adds css theme class given the color to the component host */
+    private _setColor;
+    /** Clears any existing badges that might be left over from server-side rendering. */
+    private _clearExistingBadges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatBadge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatBadge, "[matBadge]", never, { "color": { "alias": "matBadgeColor"; "required": false; }; "overlap": { "alias": "matBadgeOverlap"; "required": false; }; "disabled": { "alias": "matBadgeDisabled"; "required": false; }; "position": { "alias": "matBadgePosition"; "required": false; }; "content": { "alias": "matBadge"; "required": false; }; "description": { "alias": "matBadgeDescription"; "required": false; }; "size": { "alias": "matBadgeSize"; "required": false; }; "hidden": { "alias": "matBadgeHidden"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_overlap: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_hidden: unknown;
+}
+
+export { MatBadge, _MatBadgeStyleLoader };
+export type { MatBadgePosition, MatBadgeSize };

package/types/_button-toggle-chunk.d.ts

@@ -0,0 +1,252 @@
+import { Direction } from '@angular/cdk/bidi';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, AfterContentInit, QueryList, EventEmitter, AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * @deprecated No longer used.
+ * @breaking-change 11.0.0
+ */
+type ToggleType = 'checkbox' | 'radio';
+/** Possible appearance styles for the button toggle. */
+type MatButtonToggleAppearance = 'legacy' | 'standard';
+/**
+ * Represents the default options for the button toggle that can be configured
+ * using the `MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS` injection token.
+ */
+interface MatButtonToggleDefaultOptions {
+    /**
+     * Default appearance to be used by button toggles. Can be overridden by explicitly
+     * setting an appearance on a button toggle or group.
+     */
+    appearance?: MatButtonToggleAppearance;
+    /** Whether icon indicators should be hidden for single-selection button toggle groups. */
+    hideSingleSelectionIndicator?: boolean;
+    /** Whether icon indicators should be hidden for multiple-selection button toggle groups. */
+    hideMultipleSelectionIndicator?: boolean;
+    /** Whether disabled toggle buttons should be interactive. */
+    disabledInteractive?: boolean;
+}
+/**
+ * Injection token that can be used to configure the
+ * default options for all button toggles within an app.
+ */
+declare const MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS: InjectionToken<MatButtonToggleDefaultOptions>;
+/**
+ * Injection token that can be used to reference instances of `MatButtonToggleGroup`.
+ * It serves as alternative token to the actual `MatButtonToggleGroup` class which
+ * could cause unnecessary retention of the class and its component metadata.
+ */
+declare const MAT_BUTTON_TOGGLE_GROUP: InjectionToken<MatButtonToggleGroup>;
+/**
+ * Provider Expression that allows mat-button-toggle-group to register as a ControlValueAccessor.
+ * This allows it to support [(ngModel)].
+ * @docs-private
+ */
+declare const MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR: any;
+/** Change event object emitted by button toggle. */
+declare class MatButtonToggleChange {
+    /** The button toggle that emits the event. */
+    source: MatButtonToggle;
+    /** The value assigned to the button toggle. */
+    value: any;
+    constructor(
+    /** The button toggle that emits the event. */
+    source: MatButtonToggle, 
+    /** The value assigned to the button toggle. */
+    value: any);
+}
+/** Exclusive selection button toggle group that behaves like a radio-button group. */
+declare class MatButtonToggleGroup implements ControlValueAccessor, OnInit, AfterContentInit {
+    private _changeDetector;
+    private _dir;
+    private _multiple;
+    private _disabled;
+    private _disabledInteractive;
+    private _selectionModel;
+    /**
+     * Reference to the raw value that the consumer tried to assign. The real
+     * value will exclude any values from this one that don't correspond to a
+     * toggle. Useful for the cases where the value is assigned before the toggles
+     * have been initialized or at the same that they're being swapped out.
+     */
+    private _rawValue;
+    /**
+     * The method to be called in order to update ngModel.
+     * Now `ngModel` binding is not supported in multiple selection mode.
+     */
+    _controlValueAccessorChangeFn: (value: any) => void;
+    /** onTouch function registered via registerOnTouch (ControlValueAccessor). */
+    _onTouched: () => any;
+    /** Child button toggle buttons. */
+    _buttonToggles: QueryList<MatButtonToggle>;
+    /** The appearance for all the buttons in the group. */
+    appearance: MatButtonToggleAppearance;
+    /** `name` attribute for the underlying `input` element. */
+    get name(): string;
+    set name(value: string);
+    private _name;
+    /** Whether the toggle group is vertical. */
+    vertical: boolean;
+    /** Value of the toggle group. */
+    get value(): any;
+    set value(newValue: any);
+    /**
+     * Event that emits whenever the value of the group changes.
+     * Used to facilitate two-way data binding.
+     * @docs-private
+     */
+    readonly valueChange: EventEmitter<any>;
+    /** Selected button toggles in the group. */
+    get selected(): MatButtonToggle | MatButtonToggle[];
+    /** Whether multiple button toggles can be selected. */
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    /** Whether multiple button toggle group is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether buttons in the group should be interactive while they're disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    /** The layout direction of the toggle button group. */
+    get dir(): Direction;
+    /** Event emitted when the group's value changes. */
+    readonly change: EventEmitter<MatButtonToggleChange>;
+    /** Whether checkmark indicator for single-selection button toggle groups is hidden. */
+    get hideSingleSelectionIndicator(): boolean;
+    set hideSingleSelectionIndicator(value: boolean);
+    private _hideSingleSelectionIndicator;
+    /** Whether checkmark indicator for multiple-selection button toggle groups is hidden. */
+    get hideMultipleSelectionIndicator(): boolean;
+    set hideMultipleSelectionIndicator(value: boolean);
+    private _hideMultipleSelectionIndicator;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * @param value Value to be set to the model.
+     */
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Handle keydown event calling to single-select button toggle. */
+    protected _keydown(event: KeyboardEvent): void;
+    /** Dispatch change event with current selection and group value. */
+    _emitChangeEvent(toggle: MatButtonToggle): void;
+    /**
+     * Syncs a button toggle's selected state with the model value.
+     * @param toggle Toggle to be synced.
+     * @param select Whether the toggle should be selected.
+     * @param isUserInput Whether the change was a result of a user interaction.
+     * @param deferEvents Whether to defer emitting the change events.
+     */
+    _syncButtonToggle(toggle: MatButtonToggle, select: boolean, isUserInput?: boolean, deferEvents?: boolean): void;
+    /** Checks whether a button toggle is selected. */
+    _isSelected(toggle: MatButtonToggle): boolean;
+    /** Determines whether a button toggle should be checked on init. */
+    _isPrechecked(toggle: MatButtonToggle): boolean;
+    /** Initializes the tabindex attribute using the radio pattern. */
+    private _initializeTabIndex;
+    /** Obtain the subsequent toggle to which the focus shifts. */
+    private _getNextButton;
+    /** Updates the selection state of the toggles in the group based on a value. */
+    private _setSelectionByValue;
+    /** Clears the selected toggles. */
+    private _clearSelection;
+    /** Selects a value if there's a toggle that corresponds to it. */
+    private _selectValue;
+    /** Syncs up the group's value with the model and emits the change event. */
+    private _updateModelValue;
+    /** Marks all of the child button toggles to be checked. */
+    private _markButtonsForCheck;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonToggleGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonToggleGroup, "mat-button-toggle-group", ["matButtonToggleGroup"], { "appearance": { "alias": "appearance"; "required": false; }; "name": { "alias": "name"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "value": { "alias": "value"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; "hideSingleSelectionIndicator": { "alias": "hideSingleSelectionIndicator"; "required": false; }; "hideMultipleSelectionIndicator": { "alias": "hideMultipleSelectionIndicator"; "required": false; }; }, { "valueChange": "valueChange"; "change": "change"; }, ["_buttonToggles"], never, true, never>;
+    static ngAcceptInputType_vertical: unknown;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+    static ngAcceptInputType_hideSingleSelectionIndicator: unknown;
+    static ngAcceptInputType_hideMultipleSelectionIndicator: unknown;
+}
+/** Single button inside of a toggle group. */
+declare class MatButtonToggle implements OnInit, AfterViewInit, OnDestroy {
+    private _changeDetectorRef;
+    private _elementRef;
+    private _focusMonitor;
+    private _idGenerator;
+    private _animationDisabled;
+    private _checked;
+    /**
+     * Attached to the aria-label attribute of the host element. In most cases, aria-labelledby will
+     * take precedence so this may be omitted.
+     */
+    ariaLabel: string;
+    /**
+     * Users can specify the `aria-labelledby` attribute which will be forwarded to the input element
+     */
+    ariaLabelledby: string | null;
+    /** Underlying native `button` element. */
+    _buttonElement: ElementRef<HTMLButtonElement>;
+    /** The parent button toggle group (exclusive selection). Optional. */
+    buttonToggleGroup: MatButtonToggleGroup;
+    /** Unique ID for the underlying `button` element. */
+    get buttonId(): string;
+    /** The unique ID for this button toggle. */
+    id: string;
+    /** HTML's 'name' attribute used to group radios for unique selection. */
+    name: string;
+    /** MatButtonToggleGroup reads this to assign its own value. */
+    value: any;
+    /** Tabindex of the toggle. */
+    get tabIndex(): number | null;
+    set tabIndex(value: number | null);
+    private _tabIndex;
+    /** Whether ripples are disabled on the button toggle. */
+    disableRipple: boolean;
+    /** The appearance style of the button. */
+    get appearance(): MatButtonToggleAppearance;
+    set appearance(value: MatButtonToggleAppearance);
+    private _appearance;
+    /** Whether the button is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    /** Whether the button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Whether the button should remain interactive when it is disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    private _disabledInteractive;
+    /** Event emitted when the group value changes. */
+    readonly change: EventEmitter<MatButtonToggleChange>;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Focuses the button. */
+    focus(options?: FocusOptions): void;
+    /** Checks the button toggle due to an interaction with the underlying native button. */
+    _onButtonClick(): void;
+    /**
+     * Marks the button toggle as needing checking for change detection.
+     * This method is exposed because the parent button toggle group will directly
+     * update bound properties of the radio button.
+     */
+    _markForCheck(): void;
+    /** Gets the name that should be assigned to the inner DOM node. */
+    _getButtonName(): string | null;
+    /** Whether the toggle is in single selection mode. */
+    isSingleSelector(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatButtonToggle, "mat-button-toggle", ["matButtonToggle"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disableRipple: unknown;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+
+export { MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS, MAT_BUTTON_TOGGLE_GROUP, MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR, MatButtonToggle, MatButtonToggleChange, MatButtonToggleGroup };
+export type { MatButtonToggleAppearance, MatButtonToggleDefaultOptions, ToggleType };