@depup/angular__material 21.2.2-depup.19

package/types/progress-bar.d.ts

@@ -0,0 +1,106 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, OnDestroy, ElementRef, EventEmitter } from '@angular/core';
+import { ThemePalette } from './_palette-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+
+/** Last animation end data. */
+interface ProgressAnimationEnd {
+    value: number;
+}
+/** Default `mat-progress-bar` options that can be overridden. */
+interface MatProgressBarDefaultOptions {
+    /**
+     * Default theme color of the progress bar. 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/progress-bar/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
+     */
+    color?: ThemePalette;
+    /** Default mode of the progress bar. */
+    mode?: ProgressBarMode;
+}
+/** Injection token to be used to override the default options for `mat-progress-bar`. */
+declare const MAT_PROGRESS_BAR_DEFAULT_OPTIONS: InjectionToken<MatProgressBarDefaultOptions>;
+/**
+ * Injection token used to provide the current location to `MatProgressBar`.
+ * Used to handle server-side rendering and to stub out during unit tests.
+ * @docs-private
+ */
+declare const MAT_PROGRESS_BAR_LOCATION: InjectionToken<MatProgressBarLocation>;
+/**
+ * Stubbed out location for `MatProgressBar`.
+ * @docs-private
+ */
+interface MatProgressBarLocation {
+    getPathname: () => string;
+}
+type ProgressBarMode = 'determinate' | 'indeterminate' | 'buffer' | 'query';
+declare class MatProgressBar implements AfterViewInit, OnDestroy {
+    readonly _elementRef: ElementRef<HTMLElement>;
+    private _ngZone;
+    private _changeDetectorRef;
+    private _renderer;
+    private _cleanupTransitionEnd;
+    constructor(...args: unknown[]);
+    /** Flag that indicates whether NoopAnimations mode is set to true. */
+    _isNoopAnimation: boolean;
+    /**
+     * Theme color of the progress bar. 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/progress-bar/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(): string | null | undefined;
+    set color(value: string | null | undefined);
+    private _color;
+    private _defaultColor;
+    /** Value of the progress bar. Defaults to zero. Mirrored to aria-valuenow. */
+    get value(): number;
+    set value(v: number);
+    private _value;
+    /** Buffer value of the progress bar. Defaults to zero. */
+    get bufferValue(): number;
+    set bufferValue(v: number);
+    private _bufferValue;
+    /**
+     * Event emitted when animation of the primary progress bar completes. This event will not
+     * be emitted when animations are disabled, nor will it be emitted for modes with continuous
+     * animations (indeterminate and query).
+     */
+    readonly animationEnd: EventEmitter<ProgressAnimationEnd>;
+    /**
+     * Mode of the progress bar.
+     *
+     * Input must be one of these values: determinate, indeterminate, buffer, query, defaults to
+     * 'determinate'.
+     * Mirrored to mode attribute.
+     */
+    get mode(): ProgressBarMode;
+    set mode(value: ProgressBarMode);
+    private _mode;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Gets the transform style that should be applied to the primary bar. */
+    _getPrimaryBarTransform(): string;
+    /** Gets the `flex-basis` value that should be applied to the buffer bar. */
+    _getBufferBarFlexBasis(): string;
+    /** Returns whether the progress bar is indeterminate. */
+    _isIndeterminate(): boolean;
+    /** Event handler for `transitionend` events. */
+    private _transitionendHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatProgressBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatProgressBar, "mat-progress-bar", ["matProgressBar"], { "color": { "alias": "color"; "required": false; }; "value": { "alias": "value"; "required": false; }; "bufferValue": { "alias": "bufferValue"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, { "animationEnd": "animationEnd"; }, never, never, true, never>;
+    static ngAcceptInputType_value: unknown;
+    static ngAcceptInputType_bufferValue: unknown;
+}
+
+declare class MatProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatProgressBarModule, never, [typeof MatProgressBar], [typeof MatProgressBar, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatProgressBarModule>;
+}
+
+export { MAT_PROGRESS_BAR_DEFAULT_OPTIONS, MAT_PROGRESS_BAR_LOCATION, MatProgressBar, MatProgressBarModule };
+export type { MatProgressBarDefaultOptions, MatProgressBarLocation, ProgressAnimationEnd, ProgressBarMode };

package/types/progress-spinner-testing.d.ts

@@ -0,0 +1,28 @@
+import { BaseHarnessFilters, ComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+import { ProgressSpinnerMode } from './_progress-spinner-chunk.js';
+import '@angular/core';
+import './_palette-chunk.js';
+
+/** A set of criteria that can be used to filter a list of `MatProgressSpinnerHarness` instances. */
+interface ProgressSpinnerHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Harness for interacting with a MDC based mat-progress-spinner in tests. */
+declare class MatProgressSpinnerHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatProgressSpinner` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a progress spinnner with specific
+     * attributes.
+     * @param options Options for filtering which progress spinner instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatProgressSpinnerHarness>(this: ComponentHarnessConstructor<T>, options?: ProgressSpinnerHarnessFilters): HarnessPredicate<T>;
+    /** Gets the progress spinner's value. */
+    getValue(): Promise<number | null>;
+    /** Gets the progress spinner's mode. */
+    getMode(): Promise<ProgressSpinnerMode>;
+}
+
+export { MatProgressSpinnerHarness };
+export type { ProgressSpinnerHarnessFilters };

package/types/progress-spinner.d.ts

@@ -0,0 +1,13 @@
+import { MatProgressSpinner } from './_progress-spinner-chunk.js';
+export { MAT_PROGRESS_SPINNER_DEFAULT_OPTIONS, MatProgressSpinnerDefaultOptions, MatSpinner, ProgressSpinnerMode } from './_progress-spinner-chunk.js';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/cdk/bidi';
+import './_palette-chunk.js';
+
+declare class MatProgressSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatProgressSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatProgressSpinnerModule, never, [typeof MatProgressSpinner, typeof MatProgressSpinner], [typeof MatProgressSpinner, typeof MatProgressSpinner, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatProgressSpinnerModule>;
+}
+
+export { MatProgressSpinner, MatProgressSpinnerModule };

package/types/radio-testing.d.ts

@@ -0,0 +1,109 @@
+import * as _angular_cdk_testing from '@angular/cdk/testing';
+import { BaseHarnessFilters, ComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of `MatRadioGroupHarness` instances. */
+interface RadioGroupHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose name attribute is the given value. */
+    name?: string;
+}
+/** A set of criteria that can be used to filter a list of `MatRadioButtonHarness` instances. */
+interface RadioButtonHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose label matches the given value. */
+    label?: string | RegExp;
+    /** Only find instances whose name attribute is the given value. */
+    name?: string;
+    /** Only find instances with the given checked value. */
+    checked?: boolean;
+}
+
+/** Harness for interacting with a mat-radio-group in tests. */
+declare class MatRadioGroupHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatRadioGroup` instance. */
+    static hostSelector: string;
+    private _buttonClass;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a radio group with specific
+     * attributes.
+     * @param options Options for filtering which radio group instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatRadioGroupHarness>(this: ComponentHarnessConstructor<T>, options?: RadioGroupHarnessFilters): HarnessPredicate<T>;
+    /** Gets the name of the radio-group. */
+    getName(): Promise<string | null>;
+    /** Gets the id of the radio-group. */
+    getId(): Promise<string | null>;
+    /** Gets the checked radio-button in a radio-group. */
+    getCheckedRadioButton(): Promise<MatRadioButtonHarness | null>;
+    /** Gets the checked value of the radio-group. */
+    getCheckedValue(): Promise<string | null>;
+    /**
+     * Gets a list of radio buttons which are part of the radio-group.
+     * @param filter Optionally filters which radio buttons are included.
+     */
+    getRadioButtons(filter?: RadioButtonHarnessFilters): Promise<MatRadioButtonHarness[]>;
+    /**
+     * Checks a radio button in this group.
+     * @param filter An optional filter to apply to the child radio buttons. The first tab matching
+     *     the filter will be selected.
+     */
+    checkRadioButton(filter?: RadioButtonHarnessFilters): Promise<void>;
+    /** Gets the name attribute of the host element. */
+    private _getGroupNameFromHost;
+    /** Gets a list of the name attributes of all child radio buttons. */
+    private _getNamesFromRadioButtons;
+    /** Checks if the specified radio names are all equal. */
+    private _checkRadioNamesInGroupEqual;
+    /**
+     * Checks if a radio-group harness has the given name. Throws if a radio-group with
+     * matching name could be found but has mismatching radio-button names.
+     */
+    protected static _checkRadioGroupName(harness: MatRadioGroupHarness, name: string): Promise<boolean>;
+}
+/** Harness for interacting with a mat-radio-button in tests. */
+declare class MatRadioButtonHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatRadioButton` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a radio button with specific
+     * attributes.
+     * @param options Options for filtering which radio button instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatRadioButtonHarness>(this: ComponentHarnessConstructor<T>, options?: RadioButtonHarnessFilters): HarnessPredicate<T>;
+    protected _textLabel: () => Promise<_angular_cdk_testing.TestElement>;
+    protected _clickLabel: () => Promise<_angular_cdk_testing.TestElement>;
+    private _input;
+    /** Whether the radio-button is checked. */
+    isChecked(): Promise<boolean>;
+    /** Whether the radio-button is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the radio-button is required. */
+    isRequired(): Promise<boolean>;
+    /** Gets the radio-button's name. */
+    getName(): Promise<string | null>;
+    /** Gets the radio-button's id. */
+    getId(): Promise<string | null>;
+    /**
+     * Gets the value of the radio-button. The radio-button value will be converted to a string.
+     *
+     * Note: This means that for radio-button's with an object as a value `[object Object]` is
+     * intentionally returned.
+     */
+    getValue(): Promise<string | null>;
+    /** Gets the radio-button's label text. */
+    getLabelText(): Promise<string>;
+    /** Focuses the radio-button. */
+    focus(): Promise<void>;
+    /** Blurs the radio-button. */
+    blur(): Promise<void>;
+    /** Whether the radio-button is focused. */
+    isFocused(): Promise<boolean>;
+    /**
+     * Puts the radio-button in a checked state by clicking it if it is currently unchecked,
+     * or doing nothing if it is already checked.
+     */
+    check(): Promise<void>;
+}
+
+export { MatRadioButtonHarness, MatRadioGroupHarness };
+export type { RadioButtonHarnessFilters, RadioGroupHarnessFilters };

package/types/radio.d.ts

@@ -0,0 +1,295 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterContentInit, OnDestroy, EventEmitter, QueryList, OnInit, AfterViewInit, DoCheck, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ThemePalette } from './_palette-chunk.js';
+import { MatRippleModule } from './_ripple-module-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+import './_ripple-chunk.js';
+import '@angular/cdk/platform';
+
+/** Change event object emitted by radio button and radio group. */
+declare class MatRadioChange<T = any> {
+    /** The radio button that emits the change event. */
+    source: MatRadioButton;
+    /** The value of the radio button. */
+    value: T;
+    constructor(
+    /** The radio button that emits the change event. */
+    source: MatRadioButton, 
+    /** The value of the radio button. */
+    value: T);
+}
+/**
+ * Provider Expression that allows mat-radio-group to register as a ControlValueAccessor. This
+ * allows it to support [(ngModel)] and ngControl.
+ * @docs-private
+ */
+declare const MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR: any;
+/**
+ * Injection token that can be used to inject instances of `MatRadioGroup`. It serves as
+ * alternative token to the actual `MatRadioGroup` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const MAT_RADIO_GROUP: InjectionToken<MatRadioGroup>;
+interface MatRadioDefaultOptions {
+    /**
+     * Theme color of the radio button. 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/radio/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
+     */
+    color: ThemePalette;
+    /** Whether disabled radio buttons should be interactive. */
+    disabledInteractive?: boolean;
+}
+declare const MAT_RADIO_DEFAULT_OPTIONS: InjectionToken<MatRadioDefaultOptions>;
+/**
+ * A group of radio buttons. May contain one or more `<mat-radio-button>` elements.
+ */
+declare class MatRadioGroup implements AfterContentInit, OnDestroy, ControlValueAccessor {
+    private _changeDetector;
+    /** Selected value for the radio group. */
+    private _value;
+    /** The HTML name attribute applied to radio buttons in this group. */
+    private _name;
+    /** The currently selected radio button. Should match value. */
+    private _selected;
+    /** Whether the `value` has been set to its initial value. */
+    private _isInitialized;
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    private _labelPosition;
+    /** Whether the radio group is disabled. */
+    private _disabled;
+    /** Whether the radio group is required. */
+    private _required;
+    /** Subscription to changes in amount of radio buttons. */
+    private _buttonChanges;
+    /** The method to be called in order to update ngModel */
+    _controlValueAccessorChangeFn: (value: any) => void;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     * @docs-private
+     */
+    onTouched: () => any;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * a radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: EventEmitter<MatRadioChange>;
+    /** Child radio buttons. */
+    _radios: QueryList<MatRadioButton>;
+    /**
+     * Theme color of the radio buttons in the group. 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/radio/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
+     */
+    color: ThemePalette;
+    /** Name of the radio button group. All radio buttons inside this group will use this name. */
+    get name(): string;
+    set name(value: string);
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    set labelPosition(v: "before" | "after");
+    /**
+     * Value for the radio-group. Should equal the value of the selected radio button if there is
+     * a corresponding radio button with a matching value. If there is not such a corresponding
+     * radio button, this value persists to be applied in case a new radio button is added with a
+     * matching value.
+     */
+    get value(): any;
+    set value(newValue: any);
+    _checkSelectedRadioButton(): void;
+    /**
+     * The currently selected radio button. If set to a new radio button, the radio group value
+     * will be updated to match the new selected button.
+     */
+    get selected(): MatRadioButton | null;
+    set selected(selected: MatRadioButton | null);
+    /** Whether the radio group is disabled */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether the radio group is required */
+    get required(): boolean;
+    set required(value: boolean);
+    /** Whether buttons in the group should be interactive while they're disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    private _disabledInteractive;
+    constructor(...args: unknown[]);
+    /**
+     * Initialize properties once content children are available.
+     * This allows us to propagate relevant attributes to associated buttons.
+     */
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Mark this group as being "touched" (for ngModel). Meant to be called by the contained
+     * radio buttons upon their blur.
+     */
+    _touch(): void;
+    private _updateRadioButtonNames;
+    /** Updates the `selected` radio button from the internal _value state. */
+    private _updateSelectedRadioFromValue;
+    /** Dispatch change event with current selection and group value. */
+    _emitChangeEvent(): void;
+    _markRadiosForCheck(): void;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * @param value
+     */
+    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: any) => void): 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: any): 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRadioGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatRadioGroup, "mat-radio-group", ["matRadioGroup"], { "color": { "alias": "color"; "required": false; }; "name": { "alias": "name"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, { "change": "change"; }, ["_radios"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+declare class MatRadioButton implements OnInit, AfterViewInit, DoCheck, OnDestroy {
+    protected _elementRef: ElementRef<any>;
+    private _changeDetector;
+    private _focusMonitor;
+    private _radioDispatcher;
+    private _defaultOptions;
+    private _ngZone;
+    private _renderer;
+    private _uniqueId;
+    private _cleanupClick;
+    /** The unique ID for the radio button. */
+    id: string;
+    /** Analog to HTML 'name' attribute used to group radios for unique selection. */
+    name: string;
+    /** Used to set the 'aria-label' attribute on the underlying input element. */
+    ariaLabel: string | null;
+    /** The 'aria-labelledby' attribute takes precedence as the element's text alternative. */
+    ariaLabelledby: string | null;
+    /** The 'aria-describedby' attribute is read after the element's label and field type. */
+    ariaDescribedby: string | null;
+    /** Whether ripples are disabled inside the radio button */
+    disableRipple: boolean;
+    /** Tabindex of the radio button. */
+    tabIndex: number;
+    /** Whether this radio button is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    /** The value of this radio button. */
+    get value(): any;
+    set value(value: any);
+    /** Whether the label should appear after or before the radio button. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    set labelPosition(value: "before" | "after");
+    private _labelPosition;
+    /** Whether the radio button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether the radio button is required. */
+    get required(): boolean;
+    set required(value: boolean);
+    /**
+     * Theme color of the radio button. 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/radio/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(newValue: ThemePalette);
+    private _color;
+    /** Whether the radio button should remain interactive when it is disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    private _disabledInteractive;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * the radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: EventEmitter<MatRadioChange>;
+    /** The parent radio group. May or may not be present. */
+    radioGroup: MatRadioGroup;
+    /** ID of the native input element inside `<mat-radio-button>` */
+    get inputId(): string;
+    /** Whether this radio is checked. */
+    private _checked;
+    /** Whether this radio is disabled. */
+    private _disabled;
+    /** Whether this radio is required. */
+    private _required;
+    /** Value assigned to this radio. */
+    private _value;
+    /** Unregister function for _radioDispatcher */
+    private _removeUniqueSelectionListener;
+    /** Previous value of the input's tabindex. */
+    private _previousTabIndex;
+    /** The native `<input type=radio>` element */
+    _inputElement: ElementRef<HTMLInputElement>;
+    /** Trigger elements for the ripple events. */
+    _rippleTrigger: ElementRef<HTMLElement>;
+    /** Whether animations are disabled. */
+    _noopAnimations: boolean;
+    private _injector;
+    constructor(...args: unknown[]);
+    /** Focuses the radio button. */
+    focus(options?: FocusOptions, origin?: FocusOrigin): void;
+    /**
+     * Marks the radio button as needing checking for change detection.
+     * This method is exposed because the parent radio group will directly
+     * update bound properties of the radio button.
+     */
+    _markForCheck(): void;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Dispatch change event with current value. */
+    private _emitChangeEvent;
+    _isRippleDisabled(): boolean;
+    /** Triggered when the radio button receives an interaction from the user. */
+    _onInputInteraction(event: Event): void;
+    /** Triggered when the user clicks on the touch target. */
+    _onTouchTargetClick(event: Event): void;
+    /** Sets the disabled state and marks for check if a change occurred. */
+    protected _setDisabled(value: boolean): void;
+    /** Called when the input is clicked. */
+    private _onInputClick;
+    /** Gets the tabindex for the underlying input element. */
+    private _updateTabIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRadioButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatRadioButton, "mat-radio-button", ["matRadioButton"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "color": { "alias": "color"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disableRipple: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+
+declare class MatRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatRadioModule, never, [typeof MatRippleModule, typeof MatRadioGroup, typeof MatRadioButton], [typeof i2.BidiModule, typeof MatRadioGroup, typeof MatRadioButton]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatRadioModule>;
+}
+
+export { MAT_RADIO_DEFAULT_OPTIONS, MAT_RADIO_GROUP, MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR, MatRadioButton, MatRadioChange, MatRadioGroup, MatRadioModule };
+export type { MatRadioDefaultOptions };

package/types/select-testing.d.ts

@@ -0,0 +1,63 @@
+import { ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+import { OptionHarnessFilters, MatOptionHarness, OptgroupHarnessFilters, MatOptgroupHarness } from '@angular/material/core/testing';
+import { MatFormFieldControlHarnessFilters, MatFormFieldControlHarnessBase } from '@angular/material/form-field/testing/control';
+
+/** A set of criteria that can be used to filter a list of `MatSelectHarness` instances. */
+interface SelectHarnessFilters extends MatFormFieldControlHarnessFilters {
+    /** Only find instances which match the given disabled state. */
+    disabled?: boolean;
+}
+
+/** Harness for interacting with a mat-select in tests. */
+declare class MatSelectHarness extends MatFormFieldControlHarnessBase {
+    static hostSelector: string;
+    private _prefix;
+    private _optionClass;
+    private _optionGroupClass;
+    private _documentRootLocator;
+    private _backdrop;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a select with specific attributes.
+     * @param options Options for filtering which select instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatSelectHarness>(this: ComponentHarnessConstructor<T>, options?: SelectHarnessFilters): HarnessPredicate<T>;
+    /** Gets a boolean promise indicating if the select is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets a boolean promise indicating if the select is valid. */
+    isValid(): Promise<boolean>;
+    /** Gets a boolean promise indicating if the select is required. */
+    isRequired(): Promise<boolean>;
+    /** Gets a boolean promise indicating if the select is empty (no value is selected). */
+    isEmpty(): Promise<boolean>;
+    /** Gets a boolean promise indicating if the select is in multi-selection mode. */
+    isMultiple(): Promise<boolean>;
+    /** Gets a promise for the select's value text. */
+    getValueText(): Promise<string>;
+    /** Focuses the select and returns a void promise that indicates when the action is complete. */
+    focus(): Promise<void>;
+    /** Blurs the select and returns a void promise that indicates when the action is complete. */
+    blur(): Promise<void>;
+    /** Whether the select is focused. */
+    isFocused(): Promise<boolean>;
+    /** Gets the options inside the select panel. */
+    getOptions(filter?: Omit<OptionHarnessFilters, 'ancestor'>): Promise<MatOptionHarness[]>;
+    /** Gets the groups of options inside the panel. */
+    getOptionGroups(filter?: Omit<OptgroupHarnessFilters, 'ancestor'>): Promise<MatOptgroupHarness[]>;
+    /** Gets whether the select is open. */
+    isOpen(): Promise<boolean>;
+    /** Opens the select's panel. */
+    open(): Promise<void>;
+    /**
+     * Clicks the options that match the passed-in filter. If the select is in multi-selection
+     * mode all options will be clicked, otherwise the harness will pick the first matching option.
+     */
+    clickOptions(filter?: OptionHarnessFilters): Promise<void>;
+    /** Closes the select's panel. */
+    close(): Promise<void>;
+    /** Gets the selector that should be used to find this select's panel. */
+    private _getPanelSelector;
+}
+
+export { MatSelectHarness };
+export type { SelectHarnessFilters };