@angular/material 14.0.0-next.8 → 14.0.0-rc.1

package/slide-toggle/index.d.ts

@@ -1,8 +1,189 @@
+import { _AbstractConstructor } from '@angular/material/core';
+import { AfterContentInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CanColor } from '@angular/material/core';
+import { CanDisable } from '@angular/material/core';
+import { CanDisableRipple } from '@angular/material/core';
+import { ChangeDetectorRef } from '@angular/core';
+import { CheckboxRequiredValidator } from '@angular/forms';
+import { _Constructor } from '@angular/material/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { HasTabIndex } from '@angular/material/core';
+import * as i0 from '@angular/core';
+import * as i3 from '@angular/material/core';
+import * as i4 from '@angular/cdk/observers';
+import { InjectionToken } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { Provider } from '@angular/core';
+import { ThemePalette } from '@angular/material/core';
+import { Type } from '@angular/core';
+
+declare namespace i1 {
+    export {
+        MAT_SLIDE_TOGGLE_REQUIRED_VALIDATOR,
+        MatSlideToggleRequiredValidator
+    }
+}
+
+declare namespace i2 {
+    export {
+        MAT_SLIDE_TOGGLE_VALUE_ACCESSOR,
+        MatSlideToggleChange,
+        _MatSlideToggleBase,
+        MatSlideToggle
+    }
+}
+
+/** Injection token to be used to override the default options for `mat-slide-toggle`. */
+export declare const MAT_SLIDE_TOGGLE_DEFAULT_OPTIONS: InjectionToken<MatSlideToggleDefaultOptions>;
+
+export declare const MAT_SLIDE_TOGGLE_REQUIRED_VALIDATOR: Provider;
+
+/** @docs-private */
+export declare const MAT_SLIDE_TOGGLE_VALUE_ACCESSOR: {
+    provide: InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+};
+
+/** Represents a slidable "switch" toggle that can be moved between on and off. */
+export declare class MatSlideToggle extends _MatSlideToggleBase<MatSlideToggleChange> {
+    /** Reference to the underlying input element. */
+    _inputElement: ElementRef<HTMLInputElement>;
+    constructor(elementRef: ElementRef, focusMonitor: FocusMonitor, changeDetectorRef: ChangeDetectorRef, tabIndex: string, defaults: MatSlideToggleDefaultOptions, animationMode?: string);
+    protected _createChangeEvent(isChecked: boolean): MatSlideToggleChange;
+    /** Method being called whenever the underlying input emits a change event. */
+    _onChangeEvent(event: Event): void;
+    /** Method being called whenever the slide-toggle has been clicked. */
+    _onInputClick(event: Event): void;
+    /** Focuses the slide-toggle. */
+    focus(options?: FocusOptions, origin?: FocusOrigin): void;
+    /** Method being called whenever the label text changes. */
+    _onLabelTextChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggle, [null, null, null, { attribute: "tabindex"; }, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSlideToggle, "mat-slide-toggle", ["matSlideToggle"], { "disabled": "disabled"; "disableRipple": "disableRipple"; "color": "color"; "tabIndex": "tabIndex"; }, {}, never, ["*"], false>;
+}
+
+export declare abstract class _MatSlideToggleBase<T> extends _MatSlideToggleMixinBase implements OnDestroy, AfterContentInit, ControlValueAccessor, CanDisable, CanColor, HasTabIndex, CanDisableRipple {
+    protected _focusMonitor: FocusMonitor;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    defaults: MatSlideToggleDefaultOptions;
+    protected _onChange: (_: any) => void;
+    private _onTouched;
+    protected _uniqueId: string;
+    private _required;
+    private _checked;
+    protected abstract _createChangeEvent(isChecked: boolean): T;
+    abstract focus(options?: FocusOptions, origin?: FocusOrigin): 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. */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    /** Whether the slide-toggle element is checked or not. */
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    /** An event will be dispatched each time the slide-toggle changes its value. */
+    readonly change: EventEmitter<T>;
+    /**
+     * 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(elementRef: ElementRef, _focusMonitor: FocusMonitor, _changeDetectorRef: ChangeDetectorRef, tabIndex: string, defaults: MatSlideToggleDefaultOptions, animationMode: string | undefined, idPrefix: string);
+    ngAfterContentInit(): 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 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MatSlideToggleBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_MatSlideToggleBase<any>, never, never, { "name": "name"; "id": "id"; "labelPosition": "labelPosition"; "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; "ariaDescribedby": "aria-describedby"; "required": "required"; "checked": "checked"; }, { "change": "change"; "toggleChange": "toggleChange"; }, never, never, false>;
+}
+
+/** Change event object emitted by a MatSlideToggle. */
+export declare class MatSlideToggleChange {
+    /** The source MatSlideToggle of the event. */
+    source: MatSlideToggle;
+    /** The new `checked` value of the MatSlideToggle. */
+    checked: boolean;
+    constructor(
+    /** The source MatSlideToggle of the event. */
+    source: MatSlideToggle, 
+    /** The new `checked` value of the MatSlideToggle. */
+    checked: boolean);
+}
+
+/** Default `mat-slide-toggle` options that can be overridden. */
+export declare interface MatSlideToggleDefaultOptions {
+    /** Whether toggle action triggers value changes in slide toggle. */
+    disableToggleValue?: boolean;
+    /** Default color for slide toggles. */
+    color?: ThemePalette;
+}
+
+/** @docs-private */
+declare const _MatSlideToggleMixinBase: _Constructor<HasTabIndex> & _AbstractConstructor<HasTabIndex> & _Constructor<CanColor> & _AbstractConstructor<CanColor> & _Constructor<CanDisableRipple> & _AbstractConstructor<CanDisableRipple> & _Constructor<CanDisable> & _AbstractConstructor<CanDisable> & {
+    new (_elementRef: ElementRef): {
+        _elementRef: ElementRef;
+    };
+};
+
+export declare class MatSlideToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSlideToggleModule, [typeof i2.MatSlideToggle], [typeof _MatSlideToggleRequiredValidatorModule, typeof i3.MatRippleModule, typeof i3.MatCommonModule, typeof i4.ObserversModule], [typeof _MatSlideToggleRequiredValidatorModule, typeof i2.MatSlideToggle, typeof i3.MatCommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatSlideToggleModule>;
+}
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * Validator for Material slide-toggle components with the required attribute in a
+ * template-driven form. The default validator for required form controls asserts
+ * that the control value is not undefined but that is not appropriate for a slide-toggle
+ * where the value is always defined.
  *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * Required slide-toggle form controls are valid when checked.
  */
-export * from './public-api';
+export declare class MatSlideToggleRequiredValidator extends CheckboxRequiredValidator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleRequiredValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSlideToggleRequiredValidator, "mat-slide-toggle[required][formControlName],             mat-slide-toggle[required][formControl], mat-slide-toggle[required][ngModel]", never, {}, {}, never, never, false>;
+}
+
+/** This module is used by both original and MDC-based slide-toggle implementations. */
+export declare class _MatSlideToggleRequiredValidatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MatSlideToggleRequiredValidatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<_MatSlideToggleRequiredValidatorModule, [typeof i1.MatSlideToggleRequiredValidator], never, [typeof i1.MatSlideToggleRequiredValidator]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<_MatSlideToggleRequiredValidatorModule>;
+}
+
+export { }

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

@@ -1,8 +1,77 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { AsyncFactoryFn } from '@angular/cdk/testing';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+import { ComponentHarness } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { TestElement } from '@angular/cdk/testing';
+
+/** Harness for interacting with a standard mat-slide-toggle in tests. */
+export declare class MatSlideToggleHarness extends _MatSlideToggleHarnessBase {
+    private _inputContainer;
+    protected _nativeElement: AsyncFactoryFn<TestElement>;
+    /** The selector for the host element of a `MatSlideToggle` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatSlideToggleHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which slide toggle instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: SlideToggleHarnessFilters): HarnessPredicate<MatSlideToggleHarness>;
+    /** Toggle the checked state of the slide-toggle. */
+    toggle(): Promise<void>;
+    /** Whether the slide-toggle is checked. */
+    isChecked(): Promise<boolean>;
+}
+
+export declare abstract class _MatSlideToggleHarnessBase extends ComponentHarness {
+    private _label;
+    protected abstract _nativeElement: AsyncFactoryFn<TestElement>;
+    /** Toggle the checked state of the slide-toggle. */
+    abstract toggle(): Promise<void>;
+    /** Whether the slide-toggle is checked. */
+    abstract 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>;
+}
+
+/** A set of criteria that can be used to filter a list of `MatSlideToggleHarness` instances. */
+export declare 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;
+}
+
+export { }

package/slider/index.d.ts

@@ -1,8 +1,291 @@
+import { _AbstractConstructor } from '@angular/material/core';
+import { AfterViewInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CanColor } from '@angular/material/core';
+import { CanDisable } from '@angular/material/core';
+import { ChangeDetectorRef } from '@angular/core';
+import { _Constructor } from '@angular/material/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Directionality } from '@angular/cdk/bidi';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { HasTabIndex } from '@angular/material/core';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/material/core';
+import { NgZone } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+import { OnDestroy } from '@angular/core';
+
+declare namespace i1 {
+    export {
+        MAT_SLIDER_VALUE_ACCESSOR,
+        MatSliderChange,
+        MatSlider
+    }
+}
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * Provider Expression that allows mat-slider to register as a ControlValueAccessor.
+ * This allows it to support [(ngModel)] and [formControl].
+ * @docs-private
  */
-export * from './public-api';
+export declare const MAT_SLIDER_VALUE_ACCESSOR: any;
+
+/**
+ * Allows users to select from a range of values by moving the slider thumb. It is similar in
+ * behavior to the native `<input type="range">` element.
+ */
+export declare class MatSlider extends _MatSliderBase implements ControlValueAccessor, OnDestroy, CanDisable, CanColor, AfterViewInit, HasTabIndex {
+    private _focusMonitor;
+    private _changeDetectorRef;
+    private _dir;
+    private _ngZone;
+    _animationMode?: string | undefined;
+    /** Whether the slider is inverted. */
+    get invert(): boolean;
+    set invert(value: BooleanInput);
+    private _invert;
+    /** The maximum value that the slider can have. */
+    get max(): number;
+    set max(v: NumberInput);
+    private _max;
+    /** The minimum value that the slider can have. */
+    get min(): number;
+    set min(v: NumberInput);
+    private _min;
+    /** The values at which the thumb will snap. */
+    get step(): number;
+    set step(v: NumberInput);
+    private _step;
+    /** Whether or not to show the thumb label. */
+    get thumbLabel(): boolean;
+    set thumbLabel(value: BooleanInput);
+    private _thumbLabel;
+    /**
+     * How often to show ticks. Relative to the step so that a tick always appears on a step.
+     * Ex: Tick interval of 4 with a step of 3 will draw a tick every 4 steps (every 12 values).
+     */
+    get tickInterval(): 'auto' | number;
+    set tickInterval(value: 'auto' | NumberInput);
+    private _tickInterval;
+    /** Value of the slider. */
+    get value(): number;
+    set value(v: NumberInput);
+    private _value;
+    /**
+     * Function that will be used to format the value before it is displayed
+     * in the thumb label. Can be used to format very large number in order
+     * for them to fit into the slider thumb.
+     */
+    displayWith: (value: number) => string | number;
+    /** Text corresponding to the slider's value. Used primarily for improved accessibility. */
+    valueText: string;
+    /** Whether the slider is vertical. */
+    get vertical(): boolean;
+    set vertical(value: BooleanInput);
+    private _vertical;
+    /** Event emitted when the slider value has changed. */
+    readonly change: EventEmitter<MatSliderChange>;
+    /** Event emitted when the slider thumb moves. */
+    readonly input: EventEmitter<MatSliderChange>;
+    /**
+     * Emits when the raw value of the slider changes. This is here primarily
+     * to facilitate the two-way binding for the `value` input.
+     * @docs-private
+     */
+    readonly valueChange: EventEmitter<number | null>;
+    /** The value to be used for display purposes. */
+    get displayValue(): string | number;
+    /** set focus to the host element */
+    focus(options?: FocusOptions): void;
+    /** blur the host element */
+    blur(): void;
+    /** onTouch function registered via registerOnTouch (ControlValueAccessor). */
+    onTouched: () => any;
+    /** The percentage of the slider that coincides with the value. */
+    get percent(): number;
+    private _percent;
+    /**
+     * Whether or not the thumb is sliding and what the user is using to slide it with.
+     * Used to determine if there should be a transition for the thumb and fill track.
+     */
+    _isSliding: 'keyboard' | 'pointer' | null;
+    /**
+     * Whether or not the slider is active (clicked or sliding).
+     * Used to shrink and grow the thumb as according to the Material Design spec.
+     */
+    _isActive: boolean;
+    /**
+     * Whether the axis of the slider is inverted.
+     * (i.e. whether moving the thumb in the positive x or y direction decreases the slider's value).
+     */
+    _shouldInvertAxis(): boolean;
+    /** Whether the slider is at its minimum value. */
+    _isMinValue(): boolean;
+    /**
+     * The amount of space to leave between the slider thumb and the track fill & track background
+     * elements.
+     */
+    _getThumbGap(): 7 | 10 | 0;
+    /** CSS styles for the track background element. */
+    _getTrackBackgroundStyles(): {
+        [key: string]: string;
+    };
+    /** CSS styles for the track fill element. */
+    _getTrackFillStyles(): {
+        [key: string]: string;
+    };
+    /** CSS styles for the ticks container element. */
+    _getTicksContainerStyles(): {
+        [key: string]: string;
+    };
+    /** CSS styles for the ticks element. */
+    _getTicksStyles(): {
+        [key: string]: string;
+    };
+    _getThumbContainerStyles(): {
+        [key: string]: string;
+    };
+    /** The size of a tick interval as a percentage of the size of the track. */
+    private _tickIntervalPercent;
+    /** The dimensions of the slider. */
+    private _sliderDimensions;
+    private _controlValueAccessorChangeFn;
+    /** Decimal places to round to, based on the step amount. */
+    private _roundToDecimal;
+    /** Subscription to the Directionality change EventEmitter. */
+    private _dirChangeSubscription;
+    /** The value of the slider when the slide start event fires. */
+    private _valueOnSlideStart;
+    /** Reference to the inner slider wrapper element. */
+    private _sliderWrapper;
+    /**
+     * Whether mouse events should be converted to a slider position by calculating their distance
+     * from the right or bottom edge of the slider as opposed to the top or left.
+     */
+    _shouldInvertMouseCoords(): boolean;
+    /** The language direction for this slider element. */
+    private _getDirection;
+    /** Keeps track of the last pointer event that was captured by the slider. */
+    private _lastPointerEvent;
+    /** Used to subscribe to global move and end events */
+    protected _document: Document;
+    /**
+     * Identifier used to attribute a touch event to a particular slider.
+     * Will be undefined if one of the following conditions is true:
+     * - The user isn't dragging using a touch device.
+     * - The browser doesn't support `Touch.identifier`.
+     * - Dragging hasn't started yet.
+     */
+    private _touchId;
+    constructor(elementRef: ElementRef, _focusMonitor: FocusMonitor, _changeDetectorRef: ChangeDetectorRef, _dir: Directionality, tabIndex: string, _ngZone: NgZone, _document: any, _animationMode?: string | undefined);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _onMouseenter(): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    _onKeydown(event: KeyboardEvent): void;
+    _onKeyup(): void;
+    /** Called when the user has put their pointer down on the slider. */
+    private _pointerDown;
+    /**
+     * Called when the user has moved their pointer after
+     * starting to drag. Bound on the document level.
+     */
+    private _pointerMove;
+    /** Called when the user has lifted their pointer. Bound on the document level. */
+    private _pointerUp;
+    /** Called when the window has lost focus. */
+    private _windowBlur;
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    private _getWindow;
+    /**
+     * Binds our global move and end events. They're bound at the document level and only while
+     * dragging so that the user doesn't have to keep their pointer exactly over the slider
+     * as they're swiping across the screen.
+     */
+    private _bindGlobalEvents;
+    /** Removes any global event listeners that we may have added. */
+    private _removeGlobalEvents;
+    /** Increments the slider by the given number of steps (negative number decrements). */
+    private _increment;
+    /** Calculate the new value from the new physical location. The value will always be snapped. */
+    private _updateValueFromPosition;
+    /** Emits a change event if the current value is different from the last emitted value. */
+    private _emitChangeEvent;
+    /** Emits an input event when the current value is different from the last emitted value. */
+    private _emitInputEvent;
+    /** Updates the amount of space between ticks as a percentage of the width of the slider. */
+    private _updateTickIntervalPercent;
+    /** Creates a slider change object from the specified value. */
+    private _createChangeEvent;
+    /** Calculates the percentage of the slider that a value is. */
+    private _calculatePercentage;
+    /** Calculates the value a percentage of the slider corresponds to. */
+    private _calculateValue;
+    /** Return a number between two numbers. */
+    private _clamp;
+    /**
+     * Get the bounding client rect of the slider track element.
+     * The track is used rather than the native element to ignore the extra space that the thumb can
+     * take up.
+     */
+    private _getSliderDimensions;
+    /**
+     * Focuses the native element.
+     * Currently only used to allow a blur event to fire but will be used with keyboard input later.
+     */
+    private _focusHostElement;
+    /** Blurs the native element. */
+    private _blurHostElement;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * @param value
+     */
+    writeValue(value: any): void;
+    /**
+     * Registers a callback to be triggered when the value has changed.
+     * 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 component is touched.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Sets whether the component should be disabled.
+     * Implemented as part of ControlValueAccessor.
+     * @param isDisabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlider, [null, null, null, { optional: true; }, { attribute: "tabindex"; }, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSlider, "mat-slider", ["matSlider"], { "disabled": "disabled"; "color": "color"; "tabIndex": "tabIndex"; "invert": "invert"; "max": "max"; "min": "min"; "step": "step"; "thumbLabel": "thumbLabel"; "tickInterval": "tickInterval"; "value": "value"; "displayWith": "displayWith"; "valueText": "valueText"; "vertical": "vertical"; }, { "change": "change"; "input": "input"; "valueChange": "valueChange"; }, never, never, false>;
+}
+
+/** @docs-private */
+declare const _MatSliderBase: _Constructor<HasTabIndex> & _AbstractConstructor<HasTabIndex> & _Constructor<CanColor> & _AbstractConstructor<CanColor> & _Constructor<CanDisable> & _AbstractConstructor<CanDisable> & {
+    new (_elementRef: ElementRef): {
+        _elementRef: ElementRef;
+    };
+};
+
+/** A simple change event emitted by the MatSlider component. */
+export declare class MatSliderChange {
+    /** The MatSlider that changed. */
+    source: MatSlider;
+    /** The new value of the source slider. */
+    value: number | null;
+}
+
+export declare class MatSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSliderModule, [typeof i1.MatSlider], [typeof i2.CommonModule, typeof i3.MatCommonModule], [typeof i1.MatSlider, typeof i3.MatCommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatSliderModule>;
+}
+
+export { }

package/slider/testing/index.d.ts

@@ -1,8 +1,60 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+import { ComponentHarness } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+
+/** Harness for interacting with a standard mat-slider in tests. */
+export declare class MatSliderHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatSlider` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatSliderHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which slider instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: SliderHarnessFilters): HarnessPredicate<MatSliderHarness>;
+    private _textLabel;
+    private _wrapper;
+    /** Gets the slider's id. */
+    getId(): Promise<string | null>;
+    /**
+     * Gets the current display value of the slider. Returns a null promise if the thumb label is
+     * disabled.
+     */
+    getDisplayValue(): Promise<string | null>;
+    /** Gets the current percentage value of the slider. */
+    getPercentage(): Promise<number>;
+    /** Gets the current value of the slider. */
+    getValue(): Promise<number>;
+    /** Gets the maximum value of the slider. */
+    getMaxValue(): Promise<number>;
+    /** Gets the minimum value of the slider. */
+    getMinValue(): Promise<number>;
+    /** Whether the slider is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets the orientation of the slider. */
+    getOrientation(): Promise<'horizontal' | 'vertical'>;
+    /**
+     * Sets the value of the slider by clicking on the slider track.
+     *
+     * Note that in rare cases the value cannot be set to the exact specified value. This
+     * can happen if not every value of the slider maps to a single pixel that could be
+     * clicked using mouse interaction. In such cases consider using the keyboard to
+     * select the given value or expand the slider's size for a better user experience.
+     */
+    setValue(value: number): Promise<void>;
+    /** Focuses the slider. */
+    focus(): Promise<void>;
+    /** Blurs the slider. */
+    blur(): Promise<void>;
+    /** Whether the slider is focused. */
+    isFocused(): Promise<boolean>;
+    /** Calculates the percentage of the given value. */
+    private _calculatePercentage;
+}
+
+/** A set of criteria that can be used to filter a list of `MatSliderHarness` instances. */
+export declare interface SliderHarnessFilters extends BaseHarnessFilters {
+}
+
+export { }