@depup/angular__material 21.2.2-depup.19

package/types/sidenav.d.ts

@@ -0,0 +1,335 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterContentInit, AfterViewInit, OnDestroy, EventEmitter, ElementRef, DoCheck, QueryList } from '@angular/core';
+import * as i1 from '@angular/cdk/scrolling';
+import { CdkScrollable } from '@angular/cdk/scrolling';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { Subject, Observable } from 'rxjs';
+import * as i2 from '@angular/cdk/bidi';
+
+/**
+ * Throws an exception when two MatDrawer are matching the same position.
+ * @docs-private
+ */
+declare function throwMatDuplicatedDrawerError(position: string): void;
+/** Options for where to set focus to automatically on dialog open */
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Result of the toggle promise that indicates the state of the drawer. */
+type MatDrawerToggleResult = 'open' | 'close';
+/** Drawer and SideNav display modes. */
+type MatDrawerMode = 'over' | 'push' | 'side';
+/** Configures whether drawers should use auto sizing by default. */
+declare const MAT_DRAWER_DEFAULT_AUTOSIZE: InjectionToken<boolean>;
+declare class MatDrawerContent extends CdkScrollable implements AfterContentInit {
+    private _platform;
+    private _changeDetectorRef;
+    _container: MatDrawerContainer;
+    constructor(...args: unknown[]);
+    ngAfterContentInit(): void;
+    /** Determines whether the content element should be hidden from the user. */
+    protected _shouldBeHidden(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDrawerContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatDrawerContent, "mat-drawer-content", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * This component corresponds to a drawer that can be opened on the drawer container.
+ */
+declare class MatDrawer implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _focusTrapFactory;
+    private _focusMonitor;
+    private _platform;
+    private _ngZone;
+    private _renderer;
+    private readonly _interactivityChecker;
+    private _doc;
+    _container?: MatDrawerContainer | null | undefined;
+    private _focusTrap;
+    private _elementFocusedBeforeDrawerWasOpened;
+    private _eventCleanups;
+    /** Whether the view of the component has been attached. */
+    private _isAttached;
+    /** Anchor node used to restore the drawer to its initial position. */
+    private _anchor;
+    /** The side that the drawer is attached to. */
+    get position(): 'start' | 'end';
+    set position(value: 'start' | 'end');
+    private _position;
+    /** Mode of the drawer; one of 'over', 'push' or 'side'. */
+    get mode(): MatDrawerMode;
+    set mode(value: MatDrawerMode);
+    private _mode;
+    /** Whether the drawer can be closed with the escape key or by clicking on the backdrop. */
+    get disableClose(): boolean;
+    set disableClose(value: BooleanInput);
+    private _disableClose;
+    /**
+     * Whether the drawer should focus the first focusable element automatically when opened.
+     * Defaults to false in when `mode` is set to `side`, otherwise defaults to `true`. If explicitly
+     * enabled, focus will be moved into the sidenav in `side` mode as well.
+     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or AutoFocusTarget
+     * instead.
+     */
+    get autoFocus(): AutoFocusTarget | string | boolean;
+    set autoFocus(value: AutoFocusTarget | string | BooleanInput);
+    private _autoFocus;
+    /**
+     * Whether the drawer is opened. We overload this because we trigger an event when it
+     * starts or end.
+     */
+    get opened(): boolean;
+    set opened(value: BooleanInput);
+    private _opened;
+    /** How the sidenav was opened (keypress, mouse click etc.) */
+    private _openedVia;
+    /** Emits whenever the drawer has started animating. */
+    readonly _animationStarted: Subject<unknown>;
+    /** Emits whenever the drawer is done animating. */
+    readonly _animationEnd: Subject<unknown>;
+    /** Event emitted when the drawer open state is changed. */
+    readonly openedChange: EventEmitter<boolean>;
+    /** Event emitted when the drawer has been opened. */
+    readonly _openedStream: Observable<void>;
+    /** Event emitted when the drawer has started opening. */
+    readonly openedStart: Observable<void>;
+    /** Event emitted when the drawer has been closed. */
+    readonly _closedStream: Observable<void>;
+    /** Event emitted when the drawer has started closing. */
+    readonly closedStart: Observable<void>;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    /** Event emitted when the drawer's position changes. */
+    readonly onPositionChanged: EventEmitter<void>;
+    /** Reference to the inner element that contains all the content. */
+    _content: ElementRef<HTMLElement>;
+    /**
+     * An observable that emits when the drawer mode changes. This is used by the drawer container to
+     * to know when to when the mode changes so it can adapt the margins on the content.
+     */
+    readonly _modeChanged: Subject<void>;
+    private _injector;
+    private _changeDetectorRef;
+    constructor(...args: unknown[]);
+    /**
+     * Focuses the provided element. If the element is not focusable, it will add a tabIndex
+     * attribute to forcefully focus it. The attribute is removed after focus is moved.
+     * @param element The element to focus.
+     */
+    private _forceFocus;
+    /**
+     * Focuses the first element that matches the given selector within the focus trap.
+     * @param selector The CSS selector for the element to set focus to.
+     */
+    private _focusByCssSelector;
+    /**
+     * Moves focus into the drawer. Note that this works even if
+     * the focus trap is disabled in `side` mode.
+     */
+    private _takeFocus;
+    /**
+     * Restores focus to the element that was originally focused when the drawer opened.
+     * If no element was focused at that time, the focus will be restored to the drawer.
+     */
+    private _restoreFocus;
+    /** Whether focus is currently within the drawer. */
+    private _isFocusWithinDrawer;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Open the drawer.
+     * @param openedVia Whether the drawer was opened by a key press, mouse click or programmatically.
+     * Used for focus management after the sidenav is closed.
+     */
+    open(openedVia?: FocusOrigin): Promise<MatDrawerToggleResult>;
+    /** Close the drawer. */
+    close(): Promise<MatDrawerToggleResult>;
+    /** Closes the drawer with context that the backdrop was clicked. */
+    _closeViaBackdropClick(): Promise<MatDrawerToggleResult>;
+    /**
+     * Toggle this drawer.
+     * @param isOpen Whether the drawer should be open.
+     * @param openedVia Whether the drawer was opened by a key press, mouse click or programmatically.
+     * Used for focus management after the sidenav is closed.
+     */
+    toggle(isOpen?: boolean, openedVia?: FocusOrigin): Promise<MatDrawerToggleResult>;
+    /**
+     * Toggles the opened state of the drawer.
+     * @param isOpen Whether the drawer should open or close.
+     * @param restoreFocus Whether focus should be restored on close.
+     * @param focusOrigin Origin to use when restoring focus.
+     */
+    private _setOpen;
+    /** Toggles whether the drawer is currently animating. */
+    private _setIsAnimating;
+    _getWidth(): number;
+    /** Updates the enabled state of the focus trap. */
+    private _updateFocusTrapState;
+    /**
+     * Updates the position of the drawer in the DOM. We need to move the element around ourselves
+     * when it's in the `end` position so that it comes after the content and the visual order
+     * matches the tab order. We also need to be able to move it back to `start` if the sidenav
+     * started off as `end` and was changed to `start`.
+     */
+    private _updatePositionInParent;
+    /** Event handler for animation events. */
+    private _handleTransitionEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDrawer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatDrawer, "mat-drawer", ["matDrawer"], { "position": { "alias": "position"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "disableClose": { "alias": "disableClose"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; }, { "openedChange": "openedChange"; "_openedStream": "opened"; "openedStart": "openedStart"; "_closedStream": "closed"; "closedStart": "closedStart"; "onPositionChanged": "positionChanged"; }, never, ["*"], true, never>;
+}
+/**
+ * `<mat-drawer-container>` component.
+ *
+ * This is the parent component to one or two `<mat-drawer>`s that validates the state internally
+ * and coordinates the backdrop and content styling.
+ */
+declare class MatDrawerContainer implements AfterContentInit, DoCheck, OnDestroy {
+    private _dir;
+    private _element;
+    private _ngZone;
+    private _changeDetectorRef;
+    private _animationDisabled;
+    _transitionsEnabled: boolean;
+    /** All drawers in the container. Includes drawers from inside nested containers. */
+    _allDrawers: QueryList<MatDrawer>;
+    /** Drawers that belong to this container. */
+    _drawers: QueryList<MatDrawer>;
+    _content: MatDrawerContent;
+    _userContent: MatDrawerContent;
+    /** The drawer child with the `start` position. */
+    get start(): MatDrawer | null;
+    /** The drawer child with the `end` position. */
+    get end(): MatDrawer | null;
+    /**
+     * Whether to automatically resize the container whenever
+     * the size of any of its drawers changes.
+     *
+     * **Use at your own risk!** Enabling this option can cause layout thrashing by measuring
+     * the drawers on every change detection cycle. Can be configured globally via the
+     * `MAT_DRAWER_DEFAULT_AUTOSIZE` token.
+     */
+    get autosize(): boolean;
+    set autosize(value: BooleanInput);
+    private _autosize;
+    /**
+     * Whether the drawer container should have a backdrop while one of the sidenavs is open.
+     * If explicitly set to `true`, the backdrop will be enabled for drawers in the `side`
+     * mode as well.
+     */
+    get hasBackdrop(): boolean;
+    set hasBackdrop(value: BooleanInput);
+    _backdropOverride: boolean | null;
+    /** Event emitted when the drawer backdrop is clicked. */
+    readonly backdropClick: EventEmitter<void>;
+    /** The drawer at the start/end position, independent of direction. */
+    private _start;
+    private _end;
+    /**
+     * The drawer at the left/right. When direction changes, these will change as well.
+     * They're used as aliases for the above to set the left/right style properly.
+     * In LTR, _left == _start and _right == _end.
+     * In RTL, _left == _end and _right == _start.
+     */
+    private _left;
+    private _right;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    /** Emits on every ngDoCheck. Used for debouncing reflows. */
+    private readonly _doCheckSubject;
+    /**
+     * Margins to be applied to the content. These are used to push / shrink the drawer content when a
+     * drawer is open. We use margin rather than transform even for push mode because transform breaks
+     * fixed position elements inside of the transformed element.
+     */
+    _contentMargins: {
+        left: number | null;
+        right: number | null;
+    };
+    readonly _contentMarginChanges: Subject<{
+        left: number | null;
+        right: number | null;
+    }>;
+    /** Reference to the CdkScrollable instance that wraps the scrollable content. */
+    get scrollable(): CdkScrollable;
+    private _injector;
+    constructor(...args: unknown[]);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Calls `open` of both start and end drawers */
+    open(): void;
+    /** Calls `close` of both start and end drawers */
+    close(): void;
+    /**
+     * Recalculates and updates the inline styles for the content. Note that this should be used
+     * sparingly, because it causes a reflow.
+     */
+    updateContentMargins(): void;
+    ngDoCheck(): void;
+    /**
+     * Subscribes to drawer events in order to set a class on the main container element when the
+     * drawer is open and the backdrop is visible. This ensures any overflow on the container element
+     * is properly hidden.
+     */
+    private _watchDrawerToggle;
+    /**
+     * Subscribes to drawer onPositionChanged event in order to
+     * re-validate drawers when the position changes.
+     */
+    private _watchDrawerPosition;
+    /** Subscribes to changes in drawer mode so we can run change detection. */
+    private _watchDrawerMode;
+    /** Toggles the 'mat-drawer-opened' class on the main 'mat-drawer-container' element. */
+    private _setContainerClass;
+    /** Validate the state of the drawer children components. */
+    private _validateDrawers;
+    /** Whether the container is being pushed to the side by one of the drawers. */
+    private _isPushed;
+    _onBackdropClicked(): void;
+    _closeModalDrawersViaBackdrop(): void;
+    _isShowingBackdrop(): boolean;
+    private _isDrawerOpen;
+    private _drawerHasBackdrop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDrawerContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatDrawerContainer, "mat-drawer-container", ["matDrawerContainer"], { "autosize": { "alias": "autosize"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; }, { "backdropClick": "backdropClick"; }, ["_content", "_allDrawers"], ["mat-drawer", "mat-drawer-content", "*"], true, never>;
+}
+
+declare class MatSidenavContent extends MatDrawerContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSidenavContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSidenavContent, "mat-sidenav-content", never, {}, {}, never, ["*"], true, never>;
+}
+declare class MatSidenav extends MatDrawer {
+    /** Whether the sidenav is fixed in the viewport. */
+    get fixedInViewport(): boolean;
+    set fixedInViewport(value: BooleanInput);
+    private _fixedInViewport;
+    /**
+     * The gap between the top of the sidenav and the top of the viewport when the sidenav is in fixed
+     * mode.
+     */
+    get fixedTopGap(): number;
+    set fixedTopGap(value: NumberInput);
+    private _fixedTopGap;
+    /**
+     * The gap between the bottom of the sidenav and the bottom of the viewport when the sidenav is in
+     * fixed mode.
+     */
+    get fixedBottomGap(): number;
+    set fixedBottomGap(value: NumberInput);
+    private _fixedBottomGap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSidenav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSidenav, "mat-sidenav", ["matSidenav"], { "fixedInViewport": { "alias": "fixedInViewport"; "required": false; }; "fixedTopGap": { "alias": "fixedTopGap"; "required": false; }; "fixedBottomGap": { "alias": "fixedBottomGap"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+declare class MatSidenavContainer extends MatDrawerContainer {
+    _allDrawers: QueryList<MatSidenav>;
+    _content: MatSidenavContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSidenavContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSidenavContainer, "mat-sidenav-container", ["matSidenavContainer"], {}, {}, ["_content", "_allDrawers"], ["mat-sidenav", "mat-sidenav-content", "*"], true, never>;
+}
+
+declare class MatSidenavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSidenavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSidenavModule, never, [typeof i1.CdkScrollableModule, typeof MatDrawer, typeof MatDrawerContainer, typeof MatDrawerContent, typeof MatSidenav, typeof MatSidenavContainer, typeof MatSidenavContent], [typeof i2.BidiModule, typeof i1.CdkScrollableModule, typeof MatDrawer, typeof MatDrawerContainer, typeof MatDrawerContent, typeof MatSidenav, typeof MatSidenavContainer, typeof MatSidenavContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatSidenavModule>;
+}
+
+export { MAT_DRAWER_DEFAULT_AUTOSIZE, MatDrawer, MatDrawerContainer, MatDrawerContent, MatSidenav, MatSidenavContainer, MatSidenavContent, MatSidenavModule, throwMatDuplicatedDrawerError };
+export type { MatDrawerMode, MatDrawerToggleResult };

package/types/slide-toggle-testing.d.ts

@@ -0,0 +1,66 @@
+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 `MatSlideToggleHarness` instances. */
+interface SlideToggleHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose label matches the given value. */
+    label?: string | RegExp;
+    /** Only find instances whose name is the given value. */
+    name?: string;
+    /** Only find instances with the given checked value. */
+    checked?: boolean;
+    /** Only find instances where the disabled state matches the given value. */
+    disabled?: boolean;
+}
+
+/** Harness for interacting with a mat-slide-toggle in tests. */
+declare class MatSlideToggleHarness extends ComponentHarness {
+    private _label;
+    _nativeElement: () => Promise<_angular_cdk_testing.TestElement>;
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a slide-toggle w/ specific attributes.
+     * @param options Options for narrowing the search:
+     *   - `selector` finds a slide-toggle whose host element matches the given selector.
+     *   - `label` finds a slide-toggle with specific label text.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatSlideToggleHarness>(this: ComponentHarnessConstructor<T>, options?: SlideToggleHarnessFilters): HarnessPredicate<T>;
+    /** Toggle the checked state of the slide-toggle. */
+    toggle(): Promise<void>;
+    /** Whether the slide-toggle is checked. */
+    isChecked(): Promise<boolean>;
+    /** Whether the slide-toggle is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the slide-toggle is required. */
+    isRequired(): Promise<boolean>;
+    /** Whether the slide-toggle is valid. */
+    isValid(): Promise<boolean>;
+    /** Gets the slide-toggle's name. */
+    getName(): Promise<string | null>;
+    /** Gets the slide-toggle's aria-label. */
+    getAriaLabel(): Promise<string | null>;
+    /** Gets the slide-toggle's aria-labelledby. */
+    getAriaLabelledby(): Promise<string | null>;
+    /** Gets the slide-toggle's label text. */
+    getLabelText(): Promise<string>;
+    /** Focuses the slide-toggle. */
+    focus(): Promise<void>;
+    /** Blurs the slide-toggle. */
+    blur(): Promise<void>;
+    /** Whether the slide-toggle is focused. */
+    isFocused(): Promise<boolean>;
+    /**
+     * Puts the slide-toggle in a checked state by toggling it if it is currently unchecked, or doing
+     * nothing if it is already checked.
+     */
+    check(): Promise<void>;
+    /**
+     * Puts the slide-toggle in an unchecked state by toggling it if it is currently checked, or doing
+     * nothing if it is already unchecked.
+     */
+    uncheck(): Promise<void>;
+}
+
+export { MatSlideToggleHarness };
+export type { SlideToggleHarnessFilters };

package/types/slide-toggle.d.ts

@@ -0,0 +1,151 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, AfterContentInit, OnChanges, ChangeDetectorRef, ElementRef, EventEmitter, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ThemePalette } from './_palette-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+
+/** Default `mat-slide-toggle` options that can be overridden. */
+interface MatSlideToggleDefaultOptions {
+    /** Whether toggle action triggers value changes in slide toggle. */
+    disableToggleValue?: boolean;
+    /**
+     * Default theme color of the slide toggle. 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/slide-toggle/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 to hide the icon inside the slide toggle. */
+    hideIcon?: boolean;
+    /** Whether disabled slide toggles should remain interactive. */
+    disabledInteractive?: boolean;
+}
+/** Injection token to be used to override the default options for `mat-slide-toggle`. */
+declare const MAT_SLIDE_TOGGLE_DEFAULT_OPTIONS: InjectionToken<MatSlideToggleDefaultOptions>;
+
+/** Change event object emitted by a slide toggle. */
+declare class MatSlideToggleChange {
+    /** The source slide toggle of the event. */
+    source: MatSlideToggle;
+    /** The new `checked` value of the slide toggle. */
+    checked: boolean;
+    constructor(
+    /** The source slide toggle of the event. */
+    source: MatSlideToggle, 
+    /** The new `checked` value of the slide toggle. */
+    checked: boolean);
+}
+declare class MatSlideToggle implements OnDestroy, AfterContentInit, OnChanges, ControlValueAccessor, Validator {
+    private _elementRef;
+    protected _focusMonitor: FocusMonitor;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    defaults: MatSlideToggleDefaultOptions;
+    private _onChange;
+    private _onTouched;
+    private _validatorOnChange;
+    private _uniqueId;
+    private _checked;
+    private _createChangeEvent;
+    /** Unique ID for the label element. */
+    _labelId: string;
+    /** Returns the unique id for the visual hidden button. */
+    get buttonId(): string;
+    /** Reference to the MDC switch element. */
+    _switchElement: ElementRef<HTMLElement>;
+    /** Focuses the slide-toggle. */
+    focus(): void;
+    /** Whether noop animations are enabled. */
+    _noopAnimations: boolean;
+    /** Whether the slide toggle is currently focused. */
+    _focused: boolean;
+    /** Name value will be applied to the input element if present. */
+    name: string | null;
+    /** A unique id for the slide-toggle input. If none is supplied, it will be auto-generated. */
+    id: string;
+    /** Whether the label should appear after or before the slide-toggle. Defaults to 'after'. */
+    labelPosition: 'before' | 'after';
+    /** Used to set the aria-label attribute on the underlying input element. */
+    ariaLabel: string | null;
+    /** Used to set the aria-labelledby attribute on the underlying input element. */
+    ariaLabelledby: string | null;
+    /** Used to set the aria-describedby attribute on the underlying input element. */
+    ariaDescribedby: string;
+    /** Whether the slide-toggle is required. */
+    required: boolean;
+    /**
+     * Theme color of the slide toggle. 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/slide-toggle/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: string | undefined;
+    /** Whether the slide toggle is disabled. */
+    disabled: boolean;
+    /** Whether the slide toggle has a ripple. */
+    disableRipple: boolean;
+    /** Tabindex of slide toggle. */
+    tabIndex: number;
+    /** Whether the slide-toggle element is checked or not. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    /** Whether to hide the icon inside of the slide toggle. */
+    hideIcon: boolean;
+    /** Whether the slide toggle should remain interactive when it is disabled. */
+    disabledInteractive: boolean;
+    /** An event will be dispatched each time the slide-toggle changes its value. */
+    readonly change: EventEmitter<MatSlideToggleChange>;
+    /**
+     * An event will be dispatched each time the slide-toggle input is toggled.
+     * This event is always emitted when the user toggles the slide toggle, but this does not mean
+     * the slide toggle's value has changed.
+     */
+    readonly toggleChange: EventEmitter<void>;
+    /** Returns the unique id for the visual hidden input. */
+    get inputId(): string;
+    constructor(...args: unknown[]);
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Implemented as part of ControlValueAccessor. */
+    writeValue(value: any): void;
+    /** Implemented as part of ControlValueAccessor. */
+    registerOnChange(fn: any): void;
+    /** Implemented as part of ControlValueAccessor. */
+    registerOnTouched(fn: any): void;
+    /** Implemented as a part of Validator. */
+    validate(control: AbstractControl<boolean>): ValidationErrors | null;
+    /** Implemented as a part of Validator. */
+    registerOnValidatorChange(fn: () => void): void;
+    /** Implemented as a part of ControlValueAccessor. */
+    setDisabledState(isDisabled: boolean): void;
+    /** Toggles the checked state of the slide-toggle. */
+    toggle(): void;
+    /**
+     * Emits a change event on the `change` output. Also notifies the FormControl about the change.
+     */
+    protected _emitChangeEvent(): void;
+    /** Method being called whenever the underlying button is clicked. */
+    _handleClick(): void;
+    _getAriaLabelledBy(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSlideToggle, "mat-slide-toggle", ["matSlideToggle"], { "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; }; "required": { "alias": "required"; "required": false; }; "color": { "alias": "color"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "hideIcon": { "alias": "hideIcon"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, { "change": "change"; "toggleChange": "toggleChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disableRipple: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_hideIcon: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+
+declare class MatSlideToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSlideToggleModule, never, [typeof MatSlideToggle], [typeof MatSlideToggle, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatSlideToggleModule>;
+}
+
+export { MAT_SLIDE_TOGGLE_DEFAULT_OPTIONS, MatSlideToggle, MatSlideToggleChange, MatSlideToggleModule };
+export type { MatSlideToggleDefaultOptions };

package/types/slider-testing.d.ts

@@ -0,0 +1,90 @@
+import { BaseHarnessFilters, ComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+/** Possible positions of a slider thumb. */
+declare enum ThumbPosition {
+    START = 0,
+    END = 1
+}
+/** A set of criteria that can be used to filter a list of `MatSliderHarness` instances. */
+interface SliderHarnessFilters extends BaseHarnessFilters {
+    /** Filters out only range/non-range sliders. */
+    isRange?: boolean;
+    /** Only find instances which match the given disabled state. */
+    disabled?: boolean;
+}
+/** A set of criteria that can be used to filter a list of `MatSliderThumbHarness` instances. */
+interface SliderThumbHarnessFilters extends BaseHarnessFilters {
+    /** Filters out slider thumbs with a particular position. */
+    position?: ThumbPosition;
+}
+
+/** Harness for interacting with a thumb inside of a Material slider in tests. */
+declare class MatSliderThumbHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a slider thumb with specific attributes.
+     * @param options Options for filtering which thumb instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatSliderThumbHarness>(this: ComponentHarnessConstructor<T>, options?: SliderThumbHarnessFilters): HarnessPredicate<T>;
+    /** Gets the position of the thumb inside the slider. */
+    getPosition(): Promise<ThumbPosition>;
+    /** Gets the value of the thumb. */
+    getValue(): Promise<number>;
+    /** Sets the value of the thumb. */
+    setValue(newValue: number): Promise<void>;
+    /** Gets the current percentage value of the slider. */
+    getPercentage(): Promise<number>;
+    /** Gets the maximum value of the thumb. */
+    getMaxValue(): Promise<number>;
+    /** Gets the minimum value of the thumb. */
+    getMinValue(): Promise<number>;
+    /** Gets the text representation of the slider's value. */
+    getDisplayValue(): Promise<string>;
+    /** Whether the thumb is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets the name of the thumb. */
+    getName(): Promise<string>;
+    /** Gets the id of the thumb. */
+    getId(): Promise<string>;
+    /**
+     * Focuses the thumb and returns a promise that indicates when the
+     * action is complete.
+     */
+    focus(): Promise<void>;
+    /**
+     * Blurs the thumb and returns a promise that indicates when the
+     * action is complete.
+     */
+    blur(): Promise<void>;
+    /** Whether the thumb is focused. */
+    isFocused(): Promise<boolean>;
+}
+
+/** Harness for interacting with a MDC mat-slider in tests. */
+declare class MatSliderHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a slider with specific attributes.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatSliderHarness>(this: ComponentHarnessConstructor<T>, options?: SliderHarnessFilters): HarnessPredicate<T>;
+    /** Gets the start thumb of the slider (only applicable for range sliders). */
+    getStartThumb(): Promise<MatSliderThumbHarness>;
+    /** Gets the thumb (for single point sliders), or the end thumb (for range sliders). */
+    getEndThumb(): Promise<MatSliderThumbHarness>;
+    /** Gets whether the slider is a range slider. */
+    isRange(): Promise<boolean>;
+    /** Gets whether the slider is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets the value step increments of the slider. */
+    getStep(): Promise<number>;
+    /** Gets the maximum value of the slider. */
+    getMaxValue(): Promise<number>;
+    /** Gets the minimum value of the slider. */
+    getMinValue(): Promise<number>;
+}
+
+export { MatSliderHarness, MatSliderThumbHarness, ThumbPosition };
+export type { SliderHarnessFilters, SliderThumbHarnessFilters };