@angular/material 15.0.0-rc.0 → 15.0.0-rc.1

package/slider/index.d.ts

@@ -10,72 +10,68 @@ import { Directionality } from '@angular/cdk/bidi';
 import { ElementRef } from '@angular/core';
 import { EventEmitter } from '@angular/core';
 import * as i0 from '@angular/core';
-import * as i2 from '@angular/material/core';
-import * as i3 from '@angular/common';
+import * as i4 from '@angular/material/core';
+import * as i5 from '@angular/common';
+import { MatRipple } from '@angular/material/core';
 import { NgZone } from '@angular/core';
 import { NumberInput } from '@angular/cdk/coercion';
 import { OnDestroy } from '@angular/core';
-import { OnInit } from '@angular/core';
 import { Platform } from '@angular/cdk/platform';
 import { QueryList } from '@angular/core';
 import { RippleGlobalOptions } from '@angular/material/core';
-import { SpecificEventListener } from '@material/base';
-import { Subscription } from 'rxjs';
-import { Thumb } from '@material/slider/types';
-import { TickMark } from '@material/slider/types';
+import { Subject } from 'rxjs';
 
-/**
- * Handles listening for all change and input events that occur on the document.
- *
- * This service exposes a single method #listen to allow users to subscribe to change and input
- * events that occur on the document. Since listening for these events can be expensive, we use
- * #fromEvent which will lazily attach a listener when the first subscription is made and remove the
- * listener once the last observer unsubscribes.
- */
-declare class GlobalChangeAndInputListener<K extends 'change' | 'input'> implements OnDestroy {
-    private _ngZone;
-    /** The injected document if available or fallback to the global document reference. */
-    private _document;
-    /** Stores the subjects that emit the events that occur on the global document. */
-    private _observables;
-    /** The notifier that triggers the global event observables to stop emitting and complete. */
-    private _destroyed;
-    constructor(document: any, _ngZone: NgZone);
-    ngOnDestroy(): void;
-    /** Returns a subscription to global change or input events. */
-    listen(type: K, callback: SpecificEventListener<K>): Subscription;
-    /** Creates an observable that emits all events of the given type. */
-    private _createGlobalEventObservable;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalChangeAndInputListener<any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalChangeAndInputListener<any>>;
+declare namespace i1 {
+    export {
+        MatSlider
+    }
 }
 
-declare namespace i1 {
+declare namespace i2 {
     export {
-        MatSliderDragEvent,
-        MatSliderVisualThumb,
+        MAT_SLIDER_THUMB_VALUE_ACCESSOR,
+        MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR,
         MatSliderThumb,
-        MatSlider
+        MatSliderRangeThumb
+    }
+}
+
+declare namespace i3 {
+    export {
+        MatSliderVisualThumb
     }
 }
 
+/**
+ * Provider that allows the range slider thumb to register as a ControlValueAccessor.
+ * @docs-private
+ */
+declare const MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR: any;
+
+/**
+ * Provider that allows the slider thumb to register as a ControlValueAccessor.
+ * @docs-private
+ */
+declare const MAT_SLIDER_THUMB_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 _MatSliderMixinBase implements AfterViewInit, CanDisableRipple, OnDestroy {
+export declare class MatSlider extends _MatSliderMixinBase implements AfterViewInit, CanDisableRipple, OnDestroy, _MatSlider {
     readonly _ngZone: NgZone;
     readonly _cdr: ChangeDetectorRef;
-    private readonly _platform;
-    readonly _globalChangeAndInputListener: GlobalChangeAndInputListener<'input' | 'change'>;
-    private _dir;
+    readonly _platform: Platform;
+    readonly _dir: Directionality;
     readonly _globalRippleOptions?: RippleGlobalOptions | undefined;
-    /** The slider thumb(s). */
-    _thumbs: QueryList<MatSliderVisualThumb>;
-    /** The active section of the slider track. */
+    /** The active portion of the slider track. */
     _trackActive: ElementRef<HTMLElement>;
+    /** The slider thumb(s). */
+    _thumbs: QueryList<_MatSliderVisualThumb>;
+    /** The sliders hidden range input(s). */
+    _input: _MatSliderThumb;
     /** The sliders hidden range input(s). */
-    _inputs: QueryList<MatSliderThumb>;
+    _inputs: QueryList<_MatSliderRangeThumb>;
     /** Whether the slider is disabled. */
     get disabled(): boolean;
     set disabled(v: BooleanInput);
@@ -92,135 +88,182 @@ export declare class MatSlider extends _MatSliderMixinBase implements AfterViewI
     get min(): number;
     set min(v: NumberInput);
     private _min;
+    private _updateMin;
+    private _updateMinRange;
+    private _updateMinNonRange;
     /** The maximum value that the slider can have. */
     get max(): number;
     set max(v: NumberInput);
     private _max;
+    private _updateMax;
+    private _updateMaxRange;
+    private _updateMaxNonRange;
     /** The values at which the thumb will snap. */
     get step(): number;
     set step(v: NumberInput);
     private _step;
+    private _updateStep;
+    private _updateStepRange;
+    private _updateStepNonRange;
     /**
      * 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;
-    /** Instance of the MDC slider foundation for this slider. */
-    private _foundation;
-    /** Whether the foundation has been initialized. */
-    _initialized: boolean;
-    /** The injected document if available or fallback to the global document reference. */
-    _document: Document;
-    /**
-     * The defaultView of the injected document if
-     * available or fallback to global window reference.
-     */
-    _window: Window;
     /** Used to keep track of & render the active & inactive tick marks on the slider track. */
-    _tickMarks: TickMark[];
-    /** The display value of the start thumb. */
-    _startValueIndicatorText: string;
-    /** The display value of the end thumb. */
-    _endValueIndicatorText: string;
+    _tickMarks: _MatTickMark[];
     /** Whether animations have been disabled. */
     _noopAnimations: boolean;
-    /**
-     * Whether the browser supports pointer events.
-     *
-     * We exclude iOS to mirror the MDC Foundation. The MDC Foundation cannot use pointer events on
-     * iOS because of this open bug - https://bugs.webkit.org/show_bug.cgi?id=220196.
-     */
-    private _SUPPORTS_POINTER_EVENTS;
     /** Subscription to changes to the directionality (LTR / RTL) context for the application. */
     private _dirChangeSubscription;
     /** Observer used to monitor size changes in the slider. */
     private _resizeObserver;
-    /** Timeout used to debounce resize listeners. */
+    _cachedWidth: number;
+    _cachedLeft: number;
+    _rippleRadius: number;
+    protected startValueIndicatorText: string;
+    protected endValueIndicatorText: string;
+    _endThumbTransform: string;
+    _startThumbTransform: string;
+    _isRange: boolean;
+    /** Whether the slider is rtl. */
+    _isRtl: boolean;
+    /**
+     * The width of the tick mark track.
+     * The tick mark track width is different from full track width
+     */
+    _tickMarkTrackWidth: number;
+    _hasAnimation: boolean;
     private _resizeTimer;
-    /** Cached dimensions of the host element. */
-    private _cachedHostRect;
-    constructor(_ngZone: NgZone, _cdr: ChangeDetectorRef, elementRef: ElementRef<HTMLElement>, _platform: Platform, _globalChangeAndInputListener: GlobalChangeAndInputListener<'input' | 'change'>, document: any, _dir: Directionality, _globalRippleOptions?: RippleGlobalOptions | undefined, animationMode?: string);
+    constructor(_ngZone: NgZone, _cdr: ChangeDetectorRef, _platform: Platform, elementRef: ElementRef<HTMLElement>, _dir: Directionality, _globalRippleOptions?: RippleGlobalOptions | undefined, animationMode?: string);
+    /** The radius of the native slider's knob. AFAIK there is no way to avoid hardcoding this. */
+    _knobRadius: number;
+    _inputPadding: number;
+    _inputOffset: number;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    /** Returns true if the language direction for this slider element is right to left. */
-    _isRTL(): boolean;
-    /**
-     * Attaches an event listener that keeps sync the slider UI and the foundation in sync.
-     *
-     * Because the MDC Foundation stores the value of the bounding client rect when layout is called,
-     * we need to keep calling layout to avoid the position of the slider getting out of sync with
-     * what the foundation has stored. If we don't do this, the foundation will not be able to
-     * correctly calculate the slider value on click/slide.
-     */
-    _attachUISyncEventListener(): void;
-    /** Removes the event listener that keeps sync the slider UI and the foundation in sync. */
-    _removeUISyncEventListener(): void;
-    /** Wrapper function for calling layout (needed for adding & removing an event listener). */
-    private _layout;
+    /** Handles updating the slider ui after a dir change. */
+    private _onDirChange;
+    private _onDirChangeRange;
+    private _onDirChangeNonRange;
+    /** Starts observing and updating the slider if the host changes its size. */
+    private _observeHostResize;
+    /** Whether any of the thumbs are currently active. */
+    private _isActive;
+    private _getValue;
+    private _skipUpdate;
+    /** Stores the slider dimensions. */
+    _updateDimensions(): void;
+    /** Sets the styles for the active portion of the track. */
+    _setTrackActiveStyles(styles: {
+        left: string;
+        right: string;
+        transform: string;
+        transformOrigin: string;
+    }): void;
+    /** Returns the translateX positioning for a tick mark based on it's index. */
+    _calcTickMarkTransform(index: number): string;
+    _onTranslateXChange(source: _MatSliderThumb): void;
+    _onTranslateXChangeBySideEffect(input1: _MatSliderRangeThumb, input2: _MatSliderRangeThumb): void;
+    _onValueChange(source: _MatSliderThumb): void;
+    _onMinMaxOrStepChange(): void;
+    _onResize(): void;
+    /** Whether or not the slider thumbs overlap. */
+    private _thumbsOverlap;
+    /** Returns true if the slider knobs are overlapping one another. */
+    private _areThumbsOverlapping;
     /**
-     * Reinitializes the slider foundation and input state(s).
-     *
-     * The MDC Foundation does not support changing some slider attributes after it has been
-     * initialized (e.g. min, max, and step). To continue supporting this feature, we need to
-     * destroy the foundation and re-initialize everything whenever we make these changes.
+     * Updates the class names of overlapping slider thumbs so
+     * that the current active thumb is styled to be on "top".
      */
-    private _reinitialize;
-    /** Handles updating the slider foundation after a dir change. */
-    private _onDirChange;
-    /** Sets the value of a slider thumb. */
-    _setValue(value: number, thumbPosition: Thumb): void;
-    /** Sets the disabled state of the MatSlider. */
-    private _setDisabled;
-    /** Sets the disabled state of the individual slider thumb(s) (ControlValueAccessor). */
-    private _updateInputsDisabledState;
-    /** Whether this is a ranged slider. */
-    _isRange(): boolean;
-    /** Sets the disabled state based on the disabled state of the inputs (ControlValueAccessor). */
-    _updateDisabled(): void;
+    private _updateOverlappingThumbClassNames;
+    /** Updates the UI of slider thumbs when they begin or stop overlapping. */
+    private _updateOverlappingThumbUI;
+    /** Updates the translateX of the given thumb. */
+    _updateThumbUI(source: _MatSliderThumb): void;
+    /** Updates the value indicator tooltip ui for the given thumb. */
+    _updateValueIndicatorUI(source: _MatSliderThumb): void;
+    /** Updates the width of the tick mark track. */
+    private _updateTickMarkTrackUI;
+    /** Updates the scale on the active portion of the track. */
+    _updateTrackUI(source: _MatSliderThumb): void;
+    private _updateTrackUIRange;
+    private _updateTrackUINonRange;
+    /** Updates the dots along the slider track. */
+    _updateTickMarkUI(): void;
+    private _updateTickMarkUINonRange;
+    private _updateTickMarkUIRange;
     /** Gets the slider thumb input of the given thumb position. */
-    _getInput(thumbPosition: Thumb): MatSliderThumb;
+    _getInput(thumbPosition: _MatThumb): _MatSliderThumb | _MatSliderRangeThumb | undefined;
     /** Gets the slider thumb HTML input element of the given thumb position. */
-    _getInputElement(thumbPosition: Thumb): HTMLInputElement;
-    _getThumb(thumbPosition: Thumb): MatSliderVisualThumb;
-    /** Gets the slider thumb HTML element of the given thumb position. */
-    _getThumbElement(thumbPosition: Thumb): HTMLElement;
-    /** Gets the slider knob HTML element of the given thumb position. */
-    _getKnobElement(thumbPosition: Thumb): HTMLElement;
+    _getThumb(thumbPosition: _MatThumb): _MatSliderVisualThumb;
+    _setTransition(withAnimation: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlider, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSlider, "mat-slider", ["matSlider"], { "color": "color"; "disableRipple": "disableRipple"; "disabled": "disabled"; "discrete": "discrete"; "showTickMarks": "showTickMarks"; "min": "min"; "max": "max"; "step": "step"; "displayWith": "displayWith"; }, {}, ["_input", "_inputs"], ["*"], false, never>;
+}
+
+declare interface _MatSlider {
+    /** Gets the slider thumb input of the given thumb position. */
+    _getInput(thumbPosition: _MatThumb): _MatSliderThumb | _MatSliderRangeThumb | undefined;
+    /** Gets the slider thumb HTML input element of the given thumb position. */
+    _getThumb(thumbPosition: _MatThumb): _MatSliderVisualThumb;
+    /** The minimum value that the slider can have. */
+    min: number;
+    /** The maximum value that the slider can have. */
+    max: number;
+    /** The amount that slider values can increment or decrement by. */
+    step: number;
+    /** Whether the slider is disabled. */
+    disabled: boolean;
+    /** Whether the slider is a range slider. */
+    _isRange: boolean;
+    /** Whether the slider is rtl. */
+    _isRtl: boolean;
+    /** The stored width of the host element's bounding client rect. */
+    _cachedWidth: number;
+    /** The stored width of the host element's bounding client rect. */
+    _cachedLeft: number;
     /**
-     * Gets the slider value indicator container HTML element of the given thumb
-     * position.
+     * The padding of the native slider input. This is added in order to make the region where the
+     * thumb ripple extends past the end of the slider track clickable.
      */
-    _getValueIndicatorContainerElement(thumbPosition: Thumb): HTMLElement;
+    _inputPadding: number;
     /**
-     * Sets the value indicator text of the given thumb position using the given value.
+     * The offset represents left most translateX of the slider knob. Inversely,
+     * (slider width - offset) = the right most translateX of the slider knob.
      *
-     * Uses the `displayWith` function if one has been provided. Otherwise, it just uses the
-     * numeric value as a string.
+     * Note:
+     *    * The native slider knob differs from the visual slider. It's knob cannot slide past
+     *      the end of the track AT ALL.
+     *    * The visual slider knob CAN slide past the end of the track slightly. It's knob can slide
+     *      past the end of the track such that it's center lines up with the end of the track.
      */
-    _setValueIndicatorText(value: number, thumbPosition: Thumb): void;
-    /** Gets the value indicator text for the given thumb position. */
-    _getValueIndicatorText(thumbPosition: Thumb): string;
-    /** Determines the class name for a HTML element. */
-    _getTickMarkClass(tickMark: TickMark): string;
-    /** Whether the slider thumb ripples should be disabled. */
-    _isRippleDisabled(): boolean;
-    /** Gets the dimensions of the host element. */
-    _getHostDimensions(): DOMRect;
-    /** Starts observing and updating the slider if the host changes its size. */
-    private _observeHostResize;
-    /** Whether any of the thumbs are currently active. */
-    private _isActive;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlider, [null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MatSlider, "mat-slider", ["matSlider"], { "color": "color"; "disableRipple": "disableRipple"; "disabled": "disabled"; "discrete": "discrete"; "showTickMarks": "showTickMarks"; "min": "min"; "max": "max"; "step": "step"; "displayWith": "displayWith"; }, {}, ["_inputs"], ["*"], false, never>;
+    _inputOffset: number;
+    /** The radius of the visual slider's ripple. */
+    _rippleRadius: number;
+    /** The global configuration for `matRipple` instances. */
+    readonly _globalRippleOptions?: RippleGlobalOptions;
+    /** Whether animations have been disabled. */
+    _noopAnimations: boolean;
+    /** Whether or not the slider should use animations. */
+    _hasAnimation: boolean;
+    /** Triggers UI updates that are needed after a slider input value has changed. */
+    _onValueChange: (source: _MatSliderThumb) => void;
+    /** Triggers UI updates that are needed after the slider thumb position has changed. */
+    _onTranslateXChange: (source: _MatSliderThumb) => void;
+    /** Updates the stored slider dimensions using the current bounding client rect. */
+    _updateDimensions: () => void;
+    /** Used to set the transition duration for thumb and track animations. */
+    _setTransition: (withAnimation: boolean) => void;
 }
 
 /** Represents a drag event emitted by the MatSlider component. */
 export declare interface MatSliderDragEvent {
     /** The MatSliderThumb that was interacted with. */
-    source: MatSliderThumb;
+    source: _MatSliderThumb;
     /** The MatSlider that was interacted with. */
-    parent: MatSlider;
+    parent: _MatSlider;
     /** The current value of the slider. */
     value: number;
 }
@@ -233,10 +276,63 @@ declare const _MatSliderMixinBase: _Constructor<CanColor> & _AbstractConstructor
 
 export declare class MatSliderModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSliderModule, [typeof i1.MatSlider, typeof i1.MatSliderThumb, typeof i1.MatSliderVisualThumb], [typeof i2.MatCommonModule, typeof i3.CommonModule, typeof i2.MatRippleModule], [typeof i1.MatSlider, typeof i1.MatSliderThumb]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSliderModule, [typeof i1.MatSlider, typeof i2.MatSliderThumb, typeof i2.MatSliderRangeThumb, typeof i3.MatSliderVisualThumb], [typeof i4.MatCommonModule, typeof i5.CommonModule, typeof i4.MatRippleModule], [typeof i1.MatSlider, typeof i2.MatSliderThumb, typeof i2.MatSliderRangeThumb]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<MatSliderModule>;
 }
 
+export declare class MatSliderRangeThumb extends MatSliderThumb implements _MatSliderRangeThumb {
+    readonly _cdr: ChangeDetectorRef;
+    getSibling(): _MatSliderRangeThumb | undefined;
+    private _sibling;
+    /** Returns the minimum translateX position allowed for this slider input's visual thumb. */
+    getMinPos(): number;
+    /** Returns the maximum translateX position allowed for this slider input's visual thumb. */
+    getMaxPos(): number;
+    _setIsLeftThumb(): void;
+    /** Whether this slider corresponds to the input on the left hand side. */
+    _isLeftThumb: boolean;
+    /** Whether this slider corresponds to the input with greater value. */
+    _isEndThumb: boolean;
+    constructor(_ngZone: NgZone, _slider: _MatSlider, _elementRef: ElementRef<HTMLInputElement>, _cdr: ChangeDetectorRef);
+    _getDefaultValue(): number;
+    _onInput(): void;
+    _onNgControlValueChange(): void;
+    _onPointerDown(event: PointerEvent): void;
+    _onPointerUp(event: PointerEvent): void;
+    _onPointerMove(event: PointerEvent): void;
+    _fixValue(event: PointerEvent): void;
+    _clamp(v: number): number;
+    _updateMinMax(): void;
+    _updateWidthActive(): void;
+    _updateWidthInactive(): void;
+    _updateStaticStyles(): void;
+    private _updateSibling;
+    /**
+     * Sets the input's value.
+     * @param value The new value of the input
+     * @docs-private
+     */
+    writeValue(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderRangeThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSliderRangeThumb, "input[matSliderStartThumb], input[matSliderEndThumb]", ["matSliderRangeThumb"], {}, {}, never, never, false, never>;
+}
+
+declare interface _MatSliderRangeThumb extends _MatSliderThumb {
+    /** Whether this slider corresponds to the input on the left hand side. */
+    _isLeftThumb: boolean;
+    /**
+     * Gets the sibling MatSliderRangeThumb.
+     * Returns undefined if it is too early in Angular's life cycle.
+     */
+    getSibling: () => _MatSliderRangeThumb | undefined;
+    /** Used to cache whether this slider input corresponds to the visual left thumb. */
+    _setIsLeftThumb: () => void;
+    /** Updates the input styles to control whether it is pinned to the start or end of the mat-slider. */
+    _updateStaticStyles: () => void;
+    /** Updates the min and max properties of this slider input according to it's sibling. */
+    _updateMinMax: () => void;
+}
+
 /**
  * Directive that adds slider-specific behaviors to an input element inside `<mat-slider>`.
  * Up to two may be placed inside of a `<mat-slider>`.
@@ -245,120 +341,193 @@ export declare class MatSliderModule {
  * slider. If two are used, the selectors `matSliderStartThumb` and `matSliderEndThumb` must be
  * used, and the outcome will be a range slider with two slider thumbs.
  */
-export declare class MatSliderThumb implements AfterViewInit, ControlValueAccessor, OnInit, OnDestroy {
-    private readonly _slider;
-    private readonly _elementRef;
-    /** The current value of this slider input. */
+export declare class MatSliderThumb implements _MatSliderThumb, OnDestroy, ControlValueAccessor {
+    readonly _ngZone: NgZone;
+    readonly _elementRef: ElementRef<HTMLInputElement>;
+    readonly _cdr: ChangeDetectorRef;
+    protected _slider: _MatSlider;
     get value(): number;
     set value(v: NumberInput);
-    /**
-     * 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>;
     /** Event emitted when the slider thumb starts being dragged. */
     readonly dragStart: EventEmitter<MatSliderDragEvent>;
     /** Event emitted when the slider thumb stops being dragged. */
     readonly dragEnd: EventEmitter<MatSliderDragEvent>;
-    /** Event emitted every time the MatSliderThumb is blurred. */
-    readonly _blur: EventEmitter<void>;
-    /** Event emitted every time the MatSliderThumb is focused. */
-    readonly _focus: EventEmitter<void>;
-    /**
-     * Used to determine the disabled state of the MatSlider (ControlValueAccessor).
-     * For ranged sliders, the disabled state of the MatSlider depends on the combined state of the
-     * start and end inputs. See MatSlider._updateDisabled.
-     */
-    _disabled: boolean;
+    /** The current translateX in px of the slider visual thumb. */
+    get translateX(): number;
+    set translateX(v: number);
+    private _translateX;
+    /** Indicates whether this thumb is the start or end thumb. */
+    thumbPosition: _MatThumb;
+    get min(): number;
+    set min(v: NumberInput);
+    get max(): number;
+    set max(v: NumberInput);
+    get step(): number;
+    set step(v: NumberInput);
+    get disabled(): boolean;
+    set disabled(v: BooleanInput);
+    get percentage(): number;
+    get fillPercentage(): number;
+    /** The host native HTML input element. */
+    _hostElement: HTMLInputElement;
+    /** The aria-valuetext string representation of the input's value. */
+    _valuetext: string;
+    /** The radius of a native html slider's knob. */
+    _knobRadius: number;
+    /** Whether user's cursor is currently in a mouse down state on the input. */
+    _isActive: boolean;
+    /** Whether the input is currently focused (either by tab or after clicking). */
+    _isFocused: boolean;
+    /** Used to relay updates to _isFocused to the slider visual thumbs. */
+    private _setIsFocused;
     /**
-     * A callback function that is called when the
-     * control's value changes in the UI (ControlValueAccessor).
+     * Whether the initial value has been set.
+     * This exists because the initial value cannot be immediately set because the min and max
+     * must first be relayed from the parent MatSlider component, which can only happen later
+     * in the component lifecycle.
      */
-    _onChange: (value: any) => void;
+    private _hasSetInitialValue;
+    /** The stored initial value. */
+    _initialValue: string | undefined;
+    /** Defined when a user is using a form control to manage slider value & validation. */
+    private _formControl;
+    /** Emits when the component is destroyed. */
+    protected readonly _destroyed: Subject<void>;
     /**
-     * A callback function that is called by the forms API on
-     * initialization to update the form model on blur (ControlValueAccessor).
+     * Indicates whether UI updates should be skipped.
+     *
+     * This flag is used to avoid flickering
+     * when correcting values on pointer up/down.
      */
-    private _onTouched;
-    /** Indicates which slider thumb this input corresponds to. */
-    _thumbPosition: Thumb;
-    /** The injected document if available or fallback to the global document reference. */
-    private _document;
-    /** The host native HTML input element. */
-    _hostElement: HTMLInputElement;
-    constructor(document: any, _slider: MatSlider, _elementRef: ElementRef<HTMLInputElement>);
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
+    _skipUIUpdate: boolean;
+    /** Callback called when the slider input value changes. */
+    private _onChangeFn;
+    /** Callback called when the slider input has been touched. */
+    private _onTouchedFn;
+    constructor(_ngZone: NgZone, _elementRef: ElementRef<HTMLInputElement>, _cdr: ChangeDetectorRef, _slider: _MatSlider);
     ngOnDestroy(): void;
+    initProps(): void;
+    initUI(): void;
+    _initValue(): void;
+    _getDefaultValue(): number;
     _onBlur(): void;
-    _emitFakeEvent(type: 'change' | 'input'): void;
+    _onFocus(): void;
+    _onChange(): void;
+    _onInput(): void;
+    _onNgControlValueChange(): void;
+    _onPointerDown(event: PointerEvent): void;
     /**
-     * Sets the model value. Implemented as part of ControlValueAccessor.
-     * @param value
+     * Corrects the value of the slider on pointer up/down.
+     *
+     * Called on pointer down and up because the value is set based
+     * on the inactive width instead of the active width.
+     */
+    private _handleValueCorrection;
+    /** Corrects the value of the slider based on the pointer event's position. */
+    _fixValue(event: PointerEvent): void;
+    _onPointerMove(event: PointerEvent): void;
+    _onPointerUp(event: PointerEvent): void;
+    _clamp(v: number): number;
+    _calcTranslateXByValue(): number;
+    _calcTranslateXByPointerEvent(event: PointerEvent): number;
+    /**
+     * Used to set the slider width to the correct
+     * dimensions while the user is dragging.
+     */
+    _updateWidthActive(): void;
+    /**
+     * Sets the slider input to disproportionate dimensions to allow for touch
+     * events to be captured on touch devices.
+     */
+    _updateWidthInactive(): void;
+    _updateThumbUIByValue(options?: {
+        withAnimation: boolean;
+    }): void;
+    _updateThumbUIByPointerEvent(event: PointerEvent, options?: {
+        withAnimation: boolean;
+    }): void;
+    _updateThumbUI(options?: {
+        withAnimation: boolean;
+    }): void;
+    /**
+     * Sets the input's value.
+     * @param value The new value of the input
+     * @docs-private
      */
     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.
+     * Registers a callback to be invoked when the input's value changes from user input.
+     * @param fn The callback to register
+     * @docs-private
      */
     registerOnChange(fn: any): void;
     /**
-     * Registers a callback to be triggered when the component is touched.
-     * Implemented as part of ControlValueAccessor.
-     * @param fn Callback to be registered.
+     * Registers a callback to be invoked when the input is blurred by the user.
+     * @param fn The callback to register
+     * @docs-private
      */
     registerOnTouched(fn: any): void;
     /**
-     * Sets whether the component should be disabled.
-     * Implemented as part of ControlValueAccessor.
-     * @param isDisabled
+     * Sets the disabled state of the slider.
+     * @param isDisabled The new disabled state
+     * @docs-private
      */
     setDisabledState(isDisabled: boolean): void;
     focus(): void;
     blur(): void;
-    /** Returns true if this slider input currently has focus. */
-    _isFocused(): boolean;
-    /**
-     * Sets the min, max, and step properties on the slider thumb input.
-     *
-     * Must be called AFTER the sibling slider thumb input is guaranteed to have had its value
-     * attribute value set. For a range slider, the min and max of the slider thumb input depends on
-     * the value of its sibling slider thumb inputs value.
-     *
-     * Must be called BEFORE the value property is set. In the case where the min and max have not
-     * yet been set and we are setting the input value property to a value outside of the native
-     * inputs default min or max. The value property would not be set to our desired value, but
-     * instead be capped at either the default min or max.
-     *
-     */
-    _initializeInputState(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSliderThumb, "input[matSliderThumb]", ["matSliderThumb"], { "value": "value"; }, { "valueChange": "valueChange"; "dragStart": "dragStart"; "dragEnd": "dragEnd"; }, never, never, false, never>;
+}
+
+declare interface _MatSliderThumb {
+    /** The minimum value that the slider can have. */
+    min: number;
+    /** The maximum value that the slider can have. */
+    max: number;
+    /** The amount that slider values can increment or decrement by. */
+    step: number;
+    /** The current value of this slider input. */
+    value: number;
+    /** The current translateX in px of the slider visual thumb. */
+    translateX: number;
+    /** Indicates whether this thumb is the start or end thumb. */
+    thumbPosition: _MatThumb;
+    /** Similar to percentage but calcualted using translateX relative to the total track width. */
+    fillPercentage: number;
+    /** Whether the slider is disabled. */
+    disabled: boolean;
+    /** The host native HTML input element. */
+    _hostElement: HTMLInputElement;
+    /** Whether the input is currently focused (either by tab or after clicking). */
+    _isFocused: boolean;
+    /** The aria-valuetext string representation of the input's value. */
+    _valuetext: string;
     /**
-     * Sets the value property on the slider thumb input.
+     * Indicates whether UI updates should be skipped.
      *
-     * Must be called AFTER the min and max have been set. In the case where the min and max have not
-     * yet been set and we are setting the input value property to a value outside of the native
-     * inputs default min or max. The value property would not be set to our desired value, but
-     * instead be capped at either the default min or max.
+     * This flag is used to avoid flickering
+     * when correcting values on pointer up/down.
      */
-    private _initializeInputValueProperty;
+    _skipUIUpdate: boolean;
+    /** Handles the initialization of properties for the slider input. */
+    initProps: () => void;
+    /** Handles UI initialization controlled by this slider input. */
+    initUI: () => void;
+    /** Calculates the visual thumb's translateX based on the slider input's current value. */
+    _calcTranslateXByValue: () => number;
+    /** Updates the visual thumb based on the slider input's current value. */
+    _updateThumbUIByValue: () => void;
     /**
-     * Ensures the value attribute is initialized.
-     *
-     * Must be called BEFORE the min and max are set. For a range slider, the min and max of the
-     * slider thumb input depends on the value of its sibling slider thumb inputs value.
+     * Sets the slider input to disproportionate dimensions to allow for touch
+     * events to be captured on touch devices.
      */
-    private _initializeInputValueAttribute;
+    _updateWidthInactive: () => void;
     /**
-     * Initializes the aria-valuetext attribute.
-     *
-     * Must be called AFTER the value attribute is set. This is because the slider's parent
-     * `displayWith` function is used to set the `aria-valuetext` attribute.
+     * Used to set the slider width to the correct
+     * dimensions while the user is dragging.
      */
-    private _initializeAriaValueText;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderThumb, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSliderThumb, "input[matSliderThumb], input[matSliderStartThumb], input[matSliderEndThumb]", ["matSliderThumb"], { "value": "value"; }, { "valueChange": "valueChange"; "dragStart": "dragStart"; "dragEnd": "dragEnd"; "_blur": "_blur"; "_focus": "_focus"; }, never, never, false, never>;
+    _updateWidthActive: () => void;
 }
 
 /**
@@ -368,42 +537,44 @@ export declare class MatSliderThumb implements AfterViewInit, ControlValueAccess
  * and displaying the value tooltip on discrete sliders.
  * @docs-private
  */
-declare class MatSliderVisualThumb implements AfterViewInit, OnDestroy {
+export declare class MatSliderVisualThumb implements _MatSliderVisualThumb, AfterViewInit, OnDestroy {
+    readonly _cdr: ChangeDetectorRef;
     private readonly _ngZone;
-    private readonly _slider;
-    private readonly _elementRef;
+    private _slider;
     /** Whether the slider displays a numeric value label upon pressing the thumb. */
     discrete: boolean;
     /** Indicates which slider thumb this input corresponds to. */
-    thumbPosition: Thumb;
+    thumbPosition: _MatThumb;
     /** The display value of the slider thumb. */
     valueIndicatorText: string;
-    /** Whether ripples on the slider thumb should be disabled. */
-    disableRipple: boolean;
     /** The MatRipple for this slider thumb. */
-    private readonly _ripple;
+    readonly _ripple: MatRipple;
     /** The slider thumb knob. */
     _knob: ElementRef<HTMLElement>;
     /** The slider thumb value indicator container. */
     _valueIndicatorContainer: ElementRef<HTMLElement>;
     /** The slider input corresponding to this slider thumb. */
     private _sliderInput;
+    /** The native html element of the slider input corresponding to this thumb. */
+    private _sliderInputEl;
     /** The RippleRef for the slider thumbs hover state. */
     private _hoverRippleRef;
     /** The RippleRef for the slider thumbs focus state. */
     private _focusRippleRef;
     /** The RippleRef for the slider thumbs active state. */
     private _activeRippleRef;
-    /** Whether the slider thumb is currently being pressed. */
-    readonly _isActive = false;
     /** Whether the slider thumb is currently being hovered. */
     private _isHovered;
-    constructor(_ngZone: NgZone, _slider: MatSlider, _elementRef: ElementRef<HTMLElement>);
+    /** Whether the slider thumb is currently being pressed. */
+    _isActive: boolean;
+    /** Whether the value indicator tooltip is visible. */
+    _isValueIndicatorVisible: boolean;
+    /** The host native HTML input element. */
+    _hostElement: HTMLElement;
+    constructor(_cdr: ChangeDetectorRef, _ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _slider: _MatSlider);
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    /** Used to append a class to indicate when the value indicator text is short. */
-    _isShortValue(): boolean;
-    private _onMouseEnter;
+    private _onPointerMove;
     private _onMouseLeave;
     private _onFocus;
     private _onBlur;
@@ -419,17 +590,54 @@ declare class MatSliderVisualThumb implements AfterViewInit, OnDestroy {
     private _isShowingRipple;
     /** Manually launches the slider thumb ripple using the specified ripple animation config. */
     private _showRipple;
-    /** Gets the hosts native HTML element. */
-    _getHostElement(): HTMLElement;
-    /** Gets the native HTML element of the slider thumb knob. */
-    _getKnob(): HTMLElement;
     /**
-     * Gets the native HTML element of the slider thumb value indicator
-     * container.
+     * Fades out the given ripple.
+     * Also hides the value indicator if no ripple is showing.
      */
-    _getValueIndicatorContainer(): HTMLElement;
+    private _hideRipple;
+    /** Shows the value indicator ui. */
+    _showValueIndicator(): void;
+    /** Hides the value indicator ui. */
+    _hideValueIndicator(): void;
+    _getSibling(): _MatSliderVisualThumb;
+    /** Gets the value indicator container's native HTML element. */
+    _getValueIndicatorContainer(): HTMLElement | undefined;
+    /** Gets the native HTML element of the slider thumb knob. */
+    _getKnob(): HTMLElement;
+    _isShowingAnyRipple(): boolean;
+    private _isSliderThumbHovered;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderVisualThumb, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MatSliderVisualThumb, "mat-slider-visual-thumb", never, { "discrete": "discrete"; "thumbPosition": "thumbPosition"; "valueIndicatorText": "valueIndicatorText"; "disableRipple": "disableRipple"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSliderVisualThumb, "mat-slider-visual-thumb", never, { "discrete": "discrete"; "thumbPosition": "thumbPosition"; "valueIndicatorText": "valueIndicatorText"; }, {}, never, never, false, never>;
+}
+
+declare interface _MatSliderVisualThumb {
+    /** The MatRipple for this slider thumb. */
+    _ripple: MatRipple;
+    /** Whether the slider thumb is currently being pressed. */
+    _isActive: boolean;
+    /** The host native HTML input element. */
+    _hostElement: HTMLElement;
+    /** Shows the value indicator ui. */
+    _showValueIndicator: () => void;
+    /** Hides the value indicator ui. */
+    _hideValueIndicator: () => void;
+    /** Whether the slider visual thumb is currently showing any ripple. */
+    _isShowingAnyRipple: () => boolean;
+}
+
+/**
+ * Thumb types: range slider has two thumbs (START, END) whereas single point
+ * slider only has one thumb (END).
+ */
+declare const enum _MatThumb {
+    START = 1,
+    END = 2
+}
+
+/** Tick mark enum, for discrete sliders. */
+declare const enum _MatTickMark {
+    ACTIVE = 0,
+    INACTIVE = 1
 }
 
 export { }