build: test material entry-points against api goldens (#14707)

Closes #13801
2026-09-14 13:54:52 +08:00 · 2019-01-09 19:43:26 +01:00
parent 74c7681957
commit ec9f9c836c
38 changed files with 3351 additions and 2 deletions
@@ -13,6 +13,12 @@ ng_module(
  deps = ["//src/lib/%s" % p for p in MATERIAL_PACKAGES],
 )

+# Alias so that developers can build Material using it's label shorthand (e.g. "build //src/lib")
+alias(
+  name = "lib",
+  actual = "material",
+)
+
 sass_bundle(
  name = "theming_bundle",
  srcs = [
@@ -2,8 +2,8 @@ package(default_visibility=["//visibility:public"])

 load(":generate-guard-tests.bzl", "generate_test_targets")

-# TODO(devversion): This currently does not include the CDK portal package because
-# aliases are not supported by ts-api-guardian. Re-add once we found a solution for that.
+# TODO(devversion): All entry-points except the CDK portal are currently validated. This is
+# because aliases are not supported by ts-api-guardian. Re-add once we found a solution for that.

 # Generate the API guard test targets for each golden file in the current package.
 generate_test_targets(glob(["**/*.d.ts"]))
@@ -0,0 +1,94 @@
+export declare const _MatAutocompleteMixinBase: CanDisableRippleCtor & typeof MatAutocompleteBase;
+
+export declare const AUTOCOMPLETE_OPTION_HEIGHT = 48;
+
+export declare const AUTOCOMPLETE_PANEL_HEIGHT = 256;
+
+export declare function getMatAutocompleteMissingPanelError(): Error;
+
+export declare const MAT_AUTOCOMPLETE_DEFAULT_OPTIONS: InjectionToken<MatAutocompleteDefaultOptions>;
+
+export declare function MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY(): MatAutocompleteDefaultOptions;
+
+export declare const MAT_AUTOCOMPLETE_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare function MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare const MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY;
+};
+
+export declare const MAT_AUTOCOMPLETE_VALUE_ACCESSOR: any;
+
+export declare class MatAutocomplete extends _MatAutocompleteMixinBase implements AfterContentInit, CanDisableRipple {
+    _classList: {
+        [key: string]: boolean;
+    };
+    _isOpen: boolean;
+    _keyManager: ActiveDescendantKeyManager<MatOption>;
+    autoActiveFirstOption: boolean;
+    classList: string;
+    readonly closed: EventEmitter<void>;
+    displayWith: ((value: any) => string) | null;
+    id: string;
+    readonly isOpen: boolean;
+    readonly opened: EventEmitter<void>;
+    optionGroups: QueryList<MatOptgroup>;
+    readonly optionSelected: EventEmitter<MatAutocompleteSelectedEvent>;
+    options: QueryList<MatOption>;
+    panel: ElementRef;
+    panelWidth: string | number;
+    showPanel: boolean;
+    template: TemplateRef<any>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, defaults: MatAutocompleteDefaultOptions);
+    _emitSelectEvent(option: MatOption): void;
+    _getScrollTop(): number;
+    _setScrollTop(scrollTop: number): void;
+    _setVisibility(): void;
+    ngAfterContentInit(): void;
+}
+
+export declare class MatAutocompleteBase {
+}
+
+export interface MatAutocompleteDefaultOptions {
+    autoActiveFirstOption?: boolean;
+}
+
+export declare class MatAutocompleteModule {
+}
+
+export declare class MatAutocompleteSelectedEvent {
+    option: MatOption;
+    source: MatAutocomplete;
+    constructor(
+    source: MatAutocomplete,
+    option: MatOption);
+}
+
+export declare class MatAutocompleteTrigger implements ControlValueAccessor, OnDestroy {
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    readonly activeOption: MatOption | null;
+    autocomplete: MatAutocomplete;
+    autocompleteAttribute: string;
+    autocompleteDisabled: boolean;
+    connectedTo: MatAutocompleteOrigin;
+    readonly optionSelections: Observable<MatOptionSelectionChange>;
+    readonly panelClosingActions: Observable<MatOptionSelectionChange | null>;
+    readonly panelOpen: boolean;
+    constructor(_element: ElementRef<HTMLInputElement>, _overlay: Overlay, _viewContainerRef: ViewContainerRef, _zone: NgZone, _changeDetectorRef: ChangeDetectorRef, scrollStrategy: any, _dir: Directionality, _formField: MatFormField, _document: any, _viewportRuler?: ViewportRuler | undefined);
+    _handleFocus(): void;
+    _handleInput(event: KeyboardEvent): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    closePanel(): void;
+    ngOnDestroy(): void;
+    openPanel(): void;
+    registerOnChange(fn: (value: any) => {}): void;
+    registerOnTouched(fn: () => {}): void;
+    setDisabledState(isDisabled: boolean): void;
+    updatePosition(): void;
+    writeValue(value: any): void;
+}
@@ -0,0 +1,28 @@
+export declare const _MatBadgeMixinBase: CanDisableCtor & typeof MatBadgeBase;
+
+export declare class MatBadge extends _MatBadgeMixinBase implements OnDestroy, CanDisable {
+    _hasContent: boolean;
+    _id: number;
+    color: ThemePalette;
+    content: string;
+    description: string;
+    hidden: boolean;
+    overlap: boolean;
+    position: MatBadgePosition;
+    size: MatBadgeSize;
+    constructor(_document: any, _ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _ariaDescriber: AriaDescriber,
+    _renderer?: Renderer2 | undefined);
+    isAbove(): boolean;
+    isAfter(): boolean;
+    ngOnDestroy(): void;
+}
+
+export declare class MatBadgeBase {
+}
+
+export declare class MatBadgeModule {
+}
+
+export declare type MatBadgePosition = 'above after' | 'above before' | 'below before' | 'below after';
+
+export declare type MatBadgeSize = 'small' | 'medium' | 'large';
@@ -0,0 +1,60 @@
+export declare const MAT_BOTTOM_SHEET_DATA: InjectionToken<any>;
+
+export declare const MAT_BOTTOM_SHEET_DEFAULT_OPTIONS: InjectionToken<MatBottomSheetConfig<any>>;
+
+export declare class MatBottomSheet implements OnDestroy {
+    _openedBottomSheetRef: MatBottomSheetRef<any> | null;
+    constructor(_overlay: Overlay, _injector: Injector, _parentBottomSheet: MatBottomSheet, _location?: Location | undefined, _defaultOptions?: MatBottomSheetConfig<any> | undefined);
+    dismiss(): void;
+    ngOnDestroy(): void;
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: MatBottomSheetConfig<D>): MatBottomSheetRef<T, R>;
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: MatBottomSheetConfig<D>): MatBottomSheetRef<T, R>;
+}
+
+export declare const matBottomSheetAnimations: {
+    readonly bottomSheetState: AnimationTriggerMetadata;
+};
+
+export declare class MatBottomSheetConfig<D = any> {
+    ariaLabel?: string | null;
+    autoFocus?: boolean;
+    backdropClass?: string;
+    closeOnNavigation?: boolean;
+    data?: D | null;
+    direction?: Direction;
+    disableClose?: boolean;
+    hasBackdrop?: boolean;
+    panelClass?: string | string[];
+    restoreFocus?: boolean;
+    viewContainerRef?: ViewContainerRef;
+}
+
+export declare class MatBottomSheetContainer extends BasePortalOutlet implements OnDestroy {
+    _animationState: 'void' | 'visible' | 'hidden';
+    _animationStateChanged: EventEmitter<AnimationEvent>;
+    _portalOutlet: CdkPortalOutlet;
+    bottomSheetConfig: MatBottomSheetConfig;
+    constructor(_elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, _focusTrapFactory: FocusTrapFactory, breakpointObserver: BreakpointObserver, document: any,
+    bottomSheetConfig: MatBottomSheetConfig);
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    enter(): void;
+    exit(): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatBottomSheetModule {
+}
+
+export declare class MatBottomSheetRef<T = any, R = any> {
+    containerInstance: MatBottomSheetContainer;
+    instance: T;
+    constructor(containerInstance: MatBottomSheetContainer, _overlayRef: OverlayRef, _location?: Location);
+    afterDismissed(): Observable<R | undefined>;
+    afterOpened(): Observable<void>;
+    backdropClick(): Observable<MouseEvent>;
+    dismiss(result?: R): void;
+    keydownEvents(): Observable<KeyboardEvent>;
+}
@@ -0,0 +1,79 @@
+export declare const _MatButtonToggleMixinBase: CanDisableRippleCtor & typeof MatButtonToggleBase;
+
+export declare const MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS: InjectionToken<MatButtonToggleDefaultOptions>;
+
+export declare const MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR: any;
+
+export declare class MatButtonToggle extends _MatButtonToggleMixinBase implements OnInit, CanDisableRipple, OnDestroy {
+    _buttonElement: ElementRef<HTMLButtonElement>;
+    _type: ToggleType;
+    appearance: MatButtonToggleAppearance;
+    ariaLabel: string;
+    ariaLabelledby: string | null;
+    readonly buttonId: string;
+    buttonToggleGroup: MatButtonToggleGroup;
+    readonly change: EventEmitter<MatButtonToggleChange>;
+    checked: boolean;
+    disabled: boolean;
+    id: string;
+    name: string;
+    tabIndex: number | null;
+    value: any;
+    constructor(toggleGroup: MatButtonToggleGroup, _changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, _focusMonitor: FocusMonitor, defaultTabIndex: string, defaultOptions?: MatButtonToggleDefaultOptions);
+    _markForCheck(): void;
+    _onButtonClick(): void;
+    focus(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare type MatButtonToggleAppearance = 'legacy' | 'standard';
+
+export declare class MatButtonToggleBase {
+}
+
+export declare class MatButtonToggleChange {
+    source: MatButtonToggle;
+    value: any;
+    constructor(
+    source: MatButtonToggle,
+    value: any);
+}
+
+export interface MatButtonToggleDefaultOptions {
+    appearance?: MatButtonToggleAppearance;
+}
+
+export declare class MatButtonToggleGroup implements ControlValueAccessor, OnInit, AfterContentInit {
+    _buttonToggles: QueryList<MatButtonToggle>;
+    _controlValueAccessorChangeFn: (value: any) => void;
+    _onTouched: () => any;
+    appearance: MatButtonToggleAppearance;
+    readonly change: EventEmitter<MatButtonToggleChange>;
+    disabled: boolean;
+    multiple: boolean;
+    name: string;
+    readonly selected: MatButtonToggle | MatButtonToggle[];
+    value: any;
+    readonly valueChange: EventEmitter<any>;
+    vertical: boolean;
+    constructor(_changeDetector: ChangeDetectorRef, defaultOptions?: MatButtonToggleDefaultOptions);
+    _emitChangeEvent(): void;
+    _isPrechecked(toggle: MatButtonToggle): boolean;
+    _isSelected(toggle: MatButtonToggle): boolean;
+    _syncButtonToggle(toggle: MatButtonToggle, select: boolean, isUserInput?: boolean): void;
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatButtonToggleGroupMultiple {
+}
+
+export declare class MatButtonToggleModule {
+}
+
+export declare type ToggleType = 'checkbox' | 'radio';
@@ -0,0 +1,29 @@
+export declare const _MatButtonMixinBase: CanDisableRippleCtor & CanDisableCtor & CanColorCtor & typeof MatButtonBase;
+
+export declare class MatAnchor extends MatButton {
+    tabIndex: number;
+    constructor(platform: Platform, focusMonitor: FocusMonitor, elementRef: ElementRef, animationMode?: string);
+    _haltDisabledEvents(event: Event): void;
+}
+
+export declare class MatButton extends _MatButtonMixinBase implements OnDestroy, CanDisable, CanColor, CanDisableRipple {
+    _animationMode?: string | undefined;
+    readonly isIconButton: boolean;
+    readonly isRoundButton: boolean;
+    ripple: MatRipple;
+    constructor(elementRef: ElementRef,
+    _platform: Platform, _focusMonitor: FocusMonitor, _animationMode?: string | undefined);
+    _getHostElement(): any;
+    _hasHostAttributes(...attributes: string[]): boolean;
+    _isRippleDisabled(): boolean;
+    focus(): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatButtonBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatButtonModule {
+}
@@ -0,0 +1,45 @@
+export declare class MatCard {
+}
+
+export declare class MatCardActions {
+    align: 'start' | 'end';
+}
+
+export declare class MatCardAvatar {
+}
+
+export declare class MatCardContent {
+}
+
+export declare class MatCardFooter {
+}
+
+export declare class MatCardHeader {
+}
+
+export declare class MatCardImage {
+}
+
+export declare class MatCardLgImage {
+}
+
+export declare class MatCardMdImage {
+}
+
+export declare class MatCardModule {
+}
+
+export declare class MatCardSmImage {
+}
+
+export declare class MatCardSubtitle {
+}
+
+export declare class MatCardTitle {
+}
+
+export declare class MatCardTitleGroup {
+}
+
+export declare class MatCardXlImage {
+}
@@ -0,0 +1,66 @@
+export declare const _MatCheckboxMixinBase: HasTabIndexCtor & CanColorCtor & CanDisableRippleCtor & CanDisableCtor & typeof MatCheckboxBase;
+
+export declare const MAT_CHECKBOX_CLICK_ACTION: InjectionToken<MatCheckboxClickAction>;
+
+export declare const MAT_CHECKBOX_CONTROL_VALUE_ACCESSOR: any;
+
+export declare const MAT_CHECKBOX_REQUIRED_VALIDATOR: Provider;
+
+export declare class MatCheckbox extends _MatCheckboxMixinBase implements ControlValueAccessor, AfterViewChecked, OnDestroy, CanColor, CanDisable, HasTabIndex, CanDisableRipple {
+    _animationMode?: string | undefined;
+    _inputElement: ElementRef<HTMLInputElement>;
+    _onTouched: () => any;
+    ariaLabel: string;
+    ariaLabelledby: string | null;
+    readonly change: EventEmitter<MatCheckboxChange>;
+    checked: boolean;
+    disabled: any;
+    id: string;
+    indeterminate: boolean;
+    readonly indeterminateChange: EventEmitter<boolean>;
+    readonly inputId: string;
+    labelPosition: 'before' | 'after';
+    name: string | null;
+    required: boolean;
+    ripple: MatRipple;
+    value: string;
+    constructor(elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, _focusMonitor: FocusMonitor, _ngZone: NgZone, tabIndex: string, _clickAction: MatCheckboxClickAction, _animationMode?: string | undefined);
+    _getAriaChecked(): 'true' | 'false' | 'mixed';
+    _isRippleDisabled(): any;
+    _onInputClick(event: Event): void;
+    _onInteractionEvent(event: Event): void;
+    _onLabelTextChange(): void;
+    focus(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggle(): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatCheckboxBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatCheckboxChange {
+    checked: boolean;
+    source: MatCheckbox;
+}
+
+export declare type MatCheckboxClickAction = 'noop' | 'check' | 'check-indeterminate' | undefined;
+
+export declare class MatCheckboxModule {
+}
+
+export declare class MatCheckboxRequiredValidator extends CheckboxRequiredValidator {
+}
+
+export declare enum TransitionCheckState {
+    Init = 0,
+    Checked = 1,
+    Unchecked = 2,
+    Indeterminate = 3
+}
@@ -0,0 +1,190 @@
+export declare const _MatChipListMixinBase: CanUpdateErrorStateCtor & typeof MatChipListBase;
+
+export declare const _MatChipMixinBase: CanColorCtor & CanDisableRippleCtor & CanDisableCtor & typeof MatChipBase;
+
+export declare const MAT_CHIPS_DEFAULT_OPTIONS: InjectionToken<MatChipsDefaultOptions>;
+
+export declare class MatChip extends _MatChipMixinBase implements FocusableOption, OnDestroy, CanColor, CanDisable, CanDisableRipple, RippleTarget {
+    _elementRef: ElementRef;
+    _hasFocus: boolean;
+    readonly _onBlur: Subject<MatChipEvent>;
+    readonly _onFocus: Subject<MatChipEvent>;
+    protected _removable: boolean;
+    protected _selectable: boolean;
+    protected _selected: boolean;
+    protected _value: any;
+    readonly ariaSelected: string | null;
+    avatar: MatChipAvatar;
+    chipListSelectable: boolean;
+    readonly destroyed: EventEmitter<MatChipEvent>;
+    removable: boolean;
+    removeIcon: MatChipRemove;
+    readonly removed: EventEmitter<MatChipEvent>;
+    rippleConfig: RippleConfig;
+    readonly rippleDisabled: boolean;
+    selectable: boolean;
+    selected: boolean;
+    readonly selectionChange: EventEmitter<MatChipSelectionChange>;
+    trailingIcon: MatChipTrailingIcon;
+    value: any;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone, platform: Platform, globalOptions: RippleGlobalOptions);
+    _addHostClassName(): void;
+    _blur(): void;
+    _handleClick(event: Event): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    deselect(): void;
+    focus(): void;
+    ngOnDestroy(): void;
+    remove(): void;
+    select(): void;
+    selectViaInteraction(): void;
+    toggleSelected(isUserInput?: boolean): boolean;
+}
+
+export declare class MatChipAvatar {
+}
+
+export declare class MatChipBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export interface MatChipEvent {
+    chip: MatChip;
+}
+
+export declare class MatChipInput implements MatChipTextControl, OnChanges {
+    _addOnBlur: boolean;
+    _chipList: MatChipList;
+    protected _elementRef: ElementRef<HTMLInputElement>;
+    protected _inputElement: HTMLInputElement;
+    addOnBlur: boolean;
+    chipEnd: EventEmitter<MatChipInputEvent>;
+    chipList: MatChipList;
+    disabled: boolean;
+    readonly empty: boolean;
+    focused: boolean;
+    id: string;
+    placeholder: string;
+    separatorKeyCodes: number[] | Set<number>;
+    constructor(_elementRef: ElementRef<HTMLInputElement>, _defaultOptions: MatChipsDefaultOptions);
+    _blur(): void;
+    _emitChipEnd(event?: KeyboardEvent): void;
+    _focus(): void;
+    _keydown(event?: KeyboardEvent): void;
+    _onInput(): void;
+    focus(): void;
+    ngOnChanges(): void;
+}
+
+export interface MatChipInputEvent {
+    input: HTMLInputElement;
+    value: string;
+}
+
+export declare class MatChipList extends _MatChipListMixinBase implements MatFormFieldControl<any>, ControlValueAccessor, AfterContentInit, DoCheck, OnInit, OnDestroy, CanUpdateErrorState {
+    _ariaDescribedby: string;
+    protected _chipInput: MatChipTextControl;
+    protected _disabled: boolean;
+    protected _elementRef: ElementRef<HTMLElement>;
+    _keyManager: FocusKeyManager<MatChip>;
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    protected _placeholder: string;
+    protected _required: boolean;
+    protected _selectable: boolean;
+    _selectionModel: SelectionModel<MatChip>;
+    _tabIndex: number;
+    _uid: string;
+    _userTabIndex: number | null;
+    protected _value: any;
+    ariaOrientation: 'horizontal' | 'vertical';
+    readonly change: EventEmitter<MatChipListChange>;
+    readonly chipBlurChanges: Observable<MatChipEvent>;
+    readonly chipFocusChanges: Observable<MatChipEvent>;
+    readonly chipRemoveChanges: Observable<MatChipEvent>;
+    readonly chipSelectionChanges: Observable<MatChipSelectionChange>;
+    chips: QueryList<MatChip>;
+    compareWith: (o1: any, o2: any) => boolean;
+    readonly controlType: string;
+    disabled: boolean;
+    readonly empty: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    readonly focused: boolean;
+    readonly id: string;
+    multiple: boolean;
+    ngControl: NgControl;
+    placeholder: string;
+    required: boolean;
+    readonly role: string | null;
+    selectable: boolean;
+    readonly selected: MatChip[] | MatChip;
+    readonly shouldLabelFloat: boolean;
+    tabIndex: number;
+    value: any;
+    readonly valueChange: EventEmitter<any>;
+    constructor(_elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, _dir: Directionality, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _defaultErrorStateMatcher: ErrorStateMatcher,
+    ngControl: NgControl);
+    _blur(): void;
+    _focusInput(): void;
+    _keydown(event: KeyboardEvent): void;
+    _markAsTouched(): void;
+    _setSelectionByValue(value: any, isUserInput?: boolean): void;
+    protected _updateFocusForDestroyedChips(): void;
+    protected _updateTabIndex(): void;
+    focus(): void;
+    ngAfterContentInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    onContainerClick(event: MouseEvent): void;
+    registerInput(inputElement: MatChipTextControl): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDescribedByIds(ids: string[]): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatChipListBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _parentForm: NgForm, _parentFormGroup: FormGroupDirective,
+    ngControl: NgControl);
+}
+
+export declare class MatChipListChange {
+    source: MatChipList;
+    value: any;
+    constructor(
+    source: MatChipList,
+    value: any);
+}
+
+export declare class MatChipRemove {
+    protected _parentChip: MatChip;
+    constructor(_parentChip: MatChip);
+    _handleClick(event: Event): void;
+}
+
+export interface MatChipsDefaultOptions {
+    separatorKeyCodes: number[] | Set<number>;
+}
+
+export declare class MatChipSelectionChange {
+    isUserInput: boolean;
+    selected: boolean;
+    source: MatChip;
+    constructor(
+    source: MatChip,
+    selected: boolean,
+    isUserInput?: boolean);
+}
+
+export declare class MatChipsModule {
+}
+
+export declare class MatChipTrailingIcon {
+}
@@ -0,0 +1,427 @@
+export declare function _countGroupLabelsBeforeOption(optionIndex: number, options: QueryList<MatOption>, optionGroups: QueryList<MatOptgroup>): number;
+
+export declare function _getOptionScrollPosition(optionIndex: number, optionHeight: number, currentScrollPosition: number, panelHeight: number): number;
+
+export declare const _MatOptgroupMixinBase: CanDisableCtor & typeof MatOptgroupBase;
+
+export declare class AnimationCurves {
+    static ACCELERATION_CURVE: string;
+    static DECELERATION_CURVE: string;
+    static SHARP_CURVE: string;
+    static STANDARD_CURVE: string;
+}
+
+export declare class AnimationDurations {
+    static COMPLEX: string;
+    static ENTERING: string;
+    static EXITING: string;
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export interface CanColor {
+    color: ThemePalette;
+}
+
+export declare type CanColorCtor = Constructor<CanColor>;
+
+export interface CanDisable {
+    disabled: boolean;
+}
+
+export declare type CanDisableCtor = Constructor<CanDisable>;
+
+export interface CanDisableRipple {
+    disableRipple: boolean;
+}
+
+export declare type CanDisableRippleCtor = Constructor<CanDisableRipple>;
+
+export interface CanUpdateErrorState {
+    errorState: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    readonly stateChanges: Subject<void>;
+    updateErrorState(): void;
+}
+
+export declare type CanUpdateErrorStateCtor = Constructor<CanUpdateErrorState>;
+
+export declare abstract class DateAdapter<D> {
+    protected _localeChanges: Subject<void>;
+    protected locale: any;
+    readonly localeChanges: Observable<void>;
+    abstract addCalendarDays(date: D, days: number): D;
+    abstract addCalendarMonths(date: D, months: number): D;
+    abstract addCalendarYears(date: D, years: number): D;
+    clampDate(date: D, min?: D | null, max?: D | null): D;
+    abstract clone(date: D): D;
+    compareDate(first: D, second: D): number;
+    abstract createDate(year: number, month: number, date: number): D;
+    deserialize(value: any): D | null;
+    abstract format(date: D, displayFormat: any): string;
+    abstract getDate(date: D): number;
+    abstract getDateNames(): string[];
+    abstract getDayOfWeek(date: D): number;
+    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    abstract getFirstDayOfWeek(): number;
+    abstract getMonth(date: D): number;
+    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    abstract getNumDaysInMonth(date: D): number;
+    abstract getYear(date: D): number;
+    abstract getYearName(date: D): string;
+    abstract invalid(): D;
+    abstract isDateInstance(obj: any): boolean;
+    abstract isValid(date: D): boolean;
+    abstract parse(value: any, parseFormat: any): D | null;
+    sameDate(first: D | null, second: D | null): boolean;
+    setLocale(locale: any): void;
+    abstract toIso8601(date: D): string;
+    abstract today(): D;
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare const defaultRippleAnimationConfig: {
+    enterDuration: number;
+    exitDuration: number;
+};
+
+export declare class ErrorStateMatcher {
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare type FloatLabelType = 'always' | 'never' | 'auto';
+
+export declare class GestureConfig extends HammerGestureConfig {
+    events: string[];
+    constructor(_hammerOptions?: HammerOptions | undefined, commonModule?: MatCommonModule);
+    buildHammer(element: HTMLElement): HammerInstance;
+}
+
+export interface HammerInput {
+    center: {
+        x: number;
+        y: number;
+    };
+    deltaX: number;
+    deltaY: number;
+    preventDefault: () => {};
+}
+
+export interface HammerInstance {
+    off(eventName: string, callback: Function): void;
+    on(eventName: string, callback: Function): void;
+}
+
+export interface HammerManager {
+    add(recogniser: Recognizer | Recognizer[]): Recognizer;
+    emit(event: string, data: any): void;
+    off(events: string, handler?: Function): void;
+    on(events: string, handler: Function): void;
+    set(options: any): HammerManager;
+}
+
+export interface HammerOptions {
+    cssProps?: {
+        [key: string]: string;
+    };
+    domEvents?: boolean;
+    enable?: boolean | ((manager: HammerManager) => boolean);
+    inputClass?: HammerInput;
+    inputTarget?: EventTarget;
+    preset?: any[];
+    recognizers?: any[];
+    touchAction?: string;
+}
+
+export interface HammerStatic {
+    Pan: Recognizer;
+    Press: Recognizer;
+    Swipe: Recognizer;
+    new (element: HTMLElement | SVGElement, options?: any): HammerManager;
+}
+
+export interface HasInitialized {
+    _markInitialized: () => void;
+    initialized: Observable<void>;
+}
+
+export declare type HasInitializedCtor = Constructor<HasInitialized>;
+
+export interface HasTabIndex {
+    tabIndex: number;
+}
+
+export declare type HasTabIndexCtor = Constructor<HasTabIndex>;
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export interface LabelOptions {
+    float?: FloatLabelType;
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare const MAT_DATE_FORMATS: InjectionToken<MatDateFormats>;
+
+export declare const MAT_DATE_LOCALE: InjectionToken<string>;
+
+export declare function MAT_DATE_LOCALE_FACTORY(): string;
+
+export declare const MAT_DATE_LOCALE_PROVIDER: {
+    provide: InjectionToken<string>;
+    useExisting: InjectionToken<string>;
+};
+
+export declare const MAT_HAMMER_OPTIONS: InjectionToken<HammerOptions>;
+
+export declare const MAT_LABEL_GLOBAL_OPTIONS: InjectionToken<LabelOptions>;
+
+export declare const MAT_NATIVE_DATE_FORMATS: MatDateFormats;
+
+export declare const MAT_OPTION_PARENT_COMPONENT: InjectionToken<MatOptionParentComponent>;
+
+export declare const MAT_RIPPLE_GLOBAL_OPTIONS: InjectionToken<RippleGlobalOptions>;
+
+export declare class MatCommonModule {
+    constructor(_sanityChecksEnabled: boolean, _hammerLoader?: HammerLoader | undefined);
+    _checkHammerIsAvailable(): void;
+}
+
+export declare type MatDateFormats = {
+    parse: {
+        dateInput: any;
+    };
+    display: {
+        dateInput: any;
+        monthYearLabel: any;
+        dateA11yLabel: any;
+        monthYearA11yLabel: any;
+    };
+};
+
+export declare const MATERIAL_SANITY_CHECKS: InjectionToken<boolean>;
+
+export declare class MatLine {
+}
+
+export declare class MatLineModule {
+}
+
+export declare class MatLineSetter {
+    constructor(lines: QueryList<MatLine>, element: ElementRef<HTMLElement>);
+}
+
+export declare class MatNativeDateModule {
+}
+
+export declare class MatOptgroup extends _MatOptgroupMixinBase implements CanDisable {
+    _labelId: string;
+    label: string;
+}
+
+export declare class MatOptgroupBase {
+}
+
+export declare class MatOption implements AfterViewChecked, OnDestroy {
+    readonly _stateChanges: Subject<void>;
+    readonly active: boolean;
+    readonly disableRipple: boolean | undefined;
+    disabled: any;
+    readonly group: MatOptgroup;
+    id: string;
+    readonly multiple: boolean | undefined;
+    readonly onSelectionChange: EventEmitter<MatOptionSelectionChange>;
+    readonly selected: boolean;
+    value: any;
+    readonly viewValue: string;
+    constructor(_element: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, _parent: MatOptionParentComponent, group: MatOptgroup);
+    _getHostElement(): HTMLElement;
+    _getTabIndex(): string;
+    _handleKeydown(event: KeyboardEvent): void;
+    _selectViaInteraction(): void;
+    deselect(): void;
+    focus(): void;
+    getLabel(): string;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    select(): void;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+}
+
+export declare class MatOptionModule {
+}
+
+export interface MatOptionParentComponent {
+    disableRipple?: boolean;
+    multiple?: boolean;
+}
+
+export declare class MatOptionSelectionChange {
+    isUserInput: boolean;
+    source: MatOption;
+    constructor(
+    source: MatOption,
+    isUserInput?: boolean);
+}
+
+export declare class MatPseudoCheckbox {
+    _animationMode?: string | undefined;
+    disabled: boolean;
+    state: MatPseudoCheckboxState;
+    constructor(_animationMode?: string | undefined);
+}
+
+export declare class MatPseudoCheckboxModule {
+}
+
+export declare type MatPseudoCheckboxState = 'unchecked' | 'checked' | 'indeterminate';
+
+export declare class MatRipple implements OnInit, OnDestroy, RippleTarget {
+    animation: RippleAnimationConfig;
+    centered: boolean;
+    color: string;
+    disabled: boolean;
+    radius: number;
+    readonly rippleConfig: RippleConfig;
+    readonly rippleDisabled: boolean;
+    trigger: HTMLElement;
+    unbounded: boolean;
+    constructor(_elementRef: ElementRef<HTMLElement>, ngZone: NgZone, platform: Platform, globalOptions: RippleGlobalOptions, animationMode?: string);
+    fadeOutAll(): void;
+    launch(config: RippleConfig): RippleRef;
+    launch(x: number, y: number, config?: RippleConfig): RippleRef;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare class MatRippleModule {
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare function mixinColor<T extends Constructor<HasElementRef>>(base: T, defaultColor?: ThemePalette): CanColorCtor & T;
+
+export declare function mixinDisabled<T extends Constructor<{}>>(base: T): CanDisableCtor & T;
+
+export declare function mixinDisableRipple<T extends Constructor<{}>>(base: T): CanDisableRippleCtor & T;
+
+export declare function mixinErrorState<T extends Constructor<HasErrorState>>(base: T): CanUpdateErrorStateCtor & T;
+
+export declare function mixinInitialized<T extends Constructor<{}>>(base: T): HasInitializedCtor & T;
+
+export declare function mixinTabIndex<T extends Constructor<CanDisable>>(base: T, defaultTabIndex?: number): HasTabIndexCtor & T;
+
+export declare class NativeDateAdapter extends DateAdapter<Date> {
+    useUtcForDisplay: boolean;
+    constructor(matDateLocale: string, platform: Platform);
+    addCalendarDays(date: Date, days: number): Date;
+    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarYears(date: Date, years: number): Date;
+    clone(date: Date): Date;
+    createDate(year: number, month: number, date: number): Date;
+    deserialize(value: any): Date | null;
+    format(date: Date, displayFormat: Object): string;
+    getDate(date: Date): number;
+    getDateNames(): string[];
+    getDayOfWeek(date: Date): number;
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getFirstDayOfWeek(): number;
+    getMonth(date: Date): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getNumDaysInMonth(date: Date): number;
+    getYear(date: Date): number;
+    getYearName(date: Date): string;
+    invalid(): Date;
+    isDateInstance(obj: any): boolean;
+    isValid(date: Date): boolean;
+    parse(value: any): Date | null;
+    toIso8601(date: Date): string;
+    today(): Date;
+}
+
+export declare class NativeDateModule {
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export interface Recognizer {
+    new (options?: any): Recognizer;
+    recognizeWith(otherRecognizer: Recognizer | string): Recognizer;
+}
+
+export interface RecognizerStatic {
+    new (options?: any): Recognizer;
+}
+
+export interface RippleAnimationConfig {
+    enterDuration?: number;
+    exitDuration?: number;
+}
+
+export declare type RippleConfig = {
+    color?: string;
+    centered?: boolean;
+    radius?: number;
+    persistent?: boolean;
+    animation?: RippleAnimationConfig;
+    terminateOnPointerUp?: boolean;
+};
+
+export interface RippleGlobalOptions {
+    animation?: RippleAnimationConfig;
+    disabled?: boolean;
+    terminateOnPointerUp?: boolean;
+}
+
+export declare class RippleRef {
+    config: RippleConfig;
+    element: HTMLElement;
+    state: RippleState;
+    constructor(_renderer: RippleRenderer,
+    element: HTMLElement,
+    config: RippleConfig);
+    fadeOut(): void;
+}
+
+export declare class RippleRenderer {
+    constructor(_target: RippleTarget, _ngZone: NgZone, elementRef: ElementRef<HTMLElement>, platform: Platform);
+    _removeTriggerEvents(): void;
+    fadeInRipple(x: number, y: number, config?: RippleConfig): RippleRef;
+    fadeOutAll(): void;
+    fadeOutRipple(rippleRef: RippleRef): void;
+    setupTriggerEvents(element: HTMLElement): void;
+}
+
+export declare enum RippleState {
+    FADING_IN = 0,
+    VISIBLE = 1,
+    FADING_OUT = 2,
+    HIDDEN = 3
+}
+
+export interface RippleTarget {
+    rippleConfig: RippleConfig;
+    rippleDisabled: boolean;
+}
+
+export declare const JAN = 0, FEB = 1, MAR = 2, APR = 3, MAY = 4, JUN = 5, JUL = 6, AUG = 7, SEP = 8, OCT = 9, NOV = 10, DEC = 11;
+
+export declare function setLines(lines: QueryList<MatLine>, element: ElementRef<HTMLElement>): void;
+
+export declare class ShowOnDirtyErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+
+export declare type ThemePalette = 'primary' | 'accent' | 'warn' | undefined;
@@ -0,0 +1,282 @@
+export declare const _MatDatepickerContentMixinBase: CanColorCtor & typeof MatDatepickerContentBase;
+
+export declare const MAT_DATEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare function MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare const MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY;
+};
+
+export declare const MAT_DATEPICKER_VALIDATORS: any;
+
+export declare const MAT_DATEPICKER_VALUE_ACCESSOR: any;
+
+export declare class MatCalendar<D> implements AfterContentInit, AfterViewChecked, OnDestroy, OnChanges {
+    _calendarHeaderPortal: Portal<any>;
+    readonly _userSelection: EventEmitter<void>;
+    activeDate: D;
+    currentView: MatCalendarView;
+    dateClass: (date: D) => MatCalendarCellCssClasses;
+    dateFilter: (date: D) => boolean;
+    headerComponent: ComponentType<any>;
+    maxDate: D | null;
+    minDate: D | null;
+    readonly monthSelected: EventEmitter<D>;
+    monthView: MatMonthView<D>;
+    multiYearView: MatMultiYearView<D>;
+    selected: D | null;
+    readonly selectedChange: EventEmitter<D>;
+    startAt: D | null;
+    startView: MatCalendarView;
+    stateChanges: Subject<void>;
+    readonly yearSelected: EventEmitter<D>;
+    yearView: MatYearView<D>;
+    constructor(_intl: MatDatepickerIntl, _dateAdapter: DateAdapter<D>, _dateFormats: MatDateFormats, _changeDetectorRef: ChangeDetectorRef);
+    _dateSelected(date: D): void;
+    _goToDateInView(date: D, view: 'month' | 'year' | 'multi-year'): void;
+    _monthSelectedInYearView(normalizedMonth: D): void;
+    _userSelected(): void;
+    _yearSelectedInMultiYearView(normalizedYear: D): void;
+    focusActiveCell(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    updateTodaysDate(): void;
+}
+
+export declare class MatCalendarBody implements OnChanges {
+    _cellPadding: string;
+    _cellWidth: string;
+    _firstRowOffset: number;
+    activeCell: number;
+    cellAspectRatio: number;
+    label: string;
+    labelMinRequiredCells: number;
+    numCols: number;
+    rows: MatCalendarCell[][];
+    selectedValue: number;
+    readonly selectedValueChange: EventEmitter<number>;
+    todayValue: number;
+    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone);
+    _cellClicked(cell: MatCalendarCell): void;
+    _focusActiveCell(): void;
+    _isActiveCell(rowIndex: number, colIndex: number): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+}
+
+export declare class MatCalendarCell {
+    ariaLabel: string;
+    cssClasses?: string | Set<string> | {
+        [key: string]: any;
+    } | string[] | undefined;
+    displayValue: string;
+    enabled: boolean;
+    value: number;
+    constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean, cssClasses?: string | Set<string> | {
+        [key: string]: any;
+    } | string[] | undefined);
+}
+
+export declare type MatCalendarCellCssClasses = string | string[] | Set<string> | {
+    [key: string]: any;
+};
+
+export declare class MatCalendarHeader<D> {
+    calendar: MatCalendar<D>;
+    readonly nextButtonLabel: string;
+    readonly periodButtonLabel: string;
+    readonly periodButtonText: string;
+    readonly prevButtonLabel: string;
+    constructor(_intl: MatDatepickerIntl, calendar: MatCalendar<D>, _dateAdapter: DateAdapter<D>, _dateFormats: MatDateFormats, changeDetectorRef: ChangeDetectorRef);
+    currentPeriodClicked(): void;
+    nextClicked(): void;
+    nextEnabled(): boolean;
+    previousClicked(): void;
+    previousEnabled(): boolean;
+}
+
+export declare type MatCalendarView = 'month' | 'year' | 'multi-year';
+
+export declare class MatDatepicker<D> implements OnDestroy, CanColor {
+    _color: ThemePalette;
+    readonly _dateFilter: (date: D | null) => boolean;
+    _datepickerInput: MatDatepickerInput<D>;
+    readonly _disabledChange: Subject<boolean>;
+    readonly _maxDate: D | null;
+    readonly _minDate: D | null;
+    _popupRef: OverlayRef;
+    _selected: D | null;
+    readonly _selectedChanged: Subject<D>;
+    calendarHeaderComponent: ComponentType<any>;
+    closedStream: EventEmitter<void>;
+    color: ThemePalette;
+    dateClass: (date: D) => MatCalendarCellCssClasses;
+    disabled: boolean;
+    id: string;
+    readonly monthSelected: EventEmitter<D>;
+    opened: boolean;
+    openedStream: EventEmitter<void>;
+    panelClass: string | string[];
+    startAt: D | null;
+    startView: 'month' | 'year' | 'multi-year';
+    touchUi: boolean;
+    readonly yearSelected: EventEmitter<D>;
+    constructor(_dialog: MatDialog, _overlay: Overlay, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, scrollStrategy: any, _dateAdapter: DateAdapter<D>, _dir: Directionality, _document: any);
+    _registerInput(input: MatDatepickerInput<D>): void;
+    _selectMonth(normalizedMonth: D): void;
+    _selectYear(normalizedYear: D): void;
+    close(): void;
+    ngOnDestroy(): void;
+    open(): void;
+    select(date: D): void;
+}
+
+export declare const matDatepickerAnimations: {
+    readonly transformPanel: AnimationTriggerMetadata;
+    readonly fadeInCalendar: AnimationTriggerMetadata;
+};
+
+export declare class MatDatepickerContent<D> extends _MatDatepickerContentMixinBase implements AfterViewInit, CanColor {
+    _calendar: MatCalendar<D>;
+    _isAbove: boolean;
+    datepicker: MatDatepicker<D>;
+    constructor(elementRef: ElementRef);
+    ngAfterViewInit(): void;
+}
+
+export declare class MatDatepickerContentBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatDatepickerInput<D> implements ControlValueAccessor, OnDestroy, Validator {
+    _dateAdapter: DateAdapter<D>;
+    _dateFilter: (date: D | null) => boolean;
+    _datepicker: MatDatepicker<D>;
+    _disabledChange: EventEmitter<boolean>;
+    _onTouched: () => void;
+    _valueChange: EventEmitter<D | null>;
+    readonly dateChange: EventEmitter<MatDatepickerInputEvent<D>>;
+    readonly dateInput: EventEmitter<MatDatepickerInputEvent<D>>;
+    disabled: boolean;
+    matDatepicker: MatDatepicker<D>;
+    matDatepickerFilter: (date: D | null) => boolean;
+    max: D | null;
+    min: D | null;
+    value: D | null;
+    constructor(_elementRef: ElementRef<HTMLInputElement>, _dateAdapter: DateAdapter<D>, _dateFormats: MatDateFormats, _formField: MatFormField);
+    _getThemePalette(): ThemePalette;
+    _onBlur(): void;
+    _onChange(): void;
+    _onInput(value: string): void;
+    _onKeydown(event: KeyboardEvent): void;
+    getConnectedOverlayOrigin(): ElementRef;
+    getPopupConnectionElementRef(): ElementRef;
+    ngOnDestroy(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    registerOnValidatorChange(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    writeValue(value: D): void;
+}
+
+export declare class MatDatepickerInputEvent<D> {
+    target: MatDatepickerInput<D>;
+    targetElement: HTMLElement;
+    value: D | null;
+    constructor(
+    target: MatDatepickerInput<D>,
+    targetElement: HTMLElement);
+}
+
+export declare class MatDatepickerIntl {
+    calendarLabel: string;
+    readonly changes: Subject<void>;
+    nextMonthLabel: string;
+    nextMultiYearLabel: string;
+    nextYearLabel: string;
+    openCalendarLabel: string;
+    prevMonthLabel: string;
+    prevMultiYearLabel: string;
+    prevYearLabel: string;
+    switchToMonthViewLabel: string;
+    switchToMultiYearViewLabel: string;
+}
+
+export declare class MatDatepickerModule {
+}
+
+export declare class MatDatepickerToggle<D> implements AfterContentInit, OnChanges, OnDestroy {
+    _button: MatButton;
+    _customIcon: MatDatepickerToggleIcon;
+    _intl: MatDatepickerIntl;
+    datepicker: MatDatepicker<D>;
+    disableRipple: boolean;
+    disabled: boolean;
+    tabIndex: number | null;
+    constructor(_intl: MatDatepickerIntl, _changeDetectorRef: ChangeDetectorRef, defaultTabIndex: string);
+    _open(event: Event): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatDatepickerToggleIcon {
+}
+
+export declare class MatMonthView<D> implements AfterContentInit {
+    _dateAdapter: DateAdapter<D>;
+    _firstWeekOffset: number;
+    _matCalendarBody: MatCalendarBody;
+    _monthLabel: string;
+    _selectedDate: number | null;
+    _todayDate: number | null;
+    readonly _userSelection: EventEmitter<void>;
+    _weekdays: {
+        long: string;
+        narrow: string;
+    }[];
+    _weeks: MatCalendarCell[][];
+    activeDate: D;
+    readonly activeDateChange: EventEmitter<D>;
+    dateClass: (date: D) => MatCalendarCellCssClasses;
+    dateFilter: (date: D) => boolean;
+    maxDate: D | null;
+    minDate: D | null;
+    selected: D | null;
+    readonly selectedChange: EventEmitter<D | null>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _dateFormats: MatDateFormats, _dateAdapter: DateAdapter<D>, _dir?: Directionality | undefined);
+    _dateSelected(date: number): void;
+    _focusActiveCell(): void;
+    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    _init(): void;
+    ngAfterContentInit(): void;
+}
+
+export declare class MatYearView<D> implements AfterContentInit {
+    _dateAdapter: DateAdapter<D>;
+    _matCalendarBody: MatCalendarBody;
+    _months: MatCalendarCell[][];
+    _selectedMonth: number | null;
+    _todayMonth: number | null;
+    _yearLabel: string;
+    activeDate: D;
+    readonly activeDateChange: EventEmitter<D>;
+    dateFilter: (date: D) => boolean;
+    maxDate: D | null;
+    minDate: D | null;
+    readonly monthSelected: EventEmitter<D>;
+    selected: D | null;
+    readonly selectedChange: EventEmitter<D>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _dateFormats: MatDateFormats, _dateAdapter: DateAdapter<D>, _dir?: Directionality | undefined);
+    _focusActiveCell(): void;
+    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    _init(): void;
+    _monthSelected(month: number): void;
+    ngAfterContentInit(): void;
+}
@@ -0,0 +1,128 @@
+export interface DialogPosition {
+    bottom?: string;
+    left?: string;
+    right?: string;
+    top?: string;
+}
+
+export declare type DialogRole = 'dialog' | 'alertdialog';
+
+export declare const MAT_DIALOG_DATA: InjectionToken<any>;
+
+export declare const MAT_DIALOG_DEFAULT_OPTIONS: InjectionToken<MatDialogConfig<any>>;
+
+export declare const MAT_DIALOG_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY;
+};
+
+export declare function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare class MatDialog implements OnDestroy {
+    readonly _afterAllClosed: Subject<void>;
+    readonly afterAllClosed: Observable<void>;
+    readonly afterOpen: Subject<MatDialogRef<any>>;
+    readonly afterOpened: Subject<MatDialogRef<any>>;
+    readonly openDialogs: MatDialogRef<any>[];
+    constructor(_overlay: Overlay, _injector: Injector, _location: Location, _defaultOptions: MatDialogConfig, scrollStrategy: any, _parentDialog: MatDialog, _overlayContainer: OverlayContainer);
+    closeAll(): void;
+    getDialogById(id: string): MatDialogRef<any> | undefined;
+    ngOnDestroy(): void;
+    open<T, D = any, R = any>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, config?: MatDialogConfig<D>): MatDialogRef<T, R>;
+}
+
+export declare class MatDialogActions {
+}
+
+export declare const matDialogAnimations: {
+    readonly dialogContainer: AnimationTriggerMetadata;
+    readonly slideDialog: AnimationTriggerMetadata;
+};
+
+export declare class MatDialogClose implements OnInit, OnChanges {
+    _matDialogClose: any;
+    ariaLabel: string;
+    dialogRef: MatDialogRef<any>;
+    dialogResult: any;
+    constructor(dialogRef: MatDialogRef<any>, _elementRef: ElementRef<HTMLElement>, _dialog: MatDialog);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+}
+
+export declare class MatDialogConfig<D = any> {
+    ariaDescribedBy?: string | null;
+    ariaLabel?: string | null;
+    autoFocus?: boolean;
+    backdropClass?: string;
+    closeOnNavigation?: boolean;
+    data?: D | null;
+    direction?: Direction;
+    disableClose?: boolean;
+    hasBackdrop?: boolean;
+    height?: string;
+    id?: string;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+    panelClass?: string | string[];
+    position?: DialogPosition;
+    restoreFocus?: boolean;
+    role?: DialogRole;
+    scrollStrategy?: ScrollStrategy;
+    viewContainerRef?: ViewContainerRef;
+    width?: string;
+}
+
+export declare class MatDialogContainer extends BasePortalOutlet {
+    _animationStateChanged: EventEmitter<AnimationEvent>;
+    _ariaLabelledBy: string | null;
+    _config: MatDialogConfig;
+    _id: string;
+    _portalOutlet: CdkPortalOutlet;
+    _state: 'void' | 'enter' | 'exit';
+    constructor(_elementRef: ElementRef, _focusTrapFactory: FocusTrapFactory, _changeDetectorRef: ChangeDetectorRef, _document: any,
+    _config: MatDialogConfig);
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
+    _startExitAnimation(): void;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+}
+
+export declare class MatDialogContent {
+}
+
+export declare class MatDialogModule {
+}
+
+export declare class MatDialogRef<T, R = any> {
+    _containerInstance: MatDialogContainer;
+    componentInstance: T;
+    disableClose: boolean | undefined;
+    readonly id: string;
+    constructor(_overlayRef: OverlayRef, _containerInstance: MatDialogContainer, _location?: Location, id?: string);
+    afterClosed(): Observable<R | undefined>;
+    afterOpen(): Observable<void>;
+    afterOpened(): Observable<void>;
+    backdropClick(): Observable<MouseEvent>;
+    beforeClose(): Observable<R | undefined>;
+    beforeClosed(): Observable<R | undefined>;
+    close(dialogResult?: R): void;
+    keydownEvents(): Observable<KeyboardEvent>;
+    updatePosition(position?: DialogPosition): this;
+    updateSize(width?: string, height?: string): this;
+}
+
+export declare class MatDialogTitle implements OnInit {
+    id: string;
+    constructor(_dialogRef: MatDialogRef<any>, _elementRef: ElementRef<HTMLElement>, _dialog: MatDialog);
+    ngOnInit(): void;
+}
+
+export declare function throwMatDialogContentAlreadyAttachedError(): void;
@@ -0,0 +1,7 @@
+export declare class MatDivider {
+    inset: boolean;
+    vertical: boolean;
+}
+
+export declare class MatDividerModule {
+}
@@ -0,0 +1,91 @@
+export declare const EXPANSION_PANEL_ANIMATION_TIMING = "225ms cubic-bezier(0.4,0.0,0.2,1)";
+
+export declare const MAT_ACCORDION: InjectionToken<MatAccordionBase>;
+
+export declare const MAT_EXPANSION_PANEL_DEFAULT_OPTIONS: InjectionToken<MatExpansionPanelDefaultOptions>;
+
+export declare class MatAccordion extends CdkAccordion implements MatAccordionBase, AfterContentInit {
+    _headers: QueryList<MatExpansionPanelHeader>;
+    displayMode: MatAccordionDisplayMode;
+    hideToggle: boolean;
+    _handleHeaderFocus(header: MatExpansionPanelHeader): void;
+    _handleHeaderKeydown(event: KeyboardEvent): void;
+    ngAfterContentInit(): void;
+}
+
+export interface MatAccordionBase extends CdkAccordion {
+    _handleHeaderFocus: (header: any) => void;
+    _handleHeaderKeydown: (event: KeyboardEvent) => void;
+    displayMode: MatAccordionDisplayMode;
+    hideToggle: boolean;
+}
+
+export declare type MatAccordionDisplayMode = 'default' | 'flat';
+
+export declare const matExpansionAnimations: {
+    readonly indicatorRotate: AnimationTriggerMetadata;
+    readonly expansionHeaderHeight: AnimationTriggerMetadata;
+    readonly bodyExpansion: AnimationTriggerMetadata;
+};
+
+export declare class MatExpansionModule {
+}
+
+export declare class MatExpansionPanel extends CdkAccordionItem implements AfterContentInit, OnChanges, OnDestroy {
+    _animationMode?: string | undefined;
+    _body: ElementRef<HTMLElement>;
+    _bodyAnimationDone: Subject<AnimationEvent>;
+    _headerId: string;
+    readonly _inputChanges: Subject<SimpleChanges>;
+    _lazyContent: MatExpansionPanelContent;
+    _portal: TemplatePortal;
+    accordion: MatAccordionBase;
+    afterCollapse: EventEmitter<void>;
+    afterExpand: EventEmitter<void>;
+    hideToggle: boolean;
+    constructor(accordion: MatAccordionBase, _changeDetectorRef: ChangeDetectorRef, _uniqueSelectionDispatcher: UniqueSelectionDispatcher, _viewContainerRef: ViewContainerRef, _document?: any, _animationMode?: string | undefined, defaultOptions?: MatExpansionPanelDefaultOptions);
+    _containsFocus(): boolean;
+    _getExpandedState(): MatExpansionPanelState;
+    _hasSpacing(): boolean;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatExpansionPanelActionRow {
+}
+
+export declare class MatExpansionPanelContent {
+    _template: TemplateRef<any>;
+    constructor(_template: TemplateRef<any>);
+}
+
+export interface MatExpansionPanelDefaultOptions {
+    collapsedHeight: string;
+    expandedHeight: string;
+    hideToggle: boolean;
+}
+
+export declare class MatExpansionPanelDescription {
+}
+
+export declare class MatExpansionPanelHeader implements OnDestroy, FocusableOption {
+    collapsedHeight: string;
+    readonly disabled: any;
+    expandedHeight: string;
+    panel: MatExpansionPanel;
+    constructor(panel: MatExpansionPanel, _element: ElementRef, _focusMonitor: FocusMonitor, _changeDetectorRef: ChangeDetectorRef, defaultOptions?: MatExpansionPanelDefaultOptions);
+    _getExpandedState(): string;
+    _getPanelId(): string;
+    _isExpanded(): boolean;
+    _keydown(event: KeyboardEvent): void;
+    _showToggle(): boolean;
+    _toggle(): void;
+    focus(origin?: FocusOrigin): void;
+    ngOnDestroy(): void;
+}
+
+export declare type MatExpansionPanelState = 'expanded' | 'collapsed';
+
+export declare class MatExpansionPanelTitle {
+}
@@ -0,0 +1,107 @@
+export declare const _MatFormFieldMixinBase: CanColorCtor & typeof MatFormFieldBase;
+
+export declare function getMatFormFieldDuplicatedHintError(align: string): Error;
+
+export declare function getMatFormFieldMissingControlError(): Error;
+
+export declare function getMatFormFieldPlaceholderConflictError(): Error;
+
+export declare const MAT_FORM_FIELD_DEFAULT_OPTIONS: InjectionToken<MatFormFieldDefaultOptions>;
+
+export declare class MatError {
+    id: string;
+}
+
+export declare class MatFormField extends _MatFormFieldMixinBase implements AfterContentInit, AfterContentChecked, AfterViewInit, OnDestroy, CanColor {
+    _animationsEnabled: boolean;
+    _appearance: MatFormFieldAppearance;
+    readonly _canLabelFloat: boolean;
+    _connectionContainerRef: ElementRef;
+    _control: MatFormFieldControl<any>;
+    _elementRef: ElementRef;
+    _errorChildren: QueryList<MatError>;
+    _hintChildren: QueryList<MatHint>;
+    _hintLabelId: string;
+    _inputContainerRef: ElementRef;
+    _labelChild: MatLabel;
+    _labelId: string;
+    _placeholderChild: MatPlaceholder;
+    _prefixChildren: QueryList<MatPrefix>;
+    readonly _shouldAlwaysFloat: boolean;
+    _subscriptAnimationState: string;
+    _suffixChildren: QueryList<MatSuffix>;
+    appearance: MatFormFieldAppearance;
+    floatLabel: FloatLabelType;
+    hideRequiredMarker: boolean;
+    hintLabel: string;
+    underlineRef: ElementRef;
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, labelOptions: LabelOptions, _dir: Directionality, _defaults: MatFormFieldDefaultOptions, _platform?: Platform | undefined, _ngZone?: NgZone | undefined, _animationMode?: string);
+    _animateAndLockLabel(): void;
+    _getDisplayedMessages(): 'error' | 'hint';
+    _hasFloatingLabel(): boolean;
+    _hasLabel(): boolean;
+    _hasPlaceholder(): boolean;
+    _hideControlPlaceholder(): boolean;
+    _shouldForward(prop: keyof NgControl): boolean;
+    _shouldLabelFloat(): boolean;
+    protected _validateControlChild(): void;
+    getConnectedOverlayOrigin(): ElementRef;
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    updateOutlineGap(): void;
+}
+
+export declare const matFormFieldAnimations: {
+    readonly transitionMessages: AnimationTriggerMetadata;
+};
+
+export declare type MatFormFieldAppearance = 'legacy' | 'standard' | 'fill' | 'outline';
+
+export declare class MatFormFieldBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare abstract class MatFormFieldControl<T> {
+    readonly autofilled?: boolean;
+    readonly controlType?: string;
+    readonly disabled: boolean;
+    readonly empty: boolean;
+    readonly errorState: boolean;
+    readonly focused: boolean;
+    readonly id: string;
+    readonly ngControl: NgControl | null;
+    readonly placeholder: string;
+    readonly required: boolean;
+    readonly shouldLabelFloat: boolean;
+    readonly stateChanges: Observable<void>;
+    value: T | null;
+    abstract onContainerClick(event: MouseEvent): void;
+    abstract setDescribedByIds(ids: string[]): void;
+}
+
+export interface MatFormFieldDefaultOptions {
+    appearance?: MatFormFieldAppearance;
+}
+
+export declare class MatFormFieldModule {
+}
+
+export declare class MatHint {
+    align: 'start' | 'end';
+    id: string;
+}
+
+export declare class MatLabel {
+}
+
+export declare class MatPlaceholder {
+}
+
+export declare class MatPrefix {
+}
+
+export declare class MatSuffix {
+}
@@ -0,0 +1,38 @@
+export declare class MatGridAvatarCssMatStyler {
+}
+
+export declare class MatGridList implements MatGridListBase, OnInit, AfterContentChecked {
+    _tiles: QueryList<MatGridTile>;
+    cols: number;
+    gutterSize: string;
+    rowHeight: string | number;
+    constructor(_element: ElementRef<HTMLElement>, _dir: Directionality);
+    _setListStyle(style: [string, string | null] | null): void;
+    ngAfterContentChecked(): void;
+    ngOnInit(): void;
+}
+
+export declare class MatGridListModule {
+}
+
+export declare class MatGridTile {
+    _colspan: number;
+    _gridList?: MatGridListBase | undefined;
+    _rowspan: number;
+    colspan: number;
+    rowspan: number;
+    constructor(_element: ElementRef<HTMLElement>, _gridList?: MatGridListBase | undefined);
+    _setStyle(property: string, value: any): void;
+}
+
+export declare class MatGridTileFooterCssMatStyler {
+}
+
+export declare class MatGridTileHeaderCssMatStyler {
+}
+
+export declare class MatGridTileText implements AfterContentInit {
+    _lines: QueryList<MatLine>;
+    constructor(_element: ElementRef<HTMLElement>);
+    ngAfterContentInit(): void;
+}
@@ -0,0 +1,64 @@
+export declare const _MatIconMixinBase: CanColorCtor & typeof MatIconBase;
+
+export declare function getMatIconFailedToSanitizeLiteralError(literal: SafeHtml): Error;
+
+export declare function getMatIconFailedToSanitizeUrlError(url: SafeResourceUrl): Error;
+
+export declare function getMatIconNameNotFoundError(iconName: string): Error;
+
+export declare function getMatIconNoHttpProviderError(): Error;
+
+export declare const ICON_REGISTRY_PROVIDER: {
+    provide: typeof MatIconRegistry;
+    deps: (Optional[] | typeof DomSanitizer)[];
+    useFactory: typeof ICON_REGISTRY_PROVIDER_FACTORY;
+};
+
+export declare function ICON_REGISTRY_PROVIDER_FACTORY(parentRegistry: MatIconRegistry, httpClient: HttpClient, sanitizer: DomSanitizer, document?: any): MatIconRegistry;
+
+export declare const MAT_ICON_LOCATION: InjectionToken<MatIconLocation>;
+
+export declare function MAT_ICON_LOCATION_FACTORY(): MatIconLocation;
+
+export declare class MatIcon extends _MatIconMixinBase implements OnChanges, OnInit, AfterViewChecked, CanColor, OnDestroy {
+    fontIcon: string;
+    fontSet: string;
+    inline: boolean;
+    svgIcon: string;
+    constructor(elementRef: ElementRef<HTMLElement>, _iconRegistry: MatIconRegistry, ariaHidden: string,
+    _location?: MatIconLocation | undefined);
+    ngAfterViewChecked(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare class MatIconBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export interface MatIconLocation {
+    getPathname: () => string;
+}
+
+export declare class MatIconModule {
+}
+
+export declare class MatIconRegistry {
+    constructor(_httpClient: HttpClient, _sanitizer: DomSanitizer, document: any);
+    addSvgIcon(iconName: string, url: SafeResourceUrl): this;
+    addSvgIconInNamespace(namespace: string, iconName: string, url: SafeResourceUrl): this;
+    addSvgIconLiteral(iconName: string, literal: SafeHtml): this;
+    addSvgIconLiteralInNamespace(namespace: string, iconName: string, literal: SafeHtml): this;
+    addSvgIconSet(url: SafeResourceUrl): this;
+    addSvgIconSetInNamespace(namespace: string, url: SafeResourceUrl): this;
+    addSvgIconSetLiteral(literal: SafeHtml): this;
+    addSvgIconSetLiteralInNamespace(namespace: string, literal: SafeHtml): this;
+    classNameForFontAlias(alias: string): string;
+    getDefaultFontSetClass(): string;
+    getNamedSvgIcon(name: string, namespace?: string): Observable<SVGElement>;
+    getSvgIconFromUrl(safeUrl: SafeResourceUrl): Observable<SVGElement>;
+    registerFontClassAlias(alias: string, className?: string): this;
+    setDefaultFontSetClass(className: string): this;
+}
@@ -0,0 +1,72 @@
+export declare const _MatInputMixinBase: CanUpdateErrorStateCtor & typeof MatInputBase;
+
+export declare function getMatInputUnsupportedTypeError(type: string): Error;
+
+export declare const MAT_INPUT_VALUE_ACCESSOR: InjectionToken<{
+    value: any;
+}>;
+
+export declare class MatInput extends _MatInputMixinBase implements MatFormFieldControl<any>, OnChanges, OnDestroy, OnInit, DoCheck, CanUpdateErrorState {
+    _ariaDescribedby: string;
+    protected _disabled: boolean;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    protected _id: string;
+    _isNativeSelect: boolean;
+    _isServer: boolean;
+    protected _neverEmptyInputTypes: string[];
+    protected _platform: Platform;
+    protected _previousNativeValue: any;
+    protected _required: boolean;
+    protected _type: string;
+    protected _uid: string;
+    autofilled: boolean;
+    controlType: string;
+    disabled: boolean;
+    readonly empty: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    focused: boolean;
+    id: string;
+    ngControl: NgControl;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    readonly shouldLabelFloat: boolean;
+    readonly stateChanges: Subject<void>;
+    type: string;
+    value: string;
+    constructor(_elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>, _platform: Platform,
+    ngControl: NgControl, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _defaultErrorStateMatcher: ErrorStateMatcher, inputValueAccessor: any, _autofillMonitor: AutofillMonitor, ngZone: NgZone);
+    protected _dirtyCheckNativeValue(): void;
+    _focusChanged(isFocused: boolean): void;
+    protected _isBadInput(): boolean;
+    protected _isNeverEmpty(): boolean;
+    protected _isTextarea(): boolean;
+    _onInput(): void;
+    protected _validateType(): void;
+    focus(): void;
+    ngDoCheck(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    onContainerClick(): void;
+    setDescribedByIds(ids: string[]): void;
+}
+
+export declare class MatInputBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _parentForm: NgForm, _parentFormGroup: FormGroupDirective,
+    ngControl: NgControl);
+}
+
+export declare class MatInputModule {
+}
+
+export declare class MatTextareaAutosize extends CdkTextareaAutosize {
+    matAutosize: boolean;
+    matAutosizeMaxRows: number;
+    matAutosizeMinRows: number;
+    matTextareaAutosize: boolean;
+}
@@ -0,0 +1 @@
+export declare const VERSION: Version;
@@ -0,0 +1,112 @@
+export declare const _MatListItemMixinBase: CanDisableRippleCtor & typeof MatListItemBase;
+
+export declare const _MatListMixinBase: CanDisableRippleCtor & typeof MatListBase;
+
+export declare const _MatListOptionMixinBase: CanDisableRippleCtor & typeof MatListOptionBase;
+
+export declare const _MatSelectionListMixinBase: CanDisableRippleCtor & typeof MatSelectionListBase;
+
+export declare const MAT_SELECTION_LIST_VALUE_ACCESSOR: any;
+
+export declare class MatList extends _MatListMixinBase implements CanDisableRipple {
+    constructor(_elementRef?: ElementRef<HTMLElement> | undefined);
+    _getListType(): 'list' | 'action-list' | null;
+}
+
+export declare class MatListAvatarCssMatStyler {
+}
+
+export declare class MatListBase {
+}
+
+export declare class MatListIconCssMatStyler {
+}
+
+export declare class MatListItem extends _MatListItemMixinBase implements AfterContentInit, CanDisableRipple {
+    _avatar: MatListAvatarCssMatStyler;
+    _icon: MatListIconCssMatStyler;
+    _lines: QueryList<MatLine>;
+    constructor(_element: ElementRef<HTMLElement>, navList?: MatNavList, list?: MatList);
+    _getHostElement(): HTMLElement;
+    _isRippleDisabled(): boolean;
+    ngAfterContentInit(): void;
+}
+
+export declare class MatListItemBase {
+}
+
+export declare class MatListModule {
+}
+
+export declare class MatListOption extends _MatListOptionMixinBase implements AfterContentInit, OnDestroy, OnInit, FocusableOption, CanDisableRipple {
+    _avatar: MatListAvatarCssMatStyler;
+    _icon: MatListIconCssMatStyler;
+    _lines: QueryList<MatLine>;
+    _text: ElementRef;
+    checkboxPosition: 'before' | 'after';
+    disabled: any;
+    selected: boolean;
+    selectionList: MatSelectionList;
+    value: any;
+    constructor(_element: ElementRef<HTMLElement>, _changeDetector: ChangeDetectorRef,
+    selectionList: MatSelectionList);
+    _getHostElement(): HTMLElement;
+    _handleBlur(): void;
+    _handleClick(): void;
+    _handleFocus(): void;
+    _isRippleDisabled(): any;
+    _markForCheck(): void;
+    _setSelected(selected: boolean): boolean;
+    focus(): void;
+    getLabel(): any;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    toggle(): void;
+}
+
+export declare class MatListOptionBase {
+}
+
+export declare class MatListSubheaderCssMatStyler {
+}
+
+export declare class MatNavList extends _MatListMixinBase implements CanDisableRipple {
+}
+
+export declare class MatSelectionList extends _MatSelectionListMixinBase implements FocusableOption, CanDisableRipple, AfterContentInit, ControlValueAccessor, OnDestroy {
+    _keyManager: FocusKeyManager<MatListOption>;
+    _onTouched: () => void;
+    compareWith: (o1: any, o2: any) => boolean;
+    disabled: boolean;
+    options: QueryList<MatListOption>;
+    selectedOptions: SelectionModel<MatListOption>;
+    readonly selectionChange: EventEmitter<MatSelectionListChange>;
+    tabIndex: number;
+    constructor(_element: ElementRef<HTMLElement>, tabIndex: string);
+    _emitChangeEvent(option: MatListOption): void;
+    _keydown(event: KeyboardEvent): void;
+    _removeOptionFromList(option: MatListOption): MatListOption | null;
+    _reportValueChange(): void;
+    _setFocusedOption(option: MatListOption): void;
+    deselectAll(): void;
+    focus(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    selectAll(): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(values: string[]): void;
+}
+
+export declare class MatSelectionListBase {
+}
+
+export declare class MatSelectionListChange {
+    option: MatListOption;
+    source: MatSelectionList;
+    constructor(
+    source: MatSelectionList,
+    option: MatListOption);
+}
@@ -0,0 +1,132 @@
+export declare const fadeInItems: AnimationTriggerMetadata;
+
+export declare const MAT_MENU_DEFAULT_OPTIONS: InjectionToken<MatMenuDefaultOptions>;
+
+export declare const MAT_MENU_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare class MatMenu implements AfterContentInit, MatMenuPanel<MatMenuItem>, OnInit, OnDestroy {
+    _animationDone: Subject<AnimationEvent>;
+    _classList: {
+        [key: string]: boolean;
+    };
+    _isAnimating: boolean;
+    _panelAnimationState: 'void' | 'enter';
+    backdropClass: string;
+    classList: string;
+    close: EventEmitter<void | "click" | "keydown" | "tab">;
+    readonly closed: EventEmitter<void | 'click' | 'keydown' | 'tab'>;
+    direction: Direction;
+    hasBackdrop: boolean | undefined;
+    items: QueryList<MatMenuItem>;
+    lazyContent: MatMenuContent;
+    overlapTrigger: boolean;
+    panelClass: string;
+    parentMenu: MatMenuPanel | undefined;
+    templateRef: TemplateRef<any>;
+    xPosition: MenuPositionX;
+    yPosition: MenuPositionY;
+    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone, _defaultOptions: MatMenuDefaultOptions);
+    _handleKeydown(event: KeyboardEvent): void;
+    _hovered(): Observable<MatMenuItem>;
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
+    _resetAnimation(): void;
+    _startAnimation(): void;
+    addItem(item: MatMenuItem): void;
+    focusFirstItem(origin?: FocusOrigin): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    removeItem(item: MatMenuItem): void;
+    resetActiveItem(): void;
+    setElevation(depth: number): void;
+    setPositionClasses(posX?: MenuPositionX, posY?: MenuPositionY): void;
+}
+
+export declare const matMenuAnimations: {
+    readonly transformMenu: AnimationTriggerMetadata;
+    readonly fadeInItems: AnimationTriggerMetadata;
+};
+
+export declare class MatMenuContent implements OnDestroy {
+    _attached: Subject<void>;
+    constructor(_template: TemplateRef<any>, _componentFactoryResolver: ComponentFactoryResolver, _appRef: ApplicationRef, _injector: Injector, _viewContainerRef: ViewContainerRef, _document: any);
+    attach(context?: any): void;
+    detach(): void;
+    ngOnDestroy(): void;
+}
+
+export interface MatMenuDefaultOptions {
+    backdropClass: string;
+    hasBackdrop?: boolean;
+    overlapTrigger: boolean;
+    xPosition: MenuPositionX;
+    yPosition: MenuPositionY;
+}
+
+export declare class MatMenuItem extends _MatMenuItemMixinBase implements FocusableOption, CanDisable, CanDisableRipple, OnDestroy {
+    _highlighted: boolean;
+    readonly _hovered: Subject<MatMenuItem>;
+    _triggersSubmenu: boolean;
+    role: 'menuitem' | 'menuitemradio' | 'menuitemcheckbox';
+    constructor(_elementRef: ElementRef<HTMLElement>, document?: any, _focusMonitor?: FocusMonitor | undefined, _parentMenu?: MatMenuPanel<MatMenuItem> | undefined);
+    _checkDisabled(event: Event): void;
+    _getHostElement(): HTMLElement;
+    _getTabIndex(): string;
+    _handleMouseEnter(): void;
+    focus(origin?: FocusOrigin): void;
+    getLabel(): string;
+    ngOnDestroy(): void;
+}
+
+export declare class MatMenuModule {
+}
+
+export interface MatMenuPanel<T = any> {
+    addItem?: (item: T) => void;
+    backdropClass?: string;
+    close: EventEmitter<void | 'click' | 'keydown' | 'tab'>;
+    direction?: Direction;
+    focusFirstItem: (origin?: FocusOrigin) => void;
+    hasBackdrop?: boolean;
+    lazyContent?: MatMenuContent;
+    overlapTrigger: boolean;
+    parentMenu?: MatMenuPanel | undefined;
+    removeItem?: (item: T) => void;
+    resetActiveItem: () => void;
+    setPositionClasses?: (x: MenuPositionX, y: MenuPositionY) => void;
+    templateRef: TemplateRef<any>;
+    xPosition: MenuPositionX;
+    yPosition: MenuPositionY;
+    setElevation?(depth: number): void;
+}
+
+export declare class MatMenuTrigger implements AfterContentInit, OnDestroy {
+    _deprecatedMatMenuTriggerFor: MatMenuPanel;
+    _openedBy: 'mouse' | 'touch' | null;
+    readonly dir: Direction;
+    menu: MatMenuPanel;
+    readonly menuClosed: EventEmitter<void>;
+    menuData: any;
+    readonly menuOpen: boolean;
+    readonly menuOpened: EventEmitter<void>;
+    readonly onMenuClose: EventEmitter<void>;
+    readonly onMenuOpen: EventEmitter<void>;
+    constructor(_overlay: Overlay, _element: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, scrollStrategy: any, _parentMenu: MatMenu, _menuItemInstance: MatMenuItem, _dir: Directionality, _focusMonitor?: FocusMonitor | undefined);
+    _handleClick(event: MouseEvent): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    _handleMousedown(event: MouseEvent): void;
+    closeMenu(): void;
+    focus(origin?: FocusOrigin): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    openMenu(): void;
+    toggleMenu(): void;
+    triggersSubmenu(): boolean;
+}
+
+export declare type MenuPositionX = 'before' | 'after';
+
+export declare type MenuPositionY = 'above' | 'below';
+
+export declare const transformMenu: AnimationTriggerMetadata;
@@ -0,0 +1,60 @@
+export declare const _MatPaginatorBase: CanDisableCtor & HasInitializedCtor & typeof MatPaginatorBase;
+
+export declare const MAT_PAGINATOR_INTL_PROVIDER: {
+    provide: typeof MatPaginatorIntl;
+    deps: Optional[][];
+    useFactory: typeof MAT_PAGINATOR_INTL_PROVIDER_FACTORY;
+};
+
+export declare function MAT_PAGINATOR_INTL_PROVIDER_FACTORY(parentIntl: MatPaginatorIntl): MatPaginatorIntl;
+
+export declare class MatPaginator extends _MatPaginatorBase implements OnInit, OnDestroy, CanDisable, HasInitialized {
+    _displayedPageSizeOptions: number[];
+    _intl: MatPaginatorIntl;
+    _length: number;
+    _pageIndex: number;
+    color: ThemePalette;
+    hidePageSize: boolean;
+    length: number;
+    readonly page: EventEmitter<PageEvent>;
+    pageIndex: number;
+    pageSize: number;
+    pageSizeOptions: number[];
+    showFirstLastButtons: boolean;
+    constructor(_intl: MatPaginatorIntl, _changeDetectorRef: ChangeDetectorRef);
+    _changePageSize(pageSize: number): void;
+    _nextButtonsDisabled(): boolean;
+    _previousButtonsDisabled(): boolean;
+    firstPage(): void;
+    getNumberOfPages(): number;
+    hasNextPage(): boolean;
+    hasPreviousPage(): boolean;
+    lastPage(): void;
+    nextPage(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    previousPage(): void;
+}
+
+export declare class MatPaginatorBase {
+}
+
+export declare class MatPaginatorIntl {
+    readonly changes: Subject<void>;
+    firstPageLabel: string;
+    getRangeLabel: (page: number, pageSize: number, length: number) => string;
+    itemsPerPageLabel: string;
+    lastPageLabel: string;
+    nextPageLabel: string;
+    previousPageLabel: string;
+}
+
+export declare class MatPaginatorModule {
+}
+
+export declare class PageEvent {
+    length: number;
+    pageIndex: number;
+    pageSize: number;
+    previousPageIndex?: number;
+}
@@ -0,0 +1,44 @@
+export declare const _MatProgressBarMixinBase: CanColorCtor & typeof MatProgressBarBase;
+
+export declare const MAT_PROGRESS_BAR_LOCATION: InjectionToken<MatProgressBarLocation>;
+
+export declare function MAT_PROGRESS_BAR_LOCATION_FACTORY(): MatProgressBarLocation;
+
+export declare class MatProgressBar extends _MatProgressBarMixinBase implements CanColor, AfterViewInit, OnDestroy {
+    _animationMode?: string | undefined;
+    _elementRef: ElementRef;
+    _isNoopAnimation: boolean;
+    _primaryValueBar: ElementRef;
+    _rectangleFillValue: string;
+    animationEnd: EventEmitter<ProgressAnimationEnd>;
+    bufferValue: number;
+    mode: 'determinate' | 'indeterminate' | 'buffer' | 'query';
+    progressbarId: string;
+    value: number;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone, _animationMode?: string | undefined,
+    location?: MatProgressBarLocation);
+    _bufferTransform(): {
+        transform: string;
+    } | undefined;
+    _primaryTransform(): {
+        transform: string;
+    };
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatProgressBarBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export interface MatProgressBarLocation {
+    getPathname: () => string;
+}
+
+export declare class MatProgressBarModule {
+}
+
+export interface ProgressAnimationEnd {
+    value: number;
+}
@@ -0,0 +1,37 @@
+export declare const _MatProgressSpinnerMixinBase: CanColorCtor & typeof MatProgressSpinnerBase;
+
+export declare const MAT_PROGRESS_SPINNER_DEFAULT_OPTIONS: InjectionToken<MatProgressSpinnerDefaultOptions>;
+
+export declare function MAT_PROGRESS_SPINNER_DEFAULT_OPTIONS_FACTORY(): MatProgressSpinnerDefaultOptions;
+
+export declare class MatProgressSpinner extends _MatProgressSpinnerMixinBase implements CanColor {
+    readonly _circleRadius: number;
+    readonly _circleStrokeWidth: number;
+    _elementRef: ElementRef;
+    _noopAnimations: boolean;
+    readonly _strokeCircumference: number;
+    readonly _strokeDashOffset: number | null;
+    readonly _viewBox: string;
+    diameter: number;
+    mode: ProgressSpinnerMode;
+    strokeWidth: number;
+    value: number;
+    constructor(_elementRef: ElementRef, platform: Platform, _document: any, animationMode?: string | undefined, defaults?: MatProgressSpinnerDefaultOptions | undefined);
+}
+
+export declare class MatProgressSpinnerBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export interface MatProgressSpinnerDefaultOptions {
+    _forceAnimations?: boolean;
+    diameter?: number;
+    strokeWidth?: number;
+}
+
+export declare class MatSpinner extends MatProgressSpinner {
+    constructor(elementRef: ElementRef, platform: Platform, document: any, animationMode?: string, defaults?: MatProgressSpinnerDefaultOptions);
+}
+
+export declare type ProgressSpinnerMode = 'determinate' | 'indeterminate';
@@ -0,0 +1,75 @@
+export declare const _MatRadioButtonMixinBase: CanColorCtor & CanDisableRippleCtor & HasTabIndexCtor & typeof MatRadioButtonBase;
+
+export declare const _MatRadioGroupMixinBase: CanDisableCtor & typeof MatRadioGroupBase;
+
+export declare const MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR: any;
+
+export declare class MatRadioButton extends _MatRadioButtonMixinBase implements OnInit, AfterViewInit, OnDestroy, CanColor, CanDisableRipple, HasTabIndex {
+    _animationMode?: string | undefined;
+    _inputElement: ElementRef<HTMLInputElement>;
+    ariaDescribedby: string;
+    ariaLabel: string;
+    ariaLabelledby: string;
+    readonly change: EventEmitter<MatRadioChange>;
+    checked: boolean;
+    disabled: boolean;
+    id: string;
+    readonly inputId: string;
+    labelPosition: 'before' | 'after';
+    name: string;
+    radioGroup: MatRadioGroup;
+    required: boolean;
+    value: any;
+    constructor(radioGroup: MatRadioGroup, elementRef: ElementRef, _changeDetector: ChangeDetectorRef, _focusMonitor: FocusMonitor, _radioDispatcher: UniqueSelectionDispatcher, _animationMode?: string | undefined);
+    _isRippleDisabled(): boolean;
+    _markForCheck(): void;
+    _onInputChange(event: Event): void;
+    _onInputClick(event: Event): void;
+    focus(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare class MatRadioButtonBase {
+    _elementRef: ElementRef;
+    disabled: boolean;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatRadioChange {
+    source: MatRadioButton;
+    value: any;
+    constructor(
+    source: MatRadioButton,
+    value: any);
+}
+
+export declare class MatRadioGroup extends _MatRadioGroupMixinBase implements AfterContentInit, ControlValueAccessor, CanDisable {
+    _controlValueAccessorChangeFn: (value: any) => void;
+    _radios: QueryList<MatRadioButton>;
+    readonly change: EventEmitter<MatRadioChange>;
+    disabled: boolean;
+    labelPosition: 'before' | 'after';
+    name: string;
+    onTouched: () => any;
+    required: boolean;
+    selected: MatRadioButton | null;
+    value: any;
+    constructor(_changeDetector: ChangeDetectorRef);
+    _checkSelectedRadioButton(): void;
+    _emitChangeEvent(): void;
+    _markRadiosForCheck(): void;
+    _touch(): void;
+    ngAfterContentInit(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatRadioGroupBase {
+}
+
+export declare class MatRadioModule {
+}
@@ -0,0 +1,137 @@
+export declare const _MatSelectMixinBase: CanDisableCtor & HasTabIndexCtor & CanDisableRippleCtor & CanUpdateErrorStateCtor & typeof MatSelectBase;
+
+export declare const fadeInContent: AnimationTriggerMetadata;
+
+export declare const MAT_SELECT_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare const MAT_SELECT_SCROLL_STRATEGY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY;
+};
+
+export declare function MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare class MatSelect extends _MatSelectMixinBase implements AfterContentInit, OnChanges, OnDestroy, OnInit, DoCheck, ControlValueAccessor, CanDisable, HasTabIndex, MatFormFieldControl<any>, CanUpdateErrorState, CanDisableRipple {
+    _ariaDescribedby: string;
+    readonly _closedStream: Observable<void>;
+    _keyManager: ActiveDescendantKeyManager<MatOption>;
+    _offsetY: number;
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    readonly _openedStream: Observable<void>;
+    _optionIds: string;
+    _panelDoneAnimatingStream: Subject<string>;
+    _positions: {
+        originX: string;
+        originY: string;
+        overlayX: string;
+        overlayY: string;
+    }[];
+    _scrollStrategy: ScrollStrategy;
+    _selectionModel: SelectionModel<MatOption>;
+    _transformOrigin: string;
+    _triggerFontSize: number;
+    _triggerRect: ClientRect;
+    ariaLabel: string;
+    ariaLabelledby: string;
+    compareWith: (o1: any, o2: any) => boolean;
+    controlType: string;
+    customTrigger: MatSelectTrigger;
+    disableOptionCentering: boolean;
+    readonly empty: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    focused: boolean;
+    id: string;
+    multiple: boolean;
+    ngControl: NgControl;
+    readonly openedChange: EventEmitter<boolean>;
+    optionGroups: QueryList<MatOptgroup>;
+    readonly optionSelectionChanges: Observable<MatOptionSelectionChange>;
+    options: QueryList<MatOption>;
+    overlayDir: CdkConnectedOverlay;
+    panel: ElementRef;
+    panelClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    readonly panelOpen: boolean;
+    placeholder: string;
+    required: boolean;
+    readonly selected: MatOption | MatOption[];
+    readonly selectionChange: EventEmitter<MatSelectChange>;
+    readonly shouldLabelFloat: boolean;
+    sortComparator: (a: MatOption, b: MatOption, options: MatOption[]) => number;
+    trigger: ElementRef;
+    readonly triggerValue: string;
+    value: any;
+    readonly valueChange: EventEmitter<any>;
+    constructor(_viewportRuler: ViewportRuler, _changeDetectorRef: ChangeDetectorRef, _ngZone: NgZone, _defaultErrorStateMatcher: ErrorStateMatcher, elementRef: ElementRef, _dir: Directionality, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _parentFormField: MatFormField, ngControl: NgControl, tabIndex: string, scrollStrategyFactory: any,
+    _liveAnnouncer?: LiveAnnouncer | undefined);
+    _calculateOverlayScroll(selectedIndex: number, scrollBuffer: number, maxScroll: number): number;
+    _getAriaActiveDescendant(): string | null;
+    _getAriaLabel(): string | null;
+    _getAriaLabelledby(): string | null;
+    _getPanelTheme(): string;
+    _handleKeydown(event: KeyboardEvent): void;
+    _isRtl(): boolean;
+    _onAttached(): void;
+    _onBlur(): void;
+    _onFocus(): void;
+    close(): void;
+    focus(): void;
+    ngAfterContentInit(): void;
+    ngDoCheck(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    onContainerClick(): void;
+    open(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => {}): void;
+    setDescribedByIds(ids: string[]): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggle(): void;
+    writeValue(value: any): void;
+}
+
+export declare const matSelectAnimations: {
+    readonly transformPanel: AnimationTriggerMetadata;
+    readonly fadeInContent: AnimationTriggerMetadata;
+};
+
+export declare class MatSelectBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _elementRef: ElementRef;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    constructor(_elementRef: ElementRef, _defaultErrorStateMatcher: ErrorStateMatcher, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+}
+
+export declare class MatSelectChange {
+    source: MatSelect;
+    value: any;
+    constructor(
+    source: MatSelect,
+    value: any);
+}
+
+export declare class MatSelectModule {
+}
+
+export declare class MatSelectTrigger {
+}
+
+export declare const SELECT_ITEM_HEIGHT_EM = 3;
+
+export declare let SELECT_MULTIPLE_PANEL_PADDING_X: number;
+
+export declare const SELECT_PANEL_INDENT_PADDING_X: number;
+
+export declare const SELECT_PANEL_MAX_HEIGHT = 256;
+
+export declare const SELECT_PANEL_PADDING_X = 16;
+
+export declare const SELECT_PANEL_VIEWPORT_PADDING = 8;
+
+export declare const transformPanel: AnimationTriggerMetadata;
@@ -0,0 +1,93 @@
+export declare const MAT_DRAWER_DEFAULT_AUTOSIZE: InjectionToken<boolean>;
+
+export declare function MAT_DRAWER_DEFAULT_AUTOSIZE_FACTORY(): boolean;
+
+export declare class MatDrawer implements AfterContentInit, AfterContentChecked, OnDestroy {
+    _animationEnd: Subject<AnimationEvent>;
+    _animationStarted: Subject<AnimationEvent>;
+    _animationState: 'open-instant' | 'open' | 'void';
+    readonly _closedStream: Observable<void>;
+    readonly _isFocusTrapEnabled: boolean;
+    readonly _modeChanged: Subject<{}>;
+    readonly _openedStream: Observable<void>;
+    readonly _width: number;
+    autoFocus: boolean;
+    readonly closedStart: Observable<void>;
+    disableClose: boolean;
+    mode: 'over' | 'push' | 'side';
+    onPositionChanged: EventEmitter<void>;
+    opened: boolean;
+    readonly openedChange: EventEmitter<boolean>;
+    readonly openedStart: Observable<void>;
+    position: 'start' | 'end';
+    constructor(_elementRef: ElementRef<HTMLElement>, _focusTrapFactory: FocusTrapFactory, _focusMonitor: FocusMonitor, _platform: Platform, _ngZone: NgZone, _doc: any);
+    close(): Promise<MatDrawerToggleResult>;
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    open(openedVia?: FocusOrigin): Promise<MatDrawerToggleResult>;
+    toggle(isOpen?: boolean, openedVia?: FocusOrigin): Promise<MatDrawerToggleResult>;
+}
+
+export declare const matDrawerAnimations: {
+    readonly transformDrawer: AnimationTriggerMetadata;
+};
+
+export declare class MatDrawerContainer implements AfterContentInit, DoCheck, OnDestroy {
+    _backdropOverride: boolean | null;
+    _content: MatDrawerContent;
+    readonly _contentMarginChanges: Subject<{
+        left: number | null;
+        right: number | null;
+    }>;
+    _contentMargins: {
+        left: number | null;
+        right: number | null;
+    };
+    _drawers: QueryList<MatDrawer>;
+    _userContent: MatDrawerContent;
+    autosize: boolean;
+    readonly backdropClick: EventEmitter<void>;
+    readonly end: MatDrawer | null;
+    hasBackdrop: any;
+    readonly scrollable: CdkScrollable;
+    readonly start: MatDrawer | null;
+    constructor(_dir: Directionality, _element: ElementRef<HTMLElement>, _ngZone: NgZone, _changeDetectorRef: ChangeDetectorRef, defaultAutosize?: boolean, _animationMode?: string | undefined,
+    viewportRuler?: ViewportRuler);
+    _closeModalDrawer(): void;
+    _isShowingBackdrop(): boolean;
+    _onBackdropClicked(): void;
+    close(): void;
+    ngAfterContentInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    open(): void;
+}
+
+export declare class MatDrawerContent extends CdkScrollable implements AfterContentInit {
+    _container: MatDrawerContainer;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _container: MatDrawerContainer, elementRef: ElementRef<HTMLElement>, scrollDispatcher: ScrollDispatcher, ngZone: NgZone);
+    ngAfterContentInit(): void;
+}
+
+export declare type MatDrawerToggleResult = 'open' | 'close';
+
+export declare class MatSidenav extends MatDrawer {
+    fixedBottomGap: number;
+    fixedInViewport: boolean;
+    fixedTopGap: number;
+}
+
+export declare class MatSidenavContainer extends MatDrawerContainer {
+    _content: MatSidenavContent;
+    _drawers: QueryList<MatSidenav>;
+}
+
+export declare class MatSidenavContent extends MatDrawerContent {
+    constructor(changeDetectorRef: ChangeDetectorRef, container: MatSidenavContainer, elementRef: ElementRef<HTMLElement>, scrollDispatcher: ScrollDispatcher, ngZone: NgZone);
+}
+
+export declare class MatSidenavModule {
+}
+
+export declare function throwMatDuplicatedDrawerError(position: string): void;
@@ -0,0 +1,61 @@
+export declare const _MatSlideToggleMixinBase: HasTabIndexCtor & CanColorCtor & CanDisableRippleCtor & CanDisableCtor & typeof MatSlideToggleBase;
+
+export declare const MAT_SLIDE_TOGGLE_DEFAULT_OPTIONS: InjectionToken<MatSlideToggleDefaultOptions>;
+
+export declare const MAT_SLIDE_TOGGLE_VALUE_ACCESSOR: any;
+
+export declare class MatSlideToggle extends _MatSlideToggleMixinBase implements OnDestroy, AfterContentInit, ControlValueAccessor, CanDisable, CanColor, HasTabIndex, CanDisableRipple {
+    _animationMode?: string | undefined;
+    _inputElement: ElementRef<HTMLInputElement>;
+    _thumbBarEl: ElementRef;
+    _thumbEl: ElementRef;
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    readonly change: EventEmitter<MatSlideToggleChange>;
+    checked: boolean;
+    defaults: MatSlideToggleDefaultOptions;
+    readonly dragChange: EventEmitter<void>;
+    id: string;
+    readonly inputId: string;
+    labelPosition: 'before' | 'after';
+    name: string | null;
+    required: boolean;
+    readonly toggleChange: EventEmitter<void>;
+    constructor(elementRef: ElementRef,
+    _platform: Platform, _focusMonitor: FocusMonitor, _changeDetectorRef: ChangeDetectorRef, tabIndex: string, _ngZone: NgZone, defaults: MatSlideToggleDefaultOptions, _animationMode?: string | undefined, _dir?: Directionality | undefined);
+    _onChangeEvent(event: Event): void;
+    _onDrag(event: HammerInput): void;
+    _onDragEnd(): void;
+    _onDragStart(): void;
+    _onInputClick(event: Event): void;
+    _onLabelTextChange(): void;
+    focus(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggle(): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatSlideToggleBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatSlideToggleChange {
+    checked: boolean;
+    source: MatSlideToggle;
+    constructor(
+    source: MatSlideToggle,
+    checked: boolean);
+}
+
+export interface MatSlideToggleDefaultOptions {
+    disableDragValue?: boolean;
+    disableToggleValue?: boolean;
+}
+
+export declare class MatSlideToggleModule {
+}
@@ -0,0 +1,73 @@
+export declare const _MatSliderMixinBase: HasTabIndexCtor & CanColorCtor & CanDisableCtor & typeof MatSliderBase;
+
+export declare const MAT_SLIDER_VALUE_ACCESSOR: any;
+
+export declare class MatSlider extends _MatSliderMixinBase implements ControlValueAccessor, OnDestroy, CanDisable, CanColor, OnInit, HasTabIndex {
+    _animationMode?: string | undefined;
+    readonly _invertAxis: boolean;
+    _isActive: boolean;
+    readonly _isMinValue: boolean;
+    _isSliding: boolean;
+    readonly _thumbContainerStyles: {
+        [key: string]: string;
+    };
+    readonly _thumbGap: 7 | 10 | 0;
+    readonly _ticksContainerStyles: {
+        [key: string]: string;
+    };
+    readonly _ticksStyles: {
+        [key: string]: string;
+    };
+    readonly _trackBackgroundStyles: {
+        [key: string]: string;
+    };
+    readonly _trackFillStyles: {
+        [key: string]: string;
+    };
+    readonly change: EventEmitter<MatSliderChange>;
+    readonly displayValue: string | number;
+    displayWith: (value: number | null) => string | number;
+    readonly input: EventEmitter<MatSliderChange>;
+    invert: boolean;
+    max: number;
+    min: number;
+    onTouched: () => any;
+    readonly percent: number;
+    step: number;
+    thumbLabel: boolean;
+    tickInterval: 'auto' | number;
+    value: number | null;
+    readonly valueChange: EventEmitter<number | null>;
+    vertical: boolean;
+    constructor(elementRef: ElementRef, _focusMonitor: FocusMonitor, _changeDetectorRef: ChangeDetectorRef, _dir: Directionality, tabIndex: string, _animationMode?: string | undefined);
+    _onBlur(): void;
+    _onFocus(): void;
+    _onKeydown(event: KeyboardEvent): void;
+    _onKeyup(): void;
+    _onMousedown(event: MouseEvent): void;
+    _onMouseenter(): void;
+    _onSlide(event: HammerInput): void;
+    _onSlideEnd(): void;
+    _onSlideStart(event: HammerInput | null): void;
+    blur(): void;
+    focus(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatSliderBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatSliderChange {
+    source: MatSlider;
+    value: number | null;
+}
+
+export declare class MatSliderModule {
+}
@@ -0,0 +1,84 @@
+export declare const MAT_SNACK_BAR_DATA: InjectionToken<any>;
+
+export declare const MAT_SNACK_BAR_DEFAULT_OPTIONS: InjectionToken<MatSnackBarConfig<any>>;
+
+export declare function MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY(): MatSnackBarConfig;
+
+export declare class MatSnackBar implements OnDestroy {
+    _openedSnackBarRef: MatSnackBarRef<any> | null;
+    constructor(_overlay: Overlay, _live: LiveAnnouncer, _injector: Injector, _breakpointObserver: BreakpointObserver, _parentSnackBar: MatSnackBar, _defaultConfig: MatSnackBarConfig);
+    dismiss(): void;
+    ngOnDestroy(): void;
+    open(message: string, action?: string, config?: MatSnackBarConfig): MatSnackBarRef<SimpleSnackBar>;
+    openFromComponent<T>(component: ComponentType<T>, config?: MatSnackBarConfig): MatSnackBarRef<T>;
+    openFromTemplate(template: TemplateRef<any>, config?: MatSnackBarConfig): MatSnackBarRef<EmbeddedViewRef<any>>;
+}
+
+export declare const matSnackBarAnimations: {
+    readonly snackBarState: AnimationTriggerMetadata;
+};
+
+export declare class MatSnackBarConfig<D = any> {
+    announcementMessage?: string;
+    data?: D | null;
+    direction?: Direction;
+    duration?: number;
+    horizontalPosition?: MatSnackBarHorizontalPosition;
+    panelClass?: string | string[];
+    politeness?: AriaLivePoliteness;
+    verticalPosition?: MatSnackBarVerticalPosition;
+    viewContainerRef?: ViewContainerRef;
+}
+
+export declare class MatSnackBarContainer extends BasePortalOutlet implements OnDestroy {
+    _animationState: string;
+    readonly _onEnter: Subject<any>;
+    readonly _onExit: Subject<any>;
+    _portalOutlet: CdkPortalOutlet;
+    _role: 'alert' | 'status' | null;
+    snackBarConfig: MatSnackBarConfig;
+    constructor(_ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef,
+    snackBarConfig: MatSnackBarConfig);
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    enter(): void;
+    exit(): Observable<void>;
+    ngOnDestroy(): void;
+    onAnimationEnd(event: AnimationEvent): void;
+}
+
+export interface MatSnackBarDismiss {
+    dismissedByAction: boolean;
+}
+
+export declare type MatSnackBarHorizontalPosition = 'start' | 'center' | 'end' | 'left' | 'right';
+
+export declare class MatSnackBarModule {
+}
+
+export declare class MatSnackBarRef<T> {
+    containerInstance: MatSnackBarContainer;
+    instance: T;
+    constructor(containerInstance: MatSnackBarContainer, _overlayRef: OverlayRef);
+    _dismissAfter(duration: number): void;
+    _open(): void;
+    afterDismissed(): Observable<MatSnackBarDismiss>;
+    afterOpened(): Observable<void>;
+    closeWithAction(): void;
+    dismiss(): void;
+    dismissWithAction(): void;
+    onAction(): Observable<void>;
+}
+
+export declare type MatSnackBarVerticalPosition = 'top' | 'bottom';
+
+export declare class SimpleSnackBar {
+    data: {
+        message: string;
+        action: string;
+    };
+    readonly hasAction: boolean;
+    snackBarRef: MatSnackBarRef<SimpleSnackBar>;
+    constructor(snackBarRef: MatSnackBarRef<SimpleSnackBar>, data: any);
+    action(): void;
+}
@@ -0,0 +1,97 @@
+export declare const _MatSortHeaderMixinBase: CanDisableCtor & typeof MatSortHeaderBase;
+
+export declare const _MatSortMixinBase: HasInitializedCtor & CanDisableCtor & typeof MatSortBase;
+
+export declare type ArrowViewState = SortDirection | 'hint' | 'active';
+
+export interface ArrowViewStateTransition {
+    fromState?: ArrowViewState;
+    toState: ArrowViewState;
+}
+
+export declare const MAT_SORT_HEADER_INTL_PROVIDER: {
+    provide: typeof MatSortHeaderIntl;
+    deps: Optional[][];
+    useFactory: typeof MAT_SORT_HEADER_INTL_PROVIDER_FACTORY;
+};
+
+export declare function MAT_SORT_HEADER_INTL_PROVIDER_FACTORY(parentIntl: MatSortHeaderIntl): MatSortHeaderIntl;
+
+export declare class MatSort extends _MatSortMixinBase implements CanDisable, HasInitialized, OnChanges, OnDestroy, OnInit {
+    readonly _stateChanges: Subject<void>;
+    active: string;
+    direction: SortDirection;
+    disableClear: boolean;
+    readonly sortChange: EventEmitter<Sort>;
+    sortables: Map<string, MatSortable>;
+    start: 'asc' | 'desc';
+    deregister(sortable: MatSortable): void;
+    getNextSortDirection(sortable: MatSortable): SortDirection;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    register(sortable: MatSortable): void;
+    sort(sortable: MatSortable): void;
+}
+
+export interface MatSortable {
+    disableClear: boolean;
+    id: string;
+    start: 'asc' | 'desc';
+}
+
+export declare const matSortAnimations: {
+    readonly indicator: AnimationTriggerMetadata;
+    readonly leftPointer: AnimationTriggerMetadata;
+    readonly rightPointer: AnimationTriggerMetadata;
+    readonly arrowOpacity: AnimationTriggerMetadata;
+    readonly arrowPosition: AnimationTriggerMetadata;
+    readonly allowChildren: AnimationTriggerMetadata;
+};
+
+export declare class MatSortBase {
+}
+
+export declare class MatSortHeader extends _MatSortHeaderMixinBase implements CanDisable, MatSortable, OnDestroy, OnInit {
+    _arrowDirection: SortDirection;
+    _columnDef: MatSortHeaderColumnDef;
+    _disableViewStateAnimation: boolean;
+    _intl: MatSortHeaderIntl;
+    _showIndicatorHint: boolean;
+    _sort: MatSort;
+    _viewState: ArrowViewStateTransition;
+    arrowPosition: 'before' | 'after';
+    disableClear: boolean;
+    id: string;
+    start: 'asc' | 'desc';
+    constructor(_intl: MatSortHeaderIntl, changeDetectorRef: ChangeDetectorRef, _sort: MatSort, _columnDef: MatSortHeaderColumnDef);
+    _getAriaSortAttribute(): "ascending" | "descending" | null;
+    _getArrowDirectionState(): string;
+    _getArrowViewState(): string;
+    _handleClick(): void;
+    _isDisabled(): boolean;
+    _isSorted(): boolean;
+    _setAnimationTransitionState(viewState: ArrowViewStateTransition): void;
+    _setIndicatorHintVisible(visible: boolean): void;
+    _updateArrowDirection(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare class MatSortHeaderBase {
+}
+
+export declare class MatSortHeaderIntl {
+    readonly changes: Subject<void>;
+    sortButtonLabel: (id: string) => string;
+}
+
+export declare class MatSortModule {
+}
+
+export interface Sort {
+    active: string;
+    direction: SortDirection;
+}
+
+export declare type SortDirection = 'asc' | 'desc' | '';
@@ -0,0 +1,87 @@
+export declare const MAT_STEPPER_INTL_PROVIDER: {
+    provide: typeof MatStepperIntl;
+    deps: Optional[][];
+    useFactory: typeof MAT_STEPPER_INTL_PROVIDER_FACTORY;
+};
+
+export declare function MAT_STEPPER_INTL_PROVIDER_FACTORY(parentIntl: MatStepperIntl): MatStepperIntl;
+
+export declare class MatHorizontalStepper extends MatStepper {
+    labelPosition: 'bottom' | 'end';
+}
+
+export declare class MatStep extends CdkStep implements ErrorStateMatcher {
+    stepLabel: MatStepLabel;
+    constructor(stepper: MatStepper, _errorStateMatcher: ErrorStateMatcher, stepperOptions?: StepperOptions);
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+
+export declare class MatStepHeader extends CdkStepHeader implements OnDestroy {
+    _intl: MatStepperIntl;
+    active: boolean;
+    errorMessage: string;
+    iconOverrides: {
+        [key: string]: TemplateRef<MatStepperIconContext>;
+    };
+    index: number;
+    label: MatStepLabel | string;
+    optional: boolean;
+    selected: boolean;
+    state: StepState;
+    constructor(_intl: MatStepperIntl, _focusMonitor: FocusMonitor, _elementRef: ElementRef<HTMLElement>, changeDetectorRef: ChangeDetectorRef);
+    _getHostElement(): HTMLElement;
+    _getIconContext(): MatStepperIconContext;
+    _stringLabel(): string | null;
+    _templateLabel(): MatStepLabel | null;
+    ngOnDestroy(): void;
+}
+
+export declare class MatStepLabel extends CdkStepLabel {
+}
+
+export declare class MatStepper extends CdkStepper implements AfterContentInit {
+    _animationDone: Subject<AnimationEvent>;
+    _iconOverrides: {
+        [key: string]: TemplateRef<MatStepperIconContext>;
+    };
+    _icons: QueryList<MatStepperIcon>;
+    _stepHeader: QueryList<MatStepHeader>;
+    _steps: QueryList<MatStep>;
+    readonly animationDone: EventEmitter<void>;
+    ngAfterContentInit(): void;
+}
+
+export declare const matStepperAnimations: {
+    readonly horizontalStepTransition: AnimationTriggerMetadata;
+    readonly verticalStepTransition: AnimationTriggerMetadata;
+};
+
+export declare class MatStepperIcon {
+    name: StepState;
+    templateRef: TemplateRef<MatStepperIconContext>;
+    constructor(templateRef: TemplateRef<MatStepperIconContext>);
+}
+
+export interface MatStepperIconContext {
+    active: boolean;
+    index: number;
+    optional: boolean;
+}
+
+export declare class MatStepperIntl {
+    readonly changes: Subject<void>;
+    optionalLabel: string;
+}
+
+export declare class MatStepperModule {
+}
+
+export declare class MatStepperNext extends CdkStepperNext {
+}
+
+export declare class MatStepperPrevious extends CdkStepperPrevious {
+}
+
+export declare class MatVerticalStepper extends MatStepper {
+    constructor(dir: Directionality, changeDetectorRef: ChangeDetectorRef, elementRef?: ElementRef<HTMLElement>, _document?: any);
+}
@@ -0,0 +1,71 @@
+export declare class MatCell extends CdkCell {
+    constructor(columnDef: CdkColumnDef, elementRef: ElementRef<HTMLElement>);
+}
+
+export declare class MatCellDef extends CdkCellDef {
+}
+
+export declare class MatColumnDef extends CdkColumnDef {
+    name: string;
+    sticky: boolean;
+    stickyEnd: boolean;
+}
+
+export declare class MatFooterCell extends CdkFooterCell {
+    constructor(columnDef: CdkColumnDef, elementRef: ElementRef);
+}
+
+export declare class MatFooterCellDef extends CdkFooterCellDef {
+}
+
+export declare class MatFooterRow extends CdkFooterRow {
+}
+
+export declare class MatFooterRowDef extends CdkFooterRowDef {
+}
+
+export declare class MatHeaderCell extends CdkHeaderCell {
+    constructor(columnDef: CdkColumnDef, elementRef: ElementRef<HTMLElement>);
+}
+
+export declare class MatHeaderCellDef extends CdkHeaderCellDef {
+}
+
+export declare class MatHeaderRow extends CdkHeaderRow {
+}
+
+export declare class MatHeaderRowDef extends CdkHeaderRowDef {
+}
+
+export declare class MatRow extends CdkRow {
+}
+
+export declare class MatRowDef<T> extends CdkRowDef<T> {
+}
+
+export declare class MatTable<T> extends CdkTable<T> {
+    protected stickyCssClass: string;
+}
+
+export declare class MatTableDataSource<T> extends DataSource<T> {
+    _renderChangesSubscription: Subscription;
+    data: T[];
+    filter: string;
+    filterPredicate: ((data: T, filter: string) => boolean);
+    filteredData: T[];
+    paginator: MatPaginator | null;
+    sort: MatSort | null;
+    sortData: ((data: T[], sort: MatSort) => T[]);
+    sortingDataAccessor: ((data: T, sortHeaderId: string) => string | number);
+    constructor(initialData?: T[]);
+    _filterData(data: T[]): T[];
+    _orderData(data: T[]): T[];
+    _pageData(data: T[]): T[];
+    _updateChangeSubscription(): void;
+    _updatePaginator(filteredDataLength: number): void;
+    connect(): BehaviorSubject<T[]>;
+    disconnect(): void;
+}
+
+export declare class MatTableModule {
+}
@@ -0,0 +1,192 @@
+export declare const _MAT_INK_BAR_POSITIONER: InjectionToken<_MatInkBarPositioner>;
+
+export interface _MatInkBarPositioner {
+    (element: HTMLElement): {
+        left: string;
+        width: string;
+    };
+}
+
+export declare const _MatTabGroupMixinBase: CanColorCtor & CanDisableRippleCtor & typeof MatTabGroupBase;
+
+export declare const MAT_TABS_CONFIG: InjectionToken<{}>;
+
+export declare class MatInkBar {
+    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone, _inkBarPositioner: _MatInkBarPositioner);
+    alignToElement(element: HTMLElement): void;
+    hide(): void;
+    show(): void;
+}
+
+export declare class MatTab extends _MatTabMixinBase implements OnInit, CanDisable, OnChanges, OnDestroy {
+    _explicitContent: TemplateRef<any>;
+    _implicitContent: TemplateRef<any>;
+    readonly _stateChanges: Subject<void>;
+    ariaLabel: string;
+    ariaLabelledby: string;
+    readonly content: TemplatePortal | null;
+    isActive: boolean;
+    origin: number | null;
+    position: number | null;
+    templateLabel: MatTabLabel;
+    textLabel: string;
+    constructor(_viewContainerRef: ViewContainerRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare class MatTabBody implements OnInit, OnDestroy {
+    readonly _afterLeavingCenter: EventEmitter<boolean>;
+    readonly _beforeCentering: EventEmitter<boolean>;
+    _content: TemplatePortal;
+    readonly _onCentered: EventEmitter<void>;
+    readonly _onCentering: EventEmitter<number>;
+    _portalHost: PortalHostDirective;
+    _position: MatTabBodyPositionState;
+    _translateTabComplete: Subject<AnimationEvent>;
+    animationDuration: string;
+    origin: number;
+    position: number;
+    constructor(_elementRef: ElementRef<HTMLElement>, _dir: Directionality,
+    changeDetectorRef?: ChangeDetectorRef);
+    _getLayoutDirection(): Direction;
+    _isCenterPosition(position: MatTabBodyPositionState | string): boolean;
+    _onTranslateTabStarted(event: AnimationEvent): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare type MatTabBodyOriginState = 'left' | 'right';
+
+export declare class MatTabBodyPortal extends CdkPortalOutlet implements OnInit, OnDestroy {
+    constructor(componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, _host: MatTabBody);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare type MatTabBodyPositionState = 'left' | 'center' | 'right' | 'left-origin-center' | 'right-origin-center';
+
+export declare class MatTabChangeEvent {
+    index: number;
+    tab: MatTab;
+}
+
+export declare class MatTabContent {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+}
+
+export declare class MatTabGroup extends _MatTabGroupMixinBase implements AfterContentInit, AfterContentChecked, OnDestroy, CanColor, CanDisableRipple {
+    _tabBodyWrapper: ElementRef;
+    _tabHeader: MatTabHeader;
+    _tabs: QueryList<MatTab>;
+    readonly animationDone: EventEmitter<void>;
+    animationDuration: string;
+    backgroundColor: ThemePalette;
+    dynamicHeight: boolean;
+    readonly focusChange: EventEmitter<MatTabChangeEvent>;
+    headerPosition: MatTabHeaderPosition;
+    selectedIndex: number | null;
+    readonly selectedIndexChange: EventEmitter<number>;
+    readonly selectedTabChange: EventEmitter<MatTabChangeEvent>;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, defaultConfig?: MatTabsConfig);
+    _focusChanged(index: number): void;
+    _getTabContentId(i: number): string;
+    _getTabIndex(tab: MatTab, idx: number): number | null;
+    _getTabLabelId(i: number): string;
+    _handleClick(tab: MatTab, tabHeader: MatTabHeader, index: number): void;
+    _removeTabBodyWrapperHeight(): void;
+    _setTabBodyWrapperHeight(tabHeight: number): void;
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    realignInkBar(): void;
+}
+
+export declare class MatTabGroupBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatTabHeader extends _MatTabHeaderMixinBase implements AfterContentChecked, AfterContentInit, OnDestroy, CanDisableRipple {
+    _disableScrollAfter: boolean;
+    _disableScrollBefore: boolean;
+    _inkBar: MatInkBar;
+    _labelWrappers: QueryList<MatTabLabelWrapper>;
+    _showPaginationControls: boolean;
+    _tabList: ElementRef;
+    _tabListContainer: ElementRef;
+    focusIndex: number;
+    readonly indexFocused: EventEmitter<{}>;
+    scrollDistance: number;
+    readonly selectFocusedIndex: EventEmitter<{}>;
+    selectedIndex: number;
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, _viewportRuler: ViewportRuler, _dir: Directionality, _ngZone?: NgZone | undefined);
+    _alignInkBarToSelectedTab(): void;
+    _checkPaginationEnabled(): void;
+    _checkScrollingControls(): void;
+    _getLayoutDirection(): Direction;
+    _getMaxScrollDistance(): number;
+    _handleKeydown(event: KeyboardEvent): void;
+    _isValidIndex(index: number): boolean;
+    _onContentChanges(): void;
+    _scrollHeader(scrollDir: ScrollDirection): void;
+    _scrollToLabel(labelIndex: number): void;
+    _setTabFocus(tabIndex: number): void;
+    _updateTabScrollPosition(): void;
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    updatePagination(): void;
+}
+
+export declare type MatTabHeaderPosition = 'above' | 'below';
+
+export declare class MatTabLabel extends CdkPortal {
+}
+
+export declare class MatTabLabelWrapper extends _MatTabLabelWrapperMixinBase implements CanDisable {
+    elementRef: ElementRef;
+    constructor(elementRef: ElementRef);
+    focus(): void;
+    getOffsetLeft(): number;
+    getOffsetWidth(): number;
+}
+
+export declare class MatTabLink extends _MatTabLinkMixinBase implements OnDestroy, CanDisable, CanDisableRipple, HasTabIndex, RippleTarget {
+    _elementRef: ElementRef;
+    protected _isActive: boolean;
+    protected _tabLinkRipple: RippleRenderer;
+    active: boolean;
+    rippleConfig: RippleConfig;
+    readonly rippleDisabled: boolean;
+    constructor(_tabNavBar: MatTabNav, _elementRef: ElementRef, ngZone: NgZone, platform: Platform, globalOptions: RippleGlobalOptions, tabIndex: string,
+    _focusMonitor?: FocusMonitor | undefined);
+    ngOnDestroy(): void;
+}
+
+export declare class MatTabNav extends _MatTabNavMixinBase implements AfterContentChecked, AfterContentInit, CanColor, CanDisableRipple, OnDestroy {
+    _inkBar: MatInkBar;
+    _tabLinks: QueryList<MatTabLink>;
+    backgroundColor: ThemePalette;
+    constructor(elementRef: ElementRef, _dir: Directionality, _ngZone: NgZone, _changeDetectorRef: ChangeDetectorRef, _viewportRuler: ViewportRuler);
+    _alignInkBar(): void;
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    updateActiveLink(element: ElementRef): void;
+}
+
+export declare const matTabsAnimations: {
+    readonly translateTab: AnimationTriggerMetadata;
+};
+
+export interface MatTabsConfig {
+    animationDuration?: string;
+}
+
+export declare class MatTabsModule {
+}
+
+export declare type ScrollDirection = 'after' | 'before';
@@ -0,0 +1,20 @@
+export declare const _MatToolbarMixinBase: CanColorCtor & typeof MatToolbarBase;
+
+export declare class MatToolbar extends _MatToolbarMixinBase implements CanColor, AfterViewInit {
+    _toolbarRows: QueryList<MatToolbarRow>;
+    constructor(elementRef: ElementRef, _platform: Platform, document?: any);
+    ngAfterViewInit(): void;
+}
+
+export declare class MatToolbarBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatToolbarModule {
+}
+
+export declare class MatToolbarRow {
+}
+
+export declare function throwToolbarMixedModesError(): void;
@@ -0,0 +1,85 @@
+export declare function getMatTooltipInvalidPositionError(position: string): Error;
+
+export declare const MAT_TOOLTIP_DEFAULT_OPTIONS: InjectionToken<MatTooltipDefaultOptions>;
+
+export declare function MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY(): MatTooltipDefaultOptions;
+
+export declare const MAT_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare function MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare const MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY;
+};
+
+export declare class MatTooltip implements OnDestroy {
+    _overlayRef: OverlayRef | null;
+    _tooltipInstance: TooltipComponent | null;
+    disabled: boolean;
+    hideDelay: number;
+    message: string;
+    position: TooltipPosition;
+    showDelay: number;
+    tooltipClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _scrollDispatcher: ScrollDispatcher, _viewContainerRef: ViewContainerRef, _ngZone: NgZone, platform: Platform, _ariaDescriber: AriaDescriber, _focusMonitor: FocusMonitor, scrollStrategy: any, _dir: Directionality, _defaultOptions: MatTooltipDefaultOptions, hammerLoader?: HammerLoader);
+    _getOrigin(): {
+        main: OriginConnectionPosition;
+        fallback: OriginConnectionPosition;
+    };
+    _getOverlayPosition(): {
+        main: OverlayConnectionPosition;
+        fallback: OverlayConnectionPosition;
+    };
+    _handleKeydown(e: KeyboardEvent): void;
+    _handleTouchend(): void;
+    _isTooltipVisible(): boolean;
+    hide(delay?: number): void;
+    ngOnDestroy(): void;
+    show(delay?: number): void;
+    toggle(): void;
+}
+
+export declare const matTooltipAnimations: {
+    readonly tooltipState: AnimationTriggerMetadata;
+};
+
+export interface MatTooltipDefaultOptions {
+    hideDelay: number;
+    showDelay: number;
+    touchendHideDelay: number;
+}
+
+export declare class MatTooltipModule {
+}
+
+export declare const SCROLL_THROTTLE_MS = 20;
+
+export declare const TOOLTIP_PANEL_CLASS = "mat-tooltip-panel";
+
+export declare class TooltipComponent {
+    _hideTimeoutId: number | null;
+    _isHandset: Observable<BreakpointState>;
+    _showTimeoutId: number | null;
+    _visibility: TooltipVisibility;
+    message: string;
+    tooltipClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    constructor(_changeDetectorRef: ChangeDetectorRef, _breakpointObserver: BreakpointObserver);
+    _animationDone(event: AnimationEvent): void;
+    _animationStart(): void;
+    _handleBodyInteraction(): void;
+    _markForCheck(): void;
+    afterHidden(): Observable<void>;
+    hide(delay: number): void;
+    isVisible(): boolean;
+    show(delay: number): void;
+}
+
+export declare type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+
+export declare type TooltipVisibility = 'initial' | 'visible' | 'hidden';
@@ -0,0 +1,75 @@
+export declare const _MatNestedTreeNodeMixinBase: HasTabIndexCtor & CanDisableCtor & typeof CdkNestedTreeNode;
+
+export declare const _MatTreeNodeMixinBase: HasTabIndexCtor & CanDisableCtor & typeof CdkTreeNode;
+
+export declare class MatNestedTreeNode<T> extends _MatNestedTreeNodeMixinBase<T> implements AfterContentInit, CanDisable, HasTabIndex, OnDestroy {
+    protected _differs: IterableDiffers;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _tree: CdkTree<T>;
+    node: T;
+    nodeOutlet: QueryList<MatTreeNodeOutlet>;
+    constructor(_elementRef: ElementRef<HTMLElement>, _tree: CdkTree<T>, _differs: IterableDiffers, tabIndex: string);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatTree<T> extends CdkTree<T> {
+    _nodeOutlet: MatTreeNodeOutlet;
+}
+
+export declare class MatTreeFlatDataSource<T, F> extends DataSource<F> {
+    _data: BehaviorSubject<T[]>;
+    _expandedData: BehaviorSubject<F[]>;
+    _flattenedData: BehaviorSubject<F[]>;
+    data: T[];
+    constructor(treeControl: FlatTreeControl<F>, treeFlattener: MatTreeFlattener<T, F>, initialData?: T[]);
+    connect(collectionViewer: CollectionViewer): Observable<F[]>;
+    disconnect(): void;
+}
+
+export declare class MatTreeFlattener<T, F> {
+    getChildren: (node: T) => Observable<T[]> | T[] | undefined | null;
+    getLevel: (node: F) => number;
+    isExpandable: (node: F) => boolean;
+    transformFunction: (node: T, level: number) => F;
+    constructor(transformFunction: (node: T, level: number) => F, getLevel: (node: F) => number, isExpandable: (node: F) => boolean, getChildren: (node: T) => Observable<T[]> | T[] | undefined | null);
+    _flattenChildren(children: T[], level: number, resultNodes: F[], parentMap: boolean[]): void;
+    _flattenNode(node: T, level: number, resultNodes: F[], parentMap: boolean[]): F[];
+    expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F>): F[];
+    flattenNodes(structuredData: T[]): F[];
+}
+
+export declare class MatTreeModule {
+}
+
+export declare class MatTreeNestedDataSource<T> extends DataSource<T> {
+    _data: BehaviorSubject<T[]>;
+    data: T[];
+    connect(collectionViewer: CollectionViewer): Observable<T[]>;
+    disconnect(): void;
+}
+
+export declare class MatTreeNode<T> extends _MatTreeNodeMixinBase<T> implements CanDisable, HasTabIndex {
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _tree: CdkTree<T>;
+    role: 'treeitem' | 'group';
+    constructor(_elementRef: ElementRef<HTMLElement>, _tree: CdkTree<T>, tabIndex: string);
+}
+
+export declare class MatTreeNodeDef<T> extends CdkTreeNodeDef<T> {
+    data: T;
+}
+
+export declare class MatTreeNodeOutlet implements CdkTreeNodeOutlet {
+    viewContainer: ViewContainerRef;
+    constructor(viewContainer: ViewContainerRef);
+}
+
+export declare class MatTreeNodePadding<T> extends CdkTreeNodePadding<T> {
+    indent: number;
+    level: number;
+}
+
+export declare class MatTreeNodeToggle<T> extends CdkTreeNodeToggle<T> {
+    recursive: boolean;
+}