@awc-ui/angular 0.0.0-snapshot.20260820120614.cae27aa

package/fesm2022/awc-ui-angular.mjs

@@ -0,0 +1,2537 @@
+import * as i0 from '@angular/core';
+import { ChangeDetectionStrategy, Component, HostListener, Directive, APP_INITIALIZER, CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { defineCustomElements } from '@awc-ui/core/loader';
+import { __decorate } from 'tslib';
+import { fromEvent } from 'rxjs';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+
+/* eslint-disable */
+/* tslint:disable */
+const proxyInputs = (Cmp, inputs) => {
+    const Prototype = Cmp.prototype;
+    inputs.forEach((item) => {
+        Object.defineProperty(Prototype, item, {
+            get() {
+                return this.el[item];
+            },
+            set(val) {
+                this.z.runOutsideAngular(() => (this.el[item] = val));
+            },
+            /**
+             * In the event that proxyInputs is called
+             * multiple times re-defining these inputs
+             * will cause an error to be thrown. As a result
+             * we set configurable: true to indicate these
+             * properties can be changed.
+             */
+            configurable: true,
+        });
+    });
+};
+const proxyMethods = (Cmp, methods) => {
+    const Prototype = Cmp.prototype;
+    methods.forEach((methodName) => {
+        Prototype[methodName] = function () {
+            const args = arguments;
+            return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args));
+        };
+    });
+};
+const proxyOutputs = (instance, el, events) => {
+    events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName)));
+};
+const defineCustomElement = (tagName, customElement) => {
+    if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+        customElements.define(tagName, customElement);
+    }
+};
+// tslint:disable-next-line: only-arrow-functions
+function ProxyCmp(opts) {
+    const decorator = function (cls) {
+        const { defineCustomElementFn, inputs, methods } = opts;
+        if (defineCustomElementFn !== undefined) {
+            defineCustomElementFn();
+        }
+        if (inputs) {
+            proxyInputs(cls, inputs);
+        }
+        if (methods) {
+            proxyMethods(cls, methods);
+        }
+        return cls;
+    };
+    return decorator;
+}
+
+let MdAccordion = class MdAccordion {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdToggle', 'mdReorder', 'mdDragStart', 'mdDragMove', 'mdDragEnd']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAccordion, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdAccordion, selector: "md-accordion", inputs: { bringToFront: "bringToFront", defaultExpanded: "defaultExpanded", density: "density", elevation: "elevation", exclusive: "exclusive", floating: "floating", headingLevel: "headingLevel", initialX: "initialX", initialY: "initialY", keepOneExpanded: "keepOneExpanded", region: "region", regionThreshold: "regionThreshold", reorderable: "reorderable", transition: "transition", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdAccordion = __decorate([
+    ProxyCmp({
+        inputs: ['bringToFront', 'defaultExpanded', 'density', 'elevation', 'exclusive', 'floating', 'headingLevel', 'initialX', 'initialY', 'keepOneExpanded', 'region', 'regionThreshold', 'reorderable', 'transition', 'variant']
+    })
+], MdAccordion);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAccordion, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-accordion',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['bringToFront', 'defaultExpanded', 'density', 'elevation', 'exclusive', 'floating', 'headingLevel', 'initialX', 'initialY', 'keepOneExpanded', 'region', 'regionThreshold', 'reorderable', 'transition', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdAccordionItem = class MdAccordionItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdItemToggle', 'mdItemRequestFocus', 'mdItemRequestReorder']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAccordionItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdAccordionItem, selector: "md-accordion-item", inputs: { collapsible: "collapsible", contentMaxHeight: "contentMaxHeight", density: "density", disabled: "disabled", expanded: "expanded", headingLevel: "headingLevel", headline: "headline", icon: "icon", regionRole: "regionRole", supportingText: "supportingText" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdAccordionItem = __decorate([
+    ProxyCmp({
+        inputs: ['collapsible', 'contentMaxHeight', 'density', 'disabled', 'expanded', 'headingLevel', 'headline', 'icon', 'regionRole', 'supportingText'],
+        methods: ['toggle', 'focusHeader']
+    })
+], MdAccordionItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAccordionItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-accordion-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['collapsible', 'contentMaxHeight', 'density', 'disabled', 'expanded', 'headingLevel', 'headline', 'icon', 'regionRole', 'supportingText'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdAppBar = class MdAppBar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdLeadingClick', 'mdSearchActivate', 'mdSearchInput']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAppBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdAppBar, selector: "md-app-bar", inputs: { density: "density", headline: "headline", leadingIcon: "leadingIcon", leadingIconLabel: "leadingIconLabel", scrolled: "scrolled", searchAriaLabel: "searchAriaLabel", searchDisabled: "searchDisabled", searchPlaceholder: "searchPlaceholder", searchValue: "searchValue", subtitle: "subtitle", titleAlignment: "titleAlignment", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdAppBar = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'headline', 'leadingIcon', 'leadingIconLabel', 'scrolled', 'searchAriaLabel', 'searchDisabled', 'searchPlaceholder', 'searchValue', 'subtitle', 'titleAlignment', 'variant']
+    })
+], MdAppBar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAppBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-app-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'headline', 'leadingIcon', 'leadingIconLabel', 'scrolled', 'searchAriaLabel', 'searchDisabled', 'searchPlaceholder', 'searchValue', 'subtitle', 'titleAlignment', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdAreaChart = class MdAreaChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdMarkerClick', 'mdLineClick', 'mdAreaClick', 'mdAxisClick', 'mdLegendClick', 'mdHover', 'mdReady', 'mdZoom']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAreaChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdAreaChart, selector: "md-area-chart", inputs: { animation: "animation", animationDuration: "animationDuration", axisTicks: "axisTicks", connectNulls: "connectNulls", curve: "curve", density: "density", fillOpacity: "fillOpacity", grid: "grid", heightProp: "heightProp", inverted: "inverted", label: "label", labelEmpty: "labelEmpty", labelPlot: "labelPlot", labelPoint: "labelPoint", labelZoomEnd: "labelZoomEnd", labelZoomStart: "labelZoomStart", legend: "legend", lineWidth: "lineWidth", loading: "loading", loadingLabel: "loadingLabel", locale: "locale", markSize: "markSize", noAnimation: "noAnimation", series: "series", seriesLabels: "seriesLabels", showLabels: "showLabels", showLine: "showLine", showMarks: "showMarks", stack: "stack", subtitle: "subtitle", summary: "summary", tableLabels: "tableLabels", titleAlign: "titleAlign", tooltip: "tooltip", tooltipRenderer: "tooltipRenderer", valueFormatter: "valueFormatter", xAxis: "xAxis", yAxis: "yAxis", zoom: "zoom" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdAreaChart = __decorate([
+    ProxyCmp({
+        inputs: ['animation', 'animationDuration', 'axisTicks', 'connectNulls', 'curve', 'density', 'fillOpacity', 'grid', 'heightProp', 'inverted', 'label', 'labelEmpty', 'labelPlot', 'labelPoint', 'labelZoomEnd', 'labelZoomStart', 'legend', 'lineWidth', 'loading', 'loadingLabel', 'locale', 'markSize', 'noAnimation', 'series', 'seriesLabels', 'showLabels', 'showLine', 'showMarks', 'stack', 'subtitle', 'summary', 'tableLabels', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter', 'xAxis', 'yAxis', 'zoom'],
+        methods: ['resize', 'replay', 'toDataURL', 'getInstance', 'setZoom', 'resetZoom']
+    })
+], MdAreaChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAreaChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-area-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animation', 'animationDuration', 'axisTicks', 'connectNulls', 'curve', 'density', 'fillOpacity', 'grid', 'heightProp', 'inverted', 'label', 'labelEmpty', 'labelPlot', 'labelPoint', 'labelZoomEnd', 'labelZoomStart', 'legend', 'lineWidth', 'loading', 'loadingLabel', 'locale', 'markSize', 'noAnimation', 'series', 'seriesLabels', 'showLabels', 'showLine', 'showMarks', 'stack', 'subtitle', 'summary', 'tableLabels', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter', 'xAxis', 'yAxis', 'zoom'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdAutocomplete = class MdAutocomplete {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdInput', 'mdOpen', 'mdClose', 'mdClear', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAutocomplete, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdAutocomplete, selector: "md-autocomplete", inputs: { chipPosition: "chipPosition", clearIcon: "clearIcon", clearOnBlur: "clearOnBlur", clearable: "clearable", density: "density", disableCloseOnSelect: "disableCloseOnSelect", disabled: "disabled", dropdownIcon: "dropdownIcon", error: "error", errorText: "errorText", filterMode: "filterMode", filterer: "filterer", freeSolo: "freeSolo", inputValue: "inputValue", label: "label", limitResults: "limitResults", loading: "loading", loadingText: "loadingText", matchTriggerWidth: "matchTriggerWidth", maxHeight: "maxHeight", maxSelected: "maxSelected", multiple: "multiple", name: "name", noOptionsText: "noOptionsText", noResultsText: "noResultsText", open: "open", options: "options", placeholder: "placeholder", placement: "placement", required: "required", reserveSupportingSpace: "reserveSupportingSpace", rowHeight: "rowHeight", softDisabled: "softDisabled", statusTemplate: "statusTemplate", supportingText: "supportingText", value: "value", valueMissingLabel: "valueMissingLabel", variant: "variant", virtualize: "virtualize" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdAutocomplete = __decorate([
+    ProxyCmp({
+        inputs: ['chipPosition', 'clearIcon', 'clearOnBlur', 'clearable', 'density', 'disableCloseOnSelect', 'disabled', 'dropdownIcon', 'error', 'errorText', 'filterMode', 'filterer', 'freeSolo', 'inputValue', 'label', 'limitResults', 'loading', 'loadingText', 'matchTriggerWidth', 'maxHeight', 'maxSelected', 'multiple', 'name', 'noOptionsText', 'noResultsText', 'open', 'options', 'placeholder', 'placement', 'required', 'reserveSupportingSpace', 'rowHeight', 'softDisabled', 'statusTemplate', 'supportingText', 'value', 'valueMissingLabel', 'variant', 'virtualize'],
+        methods: ['focusInput', 'showMenu', 'closeMenu', 'loadOptions', 'getLabels', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdAutocomplete);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAutocomplete, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-autocomplete',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['chipPosition', 'clearIcon', 'clearOnBlur', 'clearable', 'density', 'disableCloseOnSelect', 'disabled', 'dropdownIcon', 'error', 'errorText', 'filterMode', 'filterer', 'freeSolo', 'inputValue', 'label', 'limitResults', 'loading', 'loadingText', 'matchTriggerWidth', 'maxHeight', 'maxSelected', 'multiple', 'name', 'noOptionsText', 'noResultsText', 'open', 'options', 'placeholder', 'placement', 'required', 'reserveSupportingSpace', 'rowHeight', 'softDisabled', 'statusTemplate', 'supportingText', 'value', 'valueMissingLabel', 'variant', 'virtualize'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdAvatar = class MdAvatar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdLoad', 'mdError']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAvatar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdAvatar, selector: "md-avatar", inputs: { alt: "alt", colorFromName: "colorFromName", crossorigin: "crossorigin", density: "density", initials: "initials", label: "label", loading: "loading", name: "name", shape: "shape", size: "size", src: "src" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdAvatar = __decorate([
+    ProxyCmp({
+        inputs: ['alt', 'colorFromName', 'crossorigin', 'density', 'initials', 'label', 'loading', 'name', 'shape', 'size', 'src']
+    })
+], MdAvatar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdAvatar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-avatar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['alt', 'colorFromName', 'crossorigin', 'density', 'initials', 'label', 'loading', 'name', 'shape', 'size', 'src'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdBadge = class MdBadge {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBadge, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdBadge, selector: "md-badge", inputs: { density: "density", icon: "icon", max: "max", value: "value", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdBadge = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'icon', 'max', 'value', 'variant']
+    })
+], MdBadge);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-badge',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'icon', 'max', 'value', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdBarChart = class MdBarChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdBarClick', 'mdLegendClick', 'mdHover', 'mdReady', 'mdZoom']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBarChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdBarChart, selector: "md-bar-chart", inputs: { animation: "animation", animationDuration: "animationDuration", axisTicks: "axisTicks", barGap: "barGap", barWidth: "barWidth", categoryGap: "categoryGap", chevron: "chevron", clickable: "clickable", cornerRadius: "cornerRadius", density: "density", heightProp: "heightProp", label: "label", labelPlot: "labelPlot", labelPoint: "labelPoint", labelZoomEnd: "labelZoomEnd", labelZoomStart: "labelZoomStart", layout: "layout", legend: "legend", loading: "loading", loadingLabel: "loadingLabel", locale: "locale", noAnimation: "noAnimation", polar: "polar", polarHole: "polarHole", polarSweep: "polarSweep", series: "series", showLabels: "showLabels", showTotals: "showTotals", stack: "stack", subtitle: "subtitle", titleAlign: "titleAlign", tooltip: "tooltip", tooltipRenderer: "tooltipRenderer", valueFormatter: "valueFormatter", xAxis: "xAxis", yAxis: "yAxis", yAxis2: "yAxis2", zoom: "zoom" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdBarChart = __decorate([
+    ProxyCmp({
+        inputs: ['animation', 'animationDuration', 'axisTicks', 'barGap', 'barWidth', 'categoryGap', 'chevron', 'clickable', 'cornerRadius', 'density', 'heightProp', 'label', 'labelPlot', 'labelPoint', 'labelZoomEnd', 'labelZoomStart', 'layout', 'legend', 'loading', 'loadingLabel', 'locale', 'noAnimation', 'polar', 'polarHole', 'polarSweep', 'series', 'showLabels', 'showTotals', 'stack', 'subtitle', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter', 'xAxis', 'yAxis', 'yAxis2', 'zoom'],
+        methods: ['resize', 'replay', 'drill', 'toDataURL', 'getInstance', 'setZoom', 'resetZoom']
+    })
+], MdBarChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBarChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-bar-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animation', 'animationDuration', 'axisTicks', 'barGap', 'barWidth', 'categoryGap', 'chevron', 'clickable', 'cornerRadius', 'density', 'heightProp', 'label', 'labelPlot', 'labelPoint', 'labelZoomEnd', 'labelZoomStart', 'layout', 'legend', 'loading', 'loadingLabel', 'locale', 'noAnimation', 'polar', 'polarHole', 'polarSweep', 'series', 'showLabels', 'showTotals', 'stack', 'subtitle', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter', 'xAxis', 'yAxis', 'yAxis2', 'zoom'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdBottomSheet = class MdBottomSheet {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose', 'mdCancel']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBottomSheet, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdBottomSheet, selector: "md-bottom-sheet", inputs: { bottomDivider: "bottomDivider", closeable: "closeable", contentAlign: "contentAlign", density: "density", headline: "headline", headlineAlign: "headlineAlign", open: "open", scrimDismissible: "scrimDismissible", scrollShadow: "scrollShadow", sheetAriaLabel: "sheetAriaLabel", showDragHandle: "showDragHandle", topDivider: "topDivider", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdBottomSheet = __decorate([
+    ProxyCmp({
+        inputs: ['bottomDivider', 'closeable', 'contentAlign', 'density', 'headline', 'headlineAlign', 'open', 'scrimDismissible', 'scrollShadow', 'sheetAriaLabel', 'showDragHandle', 'topDivider', 'variant'],
+        methods: ['show', 'close']
+    })
+], MdBottomSheet);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBottomSheet, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-bottom-sheet',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['bottomDivider', 'closeable', 'contentAlign', 'density', 'headline', 'headlineAlign', 'open', 'scrimDismissible', 'scrollShadow', 'sheetAriaLabel', 'showDragHandle', 'topDivider', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdBreadcrumbItem = class MdBreadcrumbItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSelect']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBreadcrumbItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdBreadcrumbItem, selector: "md-breadcrumb-item", inputs: { collapsed: "collapsed", current: "current", density: "density", disabled: "disabled", href: "href", icon: "icon", itemIndex: "itemIndex", itemTotal: "itemTotal", rel: "rel", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdBreadcrumbItem = __decorate([
+    ProxyCmp({
+        inputs: ['collapsed', 'current', 'density', 'disabled', 'href', 'icon', 'itemIndex', 'itemTotal', 'rel', 'target']
+    })
+], MdBreadcrumbItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBreadcrumbItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-breadcrumb-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['collapsed', 'current', 'density', 'disabled', 'href', 'icon', 'itemIndex', 'itemTotal', 'rel', 'target'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdBreadcrumbs = class MdBreadcrumbs {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdExpand']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBreadcrumbs, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdBreadcrumbs, selector: "md-breadcrumbs", inputs: { density: "density", expandLabel: "expandLabel", itemsAfterCollapse: "itemsAfterCollapse", itemsBeforeCollapse: "itemsBeforeCollapse", label: "label", maxItems: "maxItems", separator: "separator" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdBreadcrumbs = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'expandLabel', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'label', 'maxItems', 'separator'],
+        methods: ['expand', 'collapse']
+    })
+], MdBreadcrumbs);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdBreadcrumbs, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-breadcrumbs',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'expandLabel', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'label', 'maxItems', 'separator'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdButton = class MdButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick', 'mdChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdButton, selector: "md-button", inputs: { density: "density", disabled: "disabled", fullWidth: "fullWidth", href: "href", icon: "icon", loading: "loading", mirrorIcon: "mirrorIcon", ripple: "ripple", roleOverride: "roleOverride", selected: "selected", shape: "shape", shapeMorph: "shapeMorph", size: "size", softDisabled: "softDisabled", suppressExpandIconFlip: "suppressExpandIconFlip", target: "target", toggle: "toggle", trailingIcon: "trailingIcon", type: "type", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdButton = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'disabled', 'fullWidth', 'href', 'icon', 'loading', 'mirrorIcon', 'ripple', 'roleOverride', 'selected', 'shape', 'shapeMorph', 'size', 'softDisabled', 'suppressExpandIconFlip', 'target', 'toggle', 'trailingIcon', 'type', 'variant']
+    })
+], MdButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'disabled', 'fullWidth', 'href', 'icon', 'loading', 'mirrorIcon', 'ripple', 'roleOverride', 'selected', 'shape', 'shapeMorph', 'size', 'softDisabled', 'suppressExpandIconFlip', 'target', 'toggle', 'trailingIcon', 'type', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdButtonGroup = class MdButtonGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSelectionChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdButtonGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdButtonGroup, selector: "md-button-group", inputs: { density: "density", fullWidth: "fullWidth", required: "required", selectionMode: "selectionMode", shape: "shape", size: "size", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdButtonGroup = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'fullWidth', 'required', 'selectionMode', 'shape', 'size', 'variant']
+    })
+], MdButtonGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdButtonGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-button-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'fullWidth', 'required', 'selectionMode', 'shape', 'size', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdCard = class MdCard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick', 'mdDragStart', 'mdDragMove', 'mdDragEnd']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdCard, selector: "md-card", inputs: { density: "density", disabled: "disabled", dragEnabled: "dragEnabled", fullHeight: "fullHeight", fullWidth: "fullWidth", interactive: "interactive", ripple: "ripple", softDisabled: "softDisabled", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdCard = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'disabled', 'dragEnabled', 'fullHeight', 'fullWidth', 'interactive', 'ripple', 'softDisabled', 'variant']
+    })
+], MdCard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'disabled', 'dragEnabled', 'fullHeight', 'fullWidth', 'interactive', 'ripple', 'softDisabled', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdCheckbox = class MdCheckbox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdCheckbox, selector: "md-checkbox", inputs: { checked: "checked", density: "density", disabled: "disabled", error: "error", errorText: "errorText", indeterminate: "indeterminate", name: "name", required: "required", softDisabled: "softDisabled", supportingText: "supportingText", value: "value", valueMissingLabel: "valueMissingLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdCheckbox = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'density', 'disabled', 'error', 'errorText', 'indeterminate', 'name', 'required', 'softDisabled', 'supportingText', 'value', 'valueMissingLabel'],
+        methods: ['getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdCheckbox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdCheckbox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-checkbox',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['checked', 'density', 'disabled', 'error', 'errorText', 'indeterminate', 'name', 'required', 'softDisabled', 'supportingText', 'value', 'valueMissingLabel'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdChip = class MdChip {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick', 'mdSelect', 'mdRemove']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdChip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdChip, selector: "md-chip", inputs: { appearance: "appearance", color: "color", density: "density", disabled: "disabled", elevated: "elevated", icon: "icon", label: "label", removable: "removable", selectable: "selectable", selected: "selected", softDisabled: "softDisabled", trailingIcon: "trailingIcon", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdChip = __decorate([
+    ProxyCmp({
+        inputs: ['appearance', 'color', 'density', 'disabled', 'elevated', 'icon', 'label', 'removable', 'selectable', 'selected', 'softDisabled', 'trailingIcon', 'variant']
+    })
+], MdChip);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdChip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-chip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['appearance', 'color', 'density', 'disabled', 'elevated', 'icon', 'label', 'removable', 'selectable', 'selected', 'softDisabled', 'trailingIcon', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdColorPicker = class MdColorPicker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdChange', 'mdOpenChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdColorPicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdColorPicker, selector: "md-color-picker", inputs: { alpha: "alpha", ariaLabelProp: "ariaLabelProp", density: "density", disabled: "disabled", dismissOnOutsideClick: "dismissOnOutsideClick", format: "format", open: "open", presets: "presets", showHex: "showHex", showInputs: "showInputs", value: "value", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdColorPicker = __decorate([
+    ProxyCmp({
+        inputs: ['alpha', 'ariaLabelProp', 'density', 'disabled', 'dismissOnOutsideClick', 'format', 'open', 'presets', 'showHex', 'showInputs', 'value', 'variant'],
+        methods: ['show', 'close']
+    })
+], MdColorPicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdColorPicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-color-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['alpha', 'ariaLabelProp', 'density', 'disabled', 'dismissOnOutsideClick', 'format', 'open', 'presets', 'showHex', 'showInputs', 'value', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdDatePicker = class MdDatePicker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdSelected', 'mdInput', 'mdOpen', 'mdClose', 'mdCancel', 'mdViewChange', 'mdMenuOpen', 'mdMenuSelect', 'mdModeChange', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdDatePicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdDatePicker, selector: "md-date-picker", inputs: { calendarIcon: "calendarIcon", cancelLabel: "cancelLabel", chooseMonthAndYearLabel: "chooseMonthAndYearLabel", chooseMonthLabel: "chooseMonthLabel", chooseMonthYearLabel: "chooseMonthYearLabel", chooseYearLabel: "chooseYearLabel", clearLabel: "clearLabel", clearable: "clearable", closeCalendarLabel: "closeCalendarLabel", commitOnSelect: "commitOnSelect", dateSeparator: "dateSeparator", density: "density", disabled: "disabled", enterDatesLabel: "enterDatesLabel", error: "error", errorText: "errorText", fieldVariant: "fieldVariant", firstDayOfWeek: "firstDayOfWeek", headline: "headline", invalidDateLabel: "invalidDateLabel", isDateDisabled: "isDateDisabled", label: "label", locale: "locale", max: "max", min: "min", name: "name", nextMonthLabel: "nextMonthLabel", nextYearLabel: "nextYearLabel", okLabel: "okLabel", open: "open", openCalendarLabel: "openCalendarLabel", outsideClickDismissible: "outsideClickDismissible", placeholder: "placeholder", previousMonthLabel: "previousMonthLabel", previousYearLabel: "previousYearLabel", required: "required", reserveSupportingSpace: "reserveSupportingSpace", scrimDismissible: "scrimDismissible", selectDateLabel: "selectDateLabel", supportingText: "supportingText", toggleCalendarLabel: "toggleCalendarLabel", toggleTextLabel: "toggleTextLabel", value: "value", valueMissingLabel: "valueMissingLabel", variant: "variant", yearGridLabel: "yearGridLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdDatePicker = __decorate([
+    ProxyCmp({
+        inputs: ['calendarIcon', 'cancelLabel', 'chooseMonthAndYearLabel', 'chooseMonthLabel', 'chooseMonthYearLabel', 'chooseYearLabel', 'clearLabel', 'clearable', 'closeCalendarLabel', 'commitOnSelect', 'dateSeparator', 'density', 'disabled', 'enterDatesLabel', 'error', 'errorText', 'fieldVariant', 'firstDayOfWeek', 'headline', 'invalidDateLabel', 'isDateDisabled', 'label', 'locale', 'max', 'min', 'name', 'nextMonthLabel', 'nextYearLabel', 'okLabel', 'open', 'openCalendarLabel', 'outsideClickDismissible', 'placeholder', 'previousMonthLabel', 'previousYearLabel', 'required', 'reserveSupportingSpace', 'scrimDismissible', 'selectDateLabel', 'supportingText', 'toggleCalendarLabel', 'toggleTextLabel', 'value', 'valueMissingLabel', 'variant', 'yearGridLabel'],
+        methods: ['show', 'close', 'clear', 'focusInput', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdDatePicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdDatePicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-date-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['calendarIcon', 'cancelLabel', 'chooseMonthAndYearLabel', 'chooseMonthLabel', 'chooseMonthYearLabel', 'chooseYearLabel', 'clearLabel', 'clearable', 'closeCalendarLabel', 'commitOnSelect', 'dateSeparator', 'density', 'disabled', 'enterDatesLabel', 'error', 'errorText', 'fieldVariant', 'firstDayOfWeek', 'headline', 'invalidDateLabel', 'isDateDisabled', 'label', 'locale', 'max', 'min', 'name', 'nextMonthLabel', 'nextYearLabel', 'okLabel', 'open', 'openCalendarLabel', 'outsideClickDismissible', 'placeholder', 'previousMonthLabel', 'previousYearLabel', 'required', 'reserveSupportingSpace', 'scrimDismissible', 'selectDateLabel', 'supportingText', 'toggleCalendarLabel', 'toggleTextLabel', 'value', 'valueMissingLabel', 'variant', 'yearGridLabel'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdDialog = class MdDialog {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose', 'mdCancel']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdDialog, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdDialog, selector: "md-dialog", inputs: { cancelLabel: "cancelLabel", closeLabel: "closeLabel", density: "density", divider: "divider", fullscreen: "fullscreen", headerDivider: "headerDivider", headline: "headline", icon: "icon", locale: "locale", okLabel: "okLabel", open: "open", scrimDismissible: "scrimDismissible" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdDialog = __decorate([
+    ProxyCmp({
+        inputs: ['cancelLabel', 'closeLabel', 'density', 'divider', 'fullscreen', 'headerDivider', 'headline', 'icon', 'locale', 'okLabel', 'open', 'scrimDismissible'],
+        methods: ['show', 'close']
+    })
+], MdDialog);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdDialog, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-dialog',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['cancelLabel', 'closeLabel', 'density', 'divider', 'fullscreen', 'headerDivider', 'headline', 'icon', 'locale', 'okLabel', 'open', 'scrimDismissible'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdDivider = class MdDivider {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdDivider, selector: "md-divider", inputs: { inset: "inset", insetEnd: "insetEnd", insetStart: "insetStart", vertical: "vertical" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdDivider = __decorate([
+    ProxyCmp({
+        inputs: ['inset', 'insetEnd', 'insetStart', 'vertical']
+    })
+], MdDivider);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdDivider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-divider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['inset', 'insetEnd', 'insetStart', 'vertical'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdFab = class MdFab {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdFab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdFab, selector: "md-fab", inputs: { density: "density", disabled: "disabled", extended: "extended", icon: "icon", label: "label", lowered: "lowered", ripple: "ripple", size: "size", softDisabled: "softDisabled", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdFab = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'disabled', 'extended', 'icon', 'label', 'lowered', 'ripple', 'size', 'softDisabled', 'variant']
+    })
+], MdFab);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdFab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-fab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'disabled', 'extended', 'icon', 'label', 'lowered', 'ripple', 'size', 'softDisabled', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdFabMenu = class MdFabMenu {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdFabMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdFabMenu, selector: "md-fab-menu", inputs: { anchor: "anchor", density: "density", menuLabel: "menuLabel", open: "open", placement: "placement", quick: "quick", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdFabMenu = __decorate([
+    ProxyCmp({
+        inputs: ['anchor', 'density', 'menuLabel', 'open', 'placement', 'quick', 'variant'],
+        methods: ['show', 'close']
+    })
+], MdFabMenu);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdFabMenu, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-fab-menu',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['anchor', 'density', 'menuLabel', 'open', 'placement', 'quick', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdFabMenuItem = class MdFabMenuItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdFabMenuItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdFabMenuItem, selector: "md-fab-menu-item", inputs: { density: "density", disabled: "disabled", icon: "icon", label: "label", rovingFocusVisible: "rovingFocusVisible", softDisabled: "softDisabled" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdFabMenuItem = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'disabled', 'icon', 'label', 'rovingFocusVisible', 'softDisabled']
+    })
+], MdFabMenuItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdFabMenuItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-fab-menu-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'disabled', 'icon', 'label', 'rovingFocusVisible', 'softDisabled'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdIconButton = class MdIconButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdIconButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdIconButton, selector: "md-icon-button", inputs: { buttonWidth: "buttonWidth", density: "density", disabled: "disabled", href: "href", icon: "icon", ripple: "ripple", selected: "selected", selectedIcon: "selectedIcon", shape: "shape", shapeMorph: "shapeMorph", size: "size", softDisabled: "softDisabled", target: "target", toggle: "toggle", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdIconButton = __decorate([
+    ProxyCmp({
+        inputs: ['buttonWidth', 'density', 'disabled', 'href', 'icon', 'ripple', 'selected', 'selectedIcon', 'shape', 'shapeMorph', 'size', 'softDisabled', 'target', 'toggle', 'variant']
+    })
+], MdIconButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdIconButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-icon-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['buttonWidth', 'density', 'disabled', 'href', 'icon', 'ripple', 'selected', 'selectedIcon', 'shape', 'shapeMorph', 'size', 'softDisabled', 'target', 'toggle', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdLineChart = class MdLineChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdMarkerClick', 'mdLineClick', 'mdAreaClick', 'mdAxisClick', 'mdLegendClick', 'mdHover', 'mdReady', 'mdZoom']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdLineChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdLineChart, selector: "md-line-chart", inputs: { animation: "animation", animationDuration: "animationDuration", area: "area", axisTicks: "axisTicks", connectNulls: "connectNulls", curve: "curve", density: "density", grid: "grid", heightProp: "heightProp", inverted: "inverted", label: "label", labelEmpty: "labelEmpty", labelPlot: "labelPlot", labelPoint: "labelPoint", labelZoomEnd: "labelZoomEnd", labelZoomStart: "labelZoomStart", legend: "legend", lineWidth: "lineWidth", loading: "loading", loadingLabel: "loadingLabel", locale: "locale", markLines: "markLines", markSize: "markSize", noAnimation: "noAnimation", series: "series", seriesLabels: "seriesLabels", showLabels: "showLabels", showLine: "showLine", showMarks: "showMarks", stack: "stack", subtitle: "subtitle", summary: "summary", tableLabels: "tableLabels", titleAlign: "titleAlign", tooltip: "tooltip", tooltipRenderer: "tooltipRenderer", valueFormatter: "valueFormatter", xAxis: "xAxis", yAxes: "yAxes", yAxis: "yAxis", zoom: "zoom" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdLineChart = __decorate([
+    ProxyCmp({
+        inputs: ['animation', 'animationDuration', 'area', 'axisTicks', 'connectNulls', 'curve', 'density', 'grid', 'heightProp', 'inverted', 'label', 'labelEmpty', 'labelPlot', 'labelPoint', 'labelZoomEnd', 'labelZoomStart', 'legend', 'lineWidth', 'loading', 'loadingLabel', 'locale', 'markLines', 'markSize', 'noAnimation', 'series', 'seriesLabels', 'showLabels', 'showLine', 'showMarks', 'stack', 'subtitle', 'summary', 'tableLabels', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter', 'xAxis', 'yAxes', 'yAxis', 'zoom'],
+        methods: ['resize', 'replay', 'toDataURL', 'getInstance', 'setZoom', 'resetZoom']
+    })
+], MdLineChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdLineChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-line-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animation', 'animationDuration', 'area', 'axisTicks', 'connectNulls', 'curve', 'density', 'grid', 'heightProp', 'inverted', 'label', 'labelEmpty', 'labelPlot', 'labelPoint', 'labelZoomEnd', 'labelZoomStart', 'legend', 'lineWidth', 'loading', 'loadingLabel', 'locale', 'markLines', 'markSize', 'noAnimation', 'series', 'seriesLabels', 'showLabels', 'showLine', 'showMarks', 'stack', 'subtitle', 'summary', 'tableLabels', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter', 'xAxis', 'yAxes', 'yAxis', 'zoom'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdList = class MdList {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSelect', 'mdActivate', 'mdReorder']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdList, selector: "md-list", inputs: { density: "density", interactionMode: "interactionMode", label: "label", labelledby: "labelledby", listStyle: "listStyle", reorderable: "reorderable", roleOverride: "roleOverride", selectionMode: "selectionMode" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdList = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'interactionMode', 'label', 'labelledby', 'listStyle', 'reorderable', 'roleOverride', 'selectionMode'],
+        methods: ['activateNext', 'activatePrevious', 'selectItem', 'getSelectedIndices']
+    })
+], MdList);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'interactionMode', 'label', 'labelledby', 'listStyle', 'reorderable', 'roleOverride', 'selectionMode'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdListItem = class MdListItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick', 'mdItemClick', 'mdItemSelect', 'mdRequestActivation', 'mdItemRequestReorder', 'mdExpand']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdListItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdListItem, selector: "md-list-item", inputs: { containerRole: "containerRole", density: "density", disabled: "disabled", expandable: "expandable", expanded: "expanded", headline: "headline", href: "href", interactionMode: "interactionMode", leadingAvatar: "leadingAvatar", leadingAvatarAlt: "leadingAvatarAlt", leadingAvatarLabel: "leadingAvatarLabel", leadingAvatarName: "leadingAvatarName", leadingIcon: "leadingIcon", leadingImage: "leadingImage", leadingImageAlt: "leadingImageAlt", lines: "lines", overline: "overline", reorderable: "reorderable", rovingFocusVisible: "rovingFocusVisible", selected: "selected", selectionMode: "selectionMode", softDisabled: "softDisabled", supportingText: "supportingText", tabbable: "tabbable", target: "target", trailingIcon: "trailingIcon", trailingSupportingText: "trailingSupportingText", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdListItem = __decorate([
+    ProxyCmp({
+        inputs: ['containerRole', 'density', 'disabled', 'expandable', 'expanded', 'headline', 'href', 'interactionMode', 'leadingAvatar', 'leadingAvatarAlt', 'leadingAvatarLabel', 'leadingAvatarName', 'leadingIcon', 'leadingImage', 'leadingImageAlt', 'lines', 'overline', 'reorderable', 'rovingFocusVisible', 'selected', 'selectionMode', 'softDisabled', 'supportingText', 'tabbable', 'target', 'trailingIcon', 'trailingSupportingText', 'type'],
+        methods: ['setFocus', 'focusItem', 'toggle', 'expand', 'collapse']
+    })
+], MdListItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdListItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-list-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['containerRole', 'density', 'disabled', 'expandable', 'expanded', 'headline', 'href', 'interactionMode', 'leadingAvatar', 'leadingAvatarAlt', 'leadingAvatarLabel', 'leadingAvatarName', 'leadingIcon', 'leadingImage', 'leadingImageAlt', 'lines', 'overline', 'reorderable', 'rovingFocusVisible', 'selected', 'selectionMode', 'softDisabled', 'supportingText', 'tabbable', 'target', 'trailingIcon', 'trailingSupportingText', 'type'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdLoadingIndicator = class MdLoadingIndicator {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdLoadingIndicator, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdLoadingIndicator, selector: "md-loading-indicator", inputs: { density: "density", label: "label", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdLoadingIndicator = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'label', 'variant']
+    })
+], MdLoadingIndicator);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdLoadingIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-loading-indicator',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'label', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdMenu = class MdMenu {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdMenu, selector: "md-menu", inputs: { anchor: "anchor", autoFocus: "autoFocus", density: "density", emptyText: "emptyText", layout: "layout", listLabel: "listLabel", listbox: "listbox", matchAnchorWidth: "matchAnchorWidth", maxHeight: "maxHeight", open: "open", persistent: "persistent", placement: "placement", quick: "quick", responsive: "responsive", useGap: "useGap", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdMenu = __decorate([
+    ProxyCmp({
+        inputs: ['anchor', 'autoFocus', 'density', 'emptyText', 'layout', 'listLabel', 'listbox', 'matchAnchorWidth', 'maxHeight', 'open', 'persistent', 'placement', 'quick', 'responsive', 'useGap', 'variant'],
+        methods: ['setComboboxElement', 'setVirtualProvider', 'getScrollViewport', 'show', 'reposition', 'close']
+    })
+], MdMenu);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMenu, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-menu',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['anchor', 'autoFocus', 'density', 'emptyText', 'layout', 'listLabel', 'listbox', 'matchAnchorWidth', 'maxHeight', 'open', 'persistent', 'placement', 'quick', 'responsive', 'useGap', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdMenuItem = class MdMenuItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMenuItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdMenuItem, selector: "md-menu-item", inputs: { badge: "badge", checkPosition: "checkPosition", density: "density", disabled: "disabled", divider: "divider", gap: "gap", headline: "headline", indeterminate: "indeterminate", keepOpen: "keepOpen", presentation: "presentation", roleOverride: "roleOverride", selected: "selected", supportingText: "supportingText", trailingText: "trailingText", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdMenuItem = __decorate([
+    ProxyCmp({
+        inputs: ['badge', 'checkPosition', 'density', 'disabled', 'divider', 'gap', 'headline', 'indeterminate', 'keepOpen', 'presentation', 'roleOverride', 'selected', 'supportingText', 'trailingText', 'type']
+    })
+], MdMenuItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMenuItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-menu-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['badge', 'checkPosition', 'density', 'disabled', 'divider', 'gap', 'headline', 'indeterminate', 'keepOpen', 'presentation', 'roleOverride', 'selected', 'supportingText', 'trailingText', 'type'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdMenuItemGroup = class MdMenuItemGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMenuItemGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdMenuItemGroup, selector: "md-menu-item-group", inputs: { density: "density", label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdMenuItemGroup = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'label']
+    })
+], MdMenuItemGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMenuItemGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-menu-item-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'label'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdMeter = class MdMeter {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMeter, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdMeter, selector: "md-meter", inputs: { color: "color", density: "density", formatOptions: "formatOptions", label: "label", locale: "locale", max: "max", min: "min", showLabel: "showLabel", showValue: "showValue", size: "size", thickness: "thickness", value: "value", valueText: "valueText", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdMeter = __decorate([
+    ProxyCmp({
+        inputs: ['color', 'density', 'formatOptions', 'label', 'locale', 'max', 'min', 'showLabel', 'showValue', 'size', 'thickness', 'value', 'valueText', 'variant']
+    })
+], MdMeter);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMeter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-meter',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['color', 'density', 'formatOptions', 'label', 'locale', 'max', 'min', 'showLabel', 'showValue', 'size', 'thickness', 'value', 'valueText', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdMultiSelect = class MdMultiSelect {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdOpen', 'mdClose', 'mdRemove', 'mdClear', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMultiSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdMultiSelect, selector: "md-multi-select", inputs: { chipOverflow: "chipOverflow", chipPosition: "chipPosition", clearIcon: "clearIcon", clearLabel: "clearLabel", clearable: "clearable", countFormatter: "countFormatter", density: "density", disabled: "disabled", displayMode: "displayMode", dropdownIcon: "dropdownIcon", error: "error", errorText: "errorText", filterLabel: "filterLabel", filterMode: "filterMode", filterable: "filterable", label: "label", loading: "loading", loadingText: "loadingText", matchTriggerWidth: "matchTriggerWidth", maxHeight: "maxHeight", maxSelected: "maxSelected", name: "name", noOptionsText: "noOptionsText", noResultsText: "noResultsText", open: "open", options: "options", placeholder: "placeholder", placement: "placement", required: "required", reserveSupportingSpace: "reserveSupportingSpace", rowHeight: "rowHeight", searchPlaceholder: "searchPlaceholder", searchingLabel: "searchingLabel", selectAllLabel: "selectAllLabel", showSelectAll: "showSelectAll", softDisabled: "softDisabled", supportingText: "supportingText", trigger: "trigger", triggerIcon: "triggerIcon", triggerLabel: "triggerLabel", value: "value", valueMissingLabel: "valueMissingLabel", variant: "variant", virtualize: "virtualize" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdMultiSelect = __decorate([
+    ProxyCmp({
+        inputs: ['chipOverflow', 'chipPosition', 'clearIcon', 'clearLabel', 'clearable', 'countFormatter', 'density', 'disabled', 'displayMode', 'dropdownIcon', 'error', 'errorText', 'filterLabel', 'filterMode', 'filterable', 'label', 'loading', 'loadingText', 'matchTriggerWidth', 'maxHeight', 'maxSelected', 'name', 'noOptionsText', 'noResultsText', 'open', 'options', 'placeholder', 'placement', 'required', 'reserveSupportingSpace', 'rowHeight', 'searchPlaceholder', 'searchingLabel', 'selectAllLabel', 'showSelectAll', 'softDisabled', 'supportingText', 'trigger', 'triggerIcon', 'triggerLabel', 'value', 'valueMissingLabel', 'variant', 'virtualize'],
+        methods: ['show', 'close', 'focusTrigger', 'reset', 'loadOptions', 'setQuery', 'getLabels', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdMultiSelect);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdMultiSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-multi-select',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['chipOverflow', 'chipPosition', 'clearIcon', 'clearLabel', 'clearable', 'countFormatter', 'density', 'disabled', 'displayMode', 'dropdownIcon', 'error', 'errorText', 'filterLabel', 'filterMode', 'filterable', 'label', 'loading', 'loadingText', 'matchTriggerWidth', 'maxHeight', 'maxSelected', 'name', 'noOptionsText', 'noResultsText', 'open', 'options', 'placeholder', 'placement', 'required', 'reserveSupportingSpace', 'rowHeight', 'searchPlaceholder', 'searchingLabel', 'selectAllLabel', 'showSelectAll', 'softDisabled', 'supportingText', 'trigger', 'triggerIcon', 'triggerLabel', 'value', 'valueMissingLabel', 'variant', 'virtualize'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdNavigationBar = class MdNavigationBar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdNavigationBar, selector: "md-navigation-bar", inputs: { activeIndex: "activeIndex", density: "density", labelBehavior: "labelBehavior", manualActivation: "manualActivation" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdNavigationBar = __decorate([
+    ProxyCmp({
+        inputs: ['activeIndex', 'density', 'labelBehavior', 'manualActivation'],
+        methods: ['select', 'focusTab']
+    })
+], MdNavigationBar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-navigation-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['activeIndex', 'density', 'labelBehavior', 'manualActivation'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdNavigationRail = class MdNavigationRail {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdTabChange', 'mdExpand', 'mdCollapse']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationRail, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdNavigationRail, selector: "md-navigation-rail", inputs: { activeIndex: "activeIndex", alignment: "alignment", density: "density", disableFocusManagement: "disableFocusManagement", expandable: "expandable", fullHeight: "fullHeight", label: "label", labelVisibility: "labelVisibility", maxVisible: "maxVisible", modal: "modal", orientation: "orientation", overflowIcon: "overflowIcon", overflowLabel: "overflowLabel", toggleLabel: "toggleLabel", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdNavigationRail = __decorate([
+    ProxyCmp({
+        inputs: ['activeIndex', 'alignment', 'density', 'disableFocusManagement', 'expandable', 'fullHeight', 'label', 'labelVisibility', 'maxVisible', 'modal', 'orientation', 'overflowIcon', 'overflowLabel', 'toggleLabel', 'variant'],
+        methods: ['expand', 'collapse', 'toggle', 'focusTab']
+    })
+], MdNavigationRail);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationRail, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-navigation-rail',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['activeIndex', 'alignment', 'density', 'disableFocusManagement', 'expandable', 'fullHeight', 'label', 'labelVisibility', 'maxVisible', 'modal', 'orientation', 'overflowIcon', 'overflowLabel', 'toggleLabel', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdNavigationRailTab = class MdNavigationRailTab {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdTabClick', 'mdSubmenuToggle']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationRailTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdNavigationRailTab, selector: "md-navigation-rail-tab", inputs: { active: "active", badge: "badge", badgeValue: "badgeValue", density: "density", disabled: "disabled", expanded: "expanded", href: "href", icon: "icon", label: "label", labelVisibility: "labelVisibility", target: "target", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdNavigationRailTab = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'badge', 'badgeValue', 'density', 'disabled', 'expanded', 'href', 'icon', 'label', 'labelVisibility', 'target', 'value'],
+        methods: ['clearSubmenuSelection']
+    })
+], MdNavigationRailTab);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationRailTab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-navigation-rail-tab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'badge', 'badgeValue', 'density', 'disabled', 'expanded', 'href', 'icon', 'label', 'labelVisibility', 'target', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdNavigationTab = class MdNavigationTab {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdTabClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdNavigationTab, selector: "md-navigation-tab", inputs: { active: "active", activeIcon: "activeIcon", badge: "badge", badgeMax: "badgeMax", badgeValue: "badgeValue", density: "density", disabled: "disabled", href: "href", icon: "icon", label: "label", labelBehavior: "labelBehavior", softDisabled: "softDisabled", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdNavigationTab = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'activeIcon', 'badge', 'badgeMax', 'badgeValue', 'density', 'disabled', 'href', 'icon', 'label', 'labelBehavior', 'softDisabled', 'target'],
+        methods: ['focusEl']
+    })
+], MdNavigationTab);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNavigationTab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-navigation-tab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'activeIcon', 'badge', 'badgeMax', 'badgeValue', 'density', 'disabled', 'href', 'icon', 'label', 'labelBehavior', 'softDisabled', 'target'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdNumberField = class MdNumberField {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdChange', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNumberField, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdNumberField, selector: "md-number-field", inputs: { allowOutOfRange: "allowOutOfRange", allowWheelScrub: "allowWheelScrub", decrementLabel: "decrementLabel", density: "density", disabled: "disabled", error: "error", errorText: "errorText", formatOptions: "formatOptions", incrementLabel: "incrementLabel", label: "label", largeStep: "largeStep", locale: "locale", max: "max", min: "min", name: "name", placeholder: "placeholder", readOnly: "readOnly", required: "required", reserveSupportingSpace: "reserveSupportingSpace", smallStep: "smallStep", snapOnStep: "snapOnStep", step: "step", steppers: "steppers", supportingText: "supportingText", value: "value", valueMissingLabel: "valueMissingLabel", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdNumberField = __decorate([
+    ProxyCmp({
+        inputs: ['allowOutOfRange', 'allowWheelScrub', 'decrementLabel', 'density', 'disabled', 'error', 'errorText', 'formatOptions', 'incrementLabel', 'label', 'largeStep', 'locale', 'max', 'min', 'name', 'placeholder', 'readOnly', 'required', 'reserveSupportingSpace', 'smallStep', 'snapOnStep', 'step', 'steppers', 'supportingText', 'value', 'valueMissingLabel', 'variant'],
+        methods: ['setFocus', 'select', 'stepUp', 'stepDown', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdNumberField);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdNumberField, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-number-field',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['allowOutOfRange', 'allowWheelScrub', 'decrementLabel', 'density', 'disabled', 'error', 'errorText', 'formatOptions', 'incrementLabel', 'label', 'largeStep', 'locale', 'max', 'min', 'name', 'placeholder', 'readOnly', 'required', 'reserveSupportingSpace', 'smallStep', 'snapOnStep', 'step', 'steppers', 'supportingText', 'value', 'valueMissingLabel', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdOrganizationChart = class MdOrganizationChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSelectionChange', 'mdNodeToggle']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdOrganizationChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdOrganizationChart, selector: "md-organization-chart", inputs: { collapseLabel: "collapseLabel", collapsible: "collapsible", density: "density", expandLabel: "expandLabel", label: "label", nodes: "nodes", orientation: "orientation", selectedIds: "selectedIds", selectionMode: "selectionMode" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdOrganizationChart = __decorate([
+    ProxyCmp({
+        inputs: ['collapseLabel', 'collapsible', 'density', 'expandLabel', 'label', 'nodes', 'orientation', 'selectedIds', 'selectionMode']
+    })
+], MdOrganizationChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdOrganizationChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-organization-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['collapseLabel', 'collapsible', 'density', 'expandLabel', 'label', 'nodes', 'orientation', 'selectedIds', 'selectionMode'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdOtpField = class MdOtpField {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdChange', 'mdComplete', 'mdInvalidInput', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdOtpField, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdOtpField, selector: "md-otp-field", inputs: { autoSubmit: "autoSubmit", cellLabelTemplate: "cellLabelTemplate", density: "density", disabled: "disabled", error: "error", errorText: "errorText", groupSize: "groupSize", incompleteLabel: "incompleteLabel", inputMode: "inputMode", label: "label", length: "length", mask: "mask", name: "name", readOnly: "readOnly", required: "required", reserveSupportingSpace: "reserveSupportingSpace", supportingText: "supportingText", transform: "transform", validationType: "validationType", value: "value", valueMissingLabel: "valueMissingLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdOtpField = __decorate([
+    ProxyCmp({
+        inputs: ['autoSubmit', 'cellLabelTemplate', 'density', 'disabled', 'error', 'errorText', 'groupSize', 'incompleteLabel', 'inputMode', 'label', 'length', 'mask', 'name', 'readOnly', 'required', 'reserveSupportingSpace', 'supportingText', 'transform', 'validationType', 'value', 'valueMissingLabel'],
+        methods: ['setFocus', 'clear', 'getValidity', 'setCustomValidity', 'checkValidity', 'reportValidity']
+    })
+], MdOtpField);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdOtpField, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-otp-field',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoSubmit', 'cellLabelTemplate', 'density', 'disabled', 'error', 'errorText', 'groupSize', 'incompleteLabel', 'inputMode', 'label', 'length', 'mask', 'name', 'readOnly', 'required', 'reserveSupportingSpace', 'supportingText', 'transform', 'validationType', 'value', 'valueMissingLabel'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdPieChart = class MdPieChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSliceClick', 'mdLegendClick', 'mdReady']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdPieChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdPieChart, selector: "md-pie-chart", inputs: { animation: "animation", animationDuration: "animationDuration", cornerRadius: "cornerRadius", data: "data", density: "density", endAngle: "endAngle", gradient: "gradient", heightProp: "heightProp", highlight: "highlight", innerRadius: "innerRadius", label: "label", labelEmpty: "labelEmpty", labelMode: "labelMode", labelPlot: "labelPlot", labelPoint: "labelPoint", legend: "legend", loading: "loading", loadingLabel: "loadingLabel", locale: "locale", monochrome: "monochrome", noAnimation: "noAnimation", outerRadius: "outerRadius", paddingAngle: "paddingAngle", ringWidths: "ringWidths", showLabels: "showLabels", startAngle: "startAngle", subtitle: "subtitle", summary: "summary", tableLabels: "tableLabels", titleAlign: "titleAlign", tooltip: "tooltip", tooltipRenderer: "tooltipRenderer", valueFormatter: "valueFormatter" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdPieChart = __decorate([
+    ProxyCmp({
+        inputs: ['animation', 'animationDuration', 'cornerRadius', 'data', 'density', 'endAngle', 'gradient', 'heightProp', 'highlight', 'innerRadius', 'label', 'labelEmpty', 'labelMode', 'labelPlot', 'labelPoint', 'legend', 'loading', 'loadingLabel', 'locale', 'monochrome', 'noAnimation', 'outerRadius', 'paddingAngle', 'ringWidths', 'showLabels', 'startAngle', 'subtitle', 'summary', 'tableLabels', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter'],
+        methods: ['resize', 'replay', 'drill', 'toDataURL', 'getInstance']
+    })
+], MdPieChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdPieChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-pie-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animation', 'animationDuration', 'cornerRadius', 'data', 'density', 'endAngle', 'gradient', 'heightProp', 'highlight', 'innerRadius', 'label', 'labelEmpty', 'labelMode', 'labelPlot', 'labelPoint', 'legend', 'loading', 'loadingLabel', 'locale', 'monochrome', 'noAnimation', 'outerRadius', 'paddingAngle', 'ringWidths', 'showLabels', 'startAngle', 'subtitle', 'summary', 'tableLabels', 'titleAlign', 'tooltip', 'tooltipRenderer', 'valueFormatter'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdProgressIndicator = class MdProgressIndicator {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdComplete']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdProgressIndicator, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdProgressIndicator, selector: "md-progress-indicator", inputs: { complete: "complete", density: "density", fourColor: "fourColor", indeterminate: "indeterminate", label: "label", max: "max", size: "size", thickness: "thickness", value: "value", variant: "variant", wave: "wave", waveAmplitude: "waveAmplitude", waveLength: "waveLength", waveSpeed: "waveSpeed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdProgressIndicator = __decorate([
+    ProxyCmp({
+        inputs: ['complete', 'density', 'fourColor', 'indeterminate', 'label', 'max', 'size', 'thickness', 'value', 'variant', 'wave', 'waveAmplitude', 'waveLength', 'waveSpeed']
+    })
+], MdProgressIndicator);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdProgressIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-progress-indicator',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['complete', 'density', 'fourColor', 'indeterminate', 'label', 'max', 'size', 'thickness', 'value', 'variant', 'wave', 'waveAmplitude', 'waveLength', 'waveSpeed'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdRadio = class MdRadio {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdFocus', 'mdBlur', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdRadio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdRadio, selector: "md-radio", inputs: { checked: "checked", density: "density", disabled: "disabled", name: "name", required: "required", softDisabled: "softDisabled", value: "value", valueMissingLabel: "valueMissingLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdRadio = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'density', 'disabled', 'name', 'required', 'softDisabled', 'value', 'valueMissingLabel'],
+        methods: ['syncValidityFromGroup', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity', 'setFocus', 'setBlur', 'select']
+    })
+], MdRadio);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdRadio, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-radio',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['checked', 'density', 'disabled', 'name', 'required', 'softDisabled', 'value', 'valueMissingLabel'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdRating = class MdRating {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdHover', 'mdChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdRating, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdRating, selector: "md-rating", inputs: { defaultValue: "defaultValue", density: "density", disabled: "disabled", emptyIcon: "emptyIcon", getLabel: "getLabel", hover: "hover", icon: "icon", max: "max", name: "name", outlineEmpty: "outlineEmpty", precision: "precision", ratingLabel: "ratingLabel", readonly: "readonly", showValueLabel: "showValueLabel", size: "size", softDisabled: "softDisabled", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdRating = __decorate([
+    ProxyCmp({
+        inputs: ['defaultValue', 'density', 'disabled', 'emptyIcon', 'getLabel', 'hover', 'icon', 'max', 'name', 'outlineEmpty', 'precision', 'ratingLabel', 'readonly', 'showValueLabel', 'size', 'softDisabled', 'value'],
+        methods: ['focusRating']
+    })
+], MdRating);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdRating, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-rating',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['defaultValue', 'density', 'disabled', 'emptyIcon', 'getLabel', 'hover', 'icon', 'max', 'name', 'outlineEmpty', 'precision', 'ratingLabel', 'readonly', 'showValueLabel', 'size', 'softDisabled', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdRipple = class MdRipple {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdRipple, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdRipple, selector: "md-ripple", inputs: { disabled: "disabled" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdRipple = __decorate([
+    ProxyCmp({
+        inputs: ['disabled'],
+        methods: ['whenSettled', 'trigger']
+    })
+], MdRipple);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdRipple, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-ripple',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSearch = class MdSearch {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdSearch', 'mdSubmit', 'mdChange', 'mdOpen', 'mdClose', 'mdClear', 'mdVoice', 'mdLeadingIconClick', 'mdTrailingIconClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSearch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSearch, selector: "md-search", inputs: { announceResults: "announceResults", debounce: "debounce", density: "density", disabled: "disabled", dismissOnOutsideClick: "dismissOnOutsideClick", elevation: "elevation", escapeCloses: "escapeCloses", fullWidth: "fullWidth", initialFocus: "initialFocus", inputAriaLabel: "inputAriaLabel", layout: "layout", leadingIcon: "leadingIcon", loading: "loading", loadingLabel: "loadingLabel", maxBlockSize: "maxBlockSize", noResultsLabel: "noResultsLabel", open: "open", openLeadingIcon: "openLeadingIcon", placeholder: "placeholder", resultsLabel: "resultsLabel", scrollShadow: "scrollShadow", showClearButton: "showClearButton", throttle: "throttle", trigger: "trigger", triggerElement: "triggerElement", triggerFor: "triggerFor", triggerIcon: "triggerIcon", value: "value", variant: "variant", voiceSearch: "voiceSearch" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSearch = __decorate([
+    ProxyCmp({
+        inputs: ['announceResults', 'debounce', 'density', 'disabled', 'dismissOnOutsideClick', 'elevation', 'escapeCloses', 'fullWidth', 'initialFocus', 'inputAriaLabel', 'layout', 'leadingIcon', 'loading', 'loadingLabel', 'maxBlockSize', 'noResultsLabel', 'open', 'openLeadingIcon', 'placeholder', 'resultsLabel', 'scrollShadow', 'showClearButton', 'throttle', 'trigger', 'triggerElement', 'triggerFor', 'triggerIcon', 'value', 'variant', 'voiceSearch'],
+        methods: ['show', 'close', 'toggle', 'focusInput', 'startVoice', 'stopVoice']
+    })
+], MdSearch);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSearch, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-search',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['announceResults', 'debounce', 'density', 'disabled', 'dismissOnOutsideClick', 'elevation', 'escapeCloses', 'fullWidth', 'initialFocus', 'inputAriaLabel', 'layout', 'leadingIcon', 'loading', 'loadingLabel', 'maxBlockSize', 'noResultsLabel', 'open', 'openLeadingIcon', 'placeholder', 'resultsLabel', 'scrollShadow', 'showClearButton', 'throttle', 'trigger', 'triggerElement', 'triggerFor', 'triggerIcon', 'value', 'variant', 'voiceSearch'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSegmentedButton = class MdSegmentedButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSegmentClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSegmentedButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSegmentedButton, selector: "md-segmented-button", inputs: { density: "density", disabled: "disabled", icon: "icon", label: "label", noCheckmark: "noCheckmark", ripple: "ripple", segmentDensity: "segmentDensity", segmentIndex: "segmentIndex", segmentMultiselect: "segmentMultiselect", segmentTotal: "segmentTotal", selected: "selected", softDisabled: "softDisabled", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSegmentedButton = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'disabled', 'icon', 'label', 'noCheckmark', 'ripple', 'segmentDensity', 'segmentIndex', 'segmentMultiselect', 'segmentTotal', 'selected', 'softDisabled', 'value']
+    })
+], MdSegmentedButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSegmentedButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-segmented-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'disabled', 'icon', 'label', 'noCheckmark', 'ripple', 'segmentDensity', 'segmentIndex', 'segmentMultiselect', 'segmentTotal', 'selected', 'softDisabled', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSegmentedButtonSet = class MdSegmentedButtonSet {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSegmentedButtonSet, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSegmentedButtonSet, selector: "md-segmented-button-set", inputs: { density: "density", multiselect: "multiselect" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSegmentedButtonSet = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'multiselect']
+    })
+], MdSegmentedButtonSet);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSegmentedButtonSet, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-segmented-button-set',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'multiselect'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSelect = class MdSelect {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdOpen', 'mdClose', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSelect, selector: "md-select", inputs: { clearIcon: "clearIcon", clearLabel: "clearLabel", clearable: "clearable", density: "density", disabled: "disabled", dropdownIcon: "dropdownIcon", error: "error", errorText: "errorText", filterLabel: "filterLabel", filterMode: "filterMode", filterable: "filterable", fullWidth: "fullWidth", label: "label", loading: "loading", loadingText: "loadingText", matchTriggerWidth: "matchTriggerWidth", maxHeight: "maxHeight", name: "name", noOptionsText: "noOptionsText", noResultsText: "noResultsText", open: "open", options: "options", placeholder: "placeholder", placement: "placement", required: "required", reserveSupportingSpace: "reserveSupportingSpace", rowHeight: "rowHeight", searchPlaceholder: "searchPlaceholder", searchingLabel: "searchingLabel", supportingText: "supportingText", value: "value", valueMissingLabel: "valueMissingLabel", variant: "variant", virtualize: "virtualize" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSelect = __decorate([
+    ProxyCmp({
+        inputs: ['clearIcon', 'clearLabel', 'clearable', 'density', 'disabled', 'dropdownIcon', 'error', 'errorText', 'filterLabel', 'filterMode', 'filterable', 'fullWidth', 'label', 'loading', 'loadingText', 'matchTriggerWidth', 'maxHeight', 'name', 'noOptionsText', 'noResultsText', 'open', 'options', 'placeholder', 'placement', 'required', 'reserveSupportingSpace', 'rowHeight', 'searchPlaceholder', 'searchingLabel', 'supportingText', 'value', 'valueMissingLabel', 'variant', 'virtualize'],
+        methods: ['show', 'close', 'focusTrigger', 'reset', 'loadOptions', 'setQuery', 'getLabels', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdSelect);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-select',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clearIcon', 'clearLabel', 'clearable', 'density', 'disabled', 'dropdownIcon', 'error', 'errorText', 'filterLabel', 'filterMode', 'filterable', 'fullWidth', 'label', 'loading', 'loadingText', 'matchTriggerWidth', 'maxHeight', 'name', 'noOptionsText', 'noResultsText', 'open', 'options', 'placeholder', 'placement', 'required', 'reserveSupportingSpace', 'rowHeight', 'searchPlaceholder', 'searchingLabel', 'supportingText', 'value', 'valueMissingLabel', 'variant', 'virtualize'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSelectOption = class MdSelectOption {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSelectOptionChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSelectOption, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSelectOption, selector: "md-select-option", inputs: { disabled: "disabled", icon: "icon", iconColor: "iconColor", label: "label", selected: "selected", supportingText: "supportingText", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSelectOption = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'icon', 'iconColor', 'label', 'selected', 'supportingText', 'value']
+    })
+], MdSelectOption);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSelectOption, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-select-option',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'icon', 'iconColor', 'label', 'selected', 'supportingText', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSideSheet = class MdSideSheet {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose', 'mdCancel', 'mdBack']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSideSheet, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSideSheet, selector: "md-side-sheet", inputs: { bottomDivider: "bottomDivider", closeable: "closeable", density: "density", detached: "detached", headline: "headline", open: "open", scrimDismissible: "scrimDismissible", sheetAriaLabel: "sheetAriaLabel", showBack: "showBack", side: "side", topDivider: "topDivider", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSideSheet = __decorate([
+    ProxyCmp({
+        inputs: ['bottomDivider', 'closeable', 'density', 'detached', 'headline', 'open', 'scrimDismissible', 'sheetAriaLabel', 'showBack', 'side', 'topDivider', 'variant'],
+        methods: ['show', 'close']
+    })
+], MdSideSheet);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSideSheet, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-side-sheet',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['bottomDivider', 'closeable', 'density', 'detached', 'headline', 'open', 'scrimDismissible', 'sheetAriaLabel', 'showBack', 'side', 'topDivider', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSkeleton = class MdSkeleton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSkeleton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSkeleton, selector: "md-skeleton", inputs: { animation: "animation", announce: "announce", ariaLabelProp: "ariaLabelProp", density: "density", fullHeight: "fullHeight", fullWidth: "fullWidth", height: "height", lines: "lines", variant: "variant", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSkeleton = __decorate([
+    ProxyCmp({
+        inputs: ['animation', 'announce', 'ariaLabelProp', 'density', 'fullHeight', 'fullWidth', 'height', 'lines', 'variant', 'width']
+    })
+], MdSkeleton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSkeleton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-skeleton',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animation', 'announce', 'ariaLabelProp', 'density', 'fullHeight', 'fullWidth', 'height', 'lines', 'variant', 'width'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSlider = class MdSlider {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdChange', 'mdFocus', 'mdBlur', 'mdDragStart', 'mdDragEnd']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSlider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSlider, selector: "md-slider", inputs: { ariaLabelEnd: "ariaLabelEnd", ariaLabelStart: "ariaLabelStart", controlled: "controlled", density: "density", disabled: "disabled", fullHeight: "fullHeight", icon: "icon", insetIcon: "insetIcon", labeled: "labeled", max: "max", min: "min", name: "name", nameEnd: "nameEnd", nameStart: "nameStart", orientation: "orientation", range: "range", size: "size", sliderAriaLabel: "sliderAriaLabel", step: "step", stops: "stops", value: "value", valueEnd: "valueEnd", valueEndText: "valueEndText", valueIndicator: "valueIndicator", valueStart: "valueStart", valueStartText: "valueStartText", valueText: "valueText", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSlider = __decorate([
+    ProxyCmp({
+        inputs: ['ariaLabelEnd', 'ariaLabelStart', 'controlled', 'density', 'disabled', 'fullHeight', 'icon', 'insetIcon', 'labeled', 'max', 'min', 'name', 'nameEnd', 'nameStart', 'orientation', 'range', 'size', 'sliderAriaLabel', 'step', 'stops', 'value', 'valueEnd', 'valueEndText', 'valueIndicator', 'valueStart', 'valueStartText', 'valueText', 'variant']
+    })
+], MdSlider);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSlider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-slider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['ariaLabelEnd', 'ariaLabelStart', 'controlled', 'density', 'disabled', 'fullHeight', 'icon', 'insetIcon', 'labeled', 'max', 'min', 'name', 'nameEnd', 'nameStart', 'orientation', 'range', 'size', 'sliderAriaLabel', 'step', 'stops', 'value', 'valueEnd', 'valueEndText', 'valueIndicator', 'valueStart', 'valueStartText', 'valueText', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSnackbar = class MdSnackbar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose', 'mdAction']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSnackbar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSnackbar, selector: "md-snackbar", inputs: { action: "action", autoHide: "autoHide", autoHideDuration: "autoHideDuration", closeable: "closeable", density: "density", dismissLabel: "dismissLabel", message: "message", open: "open", politeness: "politeness", position: "position", stacked: "stacked" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSnackbar = __decorate([
+    ProxyCmp({
+        inputs: ['action', 'autoHide', 'autoHideDuration', 'closeable', 'density', 'dismissLabel', 'message', 'open', 'politeness', 'position', 'stacked'],
+        methods: ['show', 'hide']
+    })
+], MdSnackbar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSnackbar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-snackbar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['action', 'autoHide', 'autoHideDuration', 'closeable', 'density', 'dismissLabel', 'message', 'open', 'politeness', 'position', 'stacked'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSparkline = class MdSparkline {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSparkClick', 'mdReady']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSparkline, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSparkline, selector: "md-sparkline", inputs: { barWidth: "barWidth", color: "color", cornerRadius: "cornerRadius", curve: "curve", data: "data", heightProp: "heightProp", labels: "labels", lineWidth: "lineWidth", markSize: "markSize", max: "max", min: "min", noAnimation: "noAnimation", referenceAreas: "referenceAreas", showMarks: "showMarks", showTooltip: "showTooltip", valueFormatter: "valueFormatter", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSparkline = __decorate([
+    ProxyCmp({
+        inputs: ['barWidth', 'color', 'cornerRadius', 'curve', 'data', 'heightProp', 'labels', 'lineWidth', 'markSize', 'max', 'min', 'noAnimation', 'referenceAreas', 'showMarks', 'showTooltip', 'valueFormatter', 'variant'],
+        methods: ['resize', 'getInstance']
+    })
+], MdSparkline);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSparkline, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-sparkline',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['barWidth', 'color', 'cornerRadius', 'curve', 'data', 'heightProp', 'labels', 'lineWidth', 'markSize', 'max', 'min', 'noAnimation', 'referenceAreas', 'showMarks', 'showTooltip', 'valueFormatter', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSplitButton = class MdSplitButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdLeadingClick', 'mdTrailingClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSplitButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSplitButton, selector: "md-split-button", inputs: { controls: "controls", density: "density", disabled: "disabled", fullWidth: "fullWidth", haspopup: "haspopup", icon: "icon", label: "label", menuLabel: "menuLabel", ripple: "ripple", size: "size", softDisabled: "softDisabled", trailingChecked: "trailingChecked", trailingIcon: "trailingIcon", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSplitButton = __decorate([
+    ProxyCmp({
+        inputs: ['controls', 'density', 'disabled', 'fullWidth', 'haspopup', 'icon', 'label', 'menuLabel', 'ripple', 'size', 'softDisabled', 'trailingChecked', 'trailingIcon', 'variant']
+    })
+], MdSplitButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSplitButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-split-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['controls', 'density', 'disabled', 'fullWidth', 'haspopup', 'icon', 'label', 'menuLabel', 'ripple', 'size', 'softDisabled', 'trailingChecked', 'trailingIcon', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdStatusDot = class MdStatusDot {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdStatusDot, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdStatusDot, selector: "md-status-dot", inputs: { density: "density", label: "label", live: "live", size: "size", state: "state" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdStatusDot = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'label', 'live', 'size', 'state']
+    })
+], MdStatusDot);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdStatusDot, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-status-dot',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'label', 'live', 'size', 'state'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdStep = class MdStep {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdStepClick', 'mdStepNext', 'mdStepBack']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdStep, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdStep, selector: "md-step", inputs: { accessibleName: "accessibleName", active: "active", completed: "completed", completedIcon: "completedIcon", density: "density", description: "description", disabled: "disabled", editable: "editable", error: "error", errorIcon: "errorIcon", errorText: "errorText", hideActions: "hideActions", icon: "icon", label: "label", optional: "optional" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdStep = __decorate([
+    ProxyCmp({
+        inputs: ['accessibleName', 'active', 'completed', 'completedIcon', 'density', 'description', 'disabled', 'editable', 'error', 'errorIcon', 'errorText', 'hideActions', 'icon', 'label', 'optional']
+    })
+], MdStep);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdStep, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-step',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['accessibleName', 'active', 'completed', 'completedIcon', 'density', 'description', 'disabled', 'editable', 'error', 'errorIcon', 'errorText', 'hideActions', 'icon', 'label', 'optional'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdStepper = class MdStepper {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdBeforeChange', 'mdStepChange', 'mdComplete']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdStepper, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdStepper, selector: "md-stepper", inputs: { active: "active", autoComplete: "autoComplete", backLabel: "backLabel", completedWord: "completedWord", currentWord: "currentWord", density: "density", errorWord: "errorWord", finishLabel: "finishLabel", indicator: "indicator", label: "label", lazy: "lazy", loading: "loading", mode: "mode", nav: "nav", nextDisabled: "nextDisabled", nextLabel: "nextLabel", ofWord: "ofWord", optionalWord: "optionalWord", orientation: "orientation", stepWord: "stepWord", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdStepper = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'autoComplete', 'backLabel', 'completedWord', 'currentWord', 'density', 'errorWord', 'finishLabel', 'indicator', 'label', 'lazy', 'loading', 'mode', 'nav', 'nextDisabled', 'nextLabel', 'ofWord', 'optionalWord', 'orientation', 'stepWord', 'variant'],
+        methods: ['next', 'prev', 'goTo', 'reset']
+    })
+], MdStepper);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdStepper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-stepper',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'autoComplete', 'backLabel', 'completedWord', 'currentWord', 'density', 'errorWord', 'finishLabel', 'indicator', 'label', 'lazy', 'loading', 'mode', 'nav', 'nextDisabled', 'nextLabel', 'ofWord', 'optionalWord', 'orientation', 'stepWord', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSubMenuItem = class MdSubMenuItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSubMenuItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSubMenuItem, selector: "md-sub-menu-item", inputs: { badge: "badge", density: "density", disabled: "disabled", divider: "divider", gap: "gap", headline: "headline", supportingText: "supportingText" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSubMenuItem = __decorate([
+    ProxyCmp({
+        inputs: ['badge', 'density', 'disabled', 'divider', 'gap', 'headline', 'supportingText'],
+        methods: ['collapse']
+    })
+], MdSubMenuItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSubMenuItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-sub-menu-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['badge', 'density', 'disabled', 'divider', 'gap', 'headline', 'supportingText'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdSwitch = class MdSwitch {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdChange', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSwitch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdSwitch, selector: "md-switch", inputs: { density: "density", disabled: "disabled", icons: "icons", name: "name", required: "required", selected: "selected", selectedIcon: "selectedIcon", showOnlySelectedIcon: "showOnlySelectedIcon", softDisabled: "softDisabled", unselectedIcon: "unselectedIcon", value: "value", valueMissingLabel: "valueMissingLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdSwitch = __decorate([
+    ProxyCmp({
+        inputs: ['density', 'disabled', 'icons', 'name', 'required', 'selected', 'selectedIcon', 'showOnlySelectedIcon', 'softDisabled', 'unselectedIcon', 'value', 'valueMissingLabel'],
+        methods: ['setFocus', 'getValidity', 'checkValidity', 'reportValidity', 'setCustomValidity']
+    })
+], MdSwitch);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdSwitch, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-switch',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['density', 'disabled', 'icons', 'name', 'required', 'selected', 'selectedIcon', 'showOnlySelectedIcon', 'softDisabled', 'unselectedIcon', 'value', 'valueMissingLabel'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTab = class MdTab {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdTabClick']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTab, selector: "md-tab", inputs: { active: "active", badge: "badge", controls: "controls", density: "density", disabled: "disabled", icon: "icon", inlineIcon: "inlineIcon", label: "label", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTab = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'badge', 'controls', 'density', 'disabled', 'icon', 'inlineIcon', 'label', 'variant']
+    })
+], MdTab);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-tab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'badge', 'controls', 'density', 'disabled', 'icon', 'inlineIcon', 'label', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTabPanel = class MdTabPanel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTabPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTabPanel, selector: "md-tab-panel", inputs: { active: "active" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTabPanel = __decorate([
+    ProxyCmp({
+        inputs: ['active']
+    })
+], MdTabPanel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTabPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-tab-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTabPanels = class MdTabPanels {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTabPanels, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTabPanels, selector: "md-tab-panels", inputs: { for: "for", sizing: "sizing" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTabPanels = __decorate([
+    ProxyCmp({
+        inputs: ['for', 'sizing']
+    })
+], MdTabPanels);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTabPanels, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-tab-panels',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['for', 'sizing'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTable = class MdTable {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSortChange', 'mdSelectionChange', 'mdPinChange', 'mdColumnVisibilityChange', 'mdScroll']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTable, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTable, selector: "md-table", inputs: { caption: "caption", columnTemplate: "columnTemplate", columns: "columns", density: "density", empty: "empty", frozenHeader: "frozenHeader", hoverable: "hoverable", keepHeight: "keepHeight", label: "label", loading: "loading", loadingMode: "loadingMode", loadingRows: "loadingRows", minWidth: "minWidth", motion: "motion", noDividers: "noDividers", pinIcon: "pinIcon", pinMode: "pinMode", rowCount: "rowCount", rowOffset: "rowOffset", scrollbar: "scrollbar", selection: "selection", sortBy: "sortBy", sortOrder: "sortOrder", stickyFooter: "stickyFooter", stickyHeader: "stickyHeader", striped: "striped", summary: "summary" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTable = __decorate([
+    ProxyCmp({
+        inputs: ['caption', 'columnTemplate', 'columns', 'density', 'empty', 'frozenHeader', 'hoverable', 'keepHeight', 'label', 'loading', 'loadingMode', 'loadingRows', 'minWidth', 'motion', 'noDividers', 'pinIcon', 'pinMode', 'rowCount', 'rowOffset', 'scrollbar', 'selection', 'sortBy', 'sortOrder', 'stickyFooter', 'stickyHeader', 'striped', 'summary'],
+        methods: ['getSelection', 'selectAll', 'deselectAll', 'toggleSelectAll', 'setSort', 'pinColumn', 'setColumnVisibility', 'animateNextChange']
+    })
+], MdTable);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTable, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['caption', 'columnTemplate', 'columns', 'density', 'empty', 'frozenHeader', 'hoverable', 'keepHeight', 'label', 'loading', 'loadingMode', 'loadingRows', 'minWidth', 'motion', 'noDividers', 'pinIcon', 'pinMode', 'rowCount', 'rowOffset', 'scrollbar', 'selection', 'sortBy', 'sortOrder', 'stickyFooter', 'stickyHeader', 'striped', 'summary'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableBody = class MdTableBody {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableBody, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableBody, selector: "md-table-body", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableBody = __decorate([
+    ProxyCmp({})
+], MdTableBody);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableBody, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-body',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableCell = class MdTableCell {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableCell, selector: "md-table-cell", inputs: { align: "align", colSpan: "colSpan", density: "density", ellipsis: "ellipsis", head: "head", noPinIndicator: "noPinIndicator", numeric: "numeric", padding: "padding", pinIcon: "pinIcon", rowSpan: "rowSpan", scope: "scope", sticky: "sticky", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableCell = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'colSpan', 'density', 'ellipsis', 'head', 'noPinIndicator', 'numeric', 'padding', 'pinIcon', 'rowSpan', 'scope', 'sticky', 'variant']
+    })
+], MdTableCell);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['align', 'colSpan', 'density', 'ellipsis', 'head', 'noPinIndicator', 'numeric', 'padding', 'pinIcon', 'rowSpan', 'scope', 'sticky', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableContainer = class MdTableContainer {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableContainer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableContainer, selector: "md-table-container", inputs: { elevation: "elevation", maxHeight: "maxHeight", minHeight: "minHeight", shape: "shape", variant: "variant", vibrant: "vibrant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableContainer = __decorate([
+    ProxyCmp({
+        inputs: ['elevation', 'maxHeight', 'minHeight', 'shape', 'variant', 'vibrant']
+    })
+], MdTableContainer);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableContainer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-container',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['elevation', 'maxHeight', 'minHeight', 'shape', 'variant', 'vibrant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableExpandToggle = class MdTableExpandToggle {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableExpandToggle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableExpandToggle, selector: "md-table-expand-toggle", inputs: { buttonLabel: "buttonLabel", icon: "icon" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableExpandToggle = __decorate([
+    ProxyCmp({
+        inputs: ['buttonLabel', 'icon']
+    })
+], MdTableExpandToggle);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableExpandToggle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-expand-toggle',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['buttonLabel', 'icon'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableFoot = class MdTableFoot {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableFoot, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableFoot, selector: "md-table-foot", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableFoot = __decorate([
+    ProxyCmp({})
+], MdTableFoot);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableFoot, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-foot',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableHead = class MdTableHead {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableHead, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableHead, selector: "md-table-head", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableHead = __decorate([
+    ProxyCmp({})
+], MdTableHead);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableHead, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-head',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTablePagination = class MdTablePagination {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdPageChange', 'mdRowsPerPageChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTablePagination, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTablePagination, selector: "md-table-pagination", inputs: { compact: "compact", count: "count", density: "density", disabled: "disabled", labelAll: "labelAll", labelDisplayedRows: "labelDisplayedRows", labelFirstPage: "labelFirstPage", labelLastPage: "labelLastPage", labelNextPage: "labelNextPage", labelPreviousPage: "labelPreviousPage", labelRowsPerPage: "labelRowsPerPage", page: "page", rowsPerPage: "rowsPerPage", rowsPerPageOptions: "rowsPerPageOptions", showFirstLast: "showFirstLast" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTablePagination = __decorate([
+    ProxyCmp({
+        inputs: ['compact', 'count', 'density', 'disabled', 'labelAll', 'labelDisplayedRows', 'labelFirstPage', 'labelLastPage', 'labelNextPage', 'labelPreviousPage', 'labelRowsPerPage', 'page', 'rowsPerPage', 'rowsPerPageOptions', 'showFirstLast'],
+        methods: ['goToPage', 'setRowsPerPage']
+    })
+], MdTablePagination);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTablePagination, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-pagination',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['compact', 'count', 'density', 'disabled', 'labelAll', 'labelDisplayedRows', 'labelFirstPage', 'labelLastPage', 'labelNextPage', 'labelPreviousPage', 'labelRowsPerPage', 'page', 'rowsPerPage', 'rowsPerPageOptions', 'showFirstLast'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableRow = class MdTableRow {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdRowClick', 'mdRowSelectionChange', 'mdRowExpandedChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableRow, selector: "md-table-row", inputs: { clickable: "clickable", disabled: "disabled", expandable: "expandable", expanded: "expanded", highlight: "highlight", rowgroup: "rowgroup", selectable: "selectable", selected: "selected", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableRow = __decorate([
+    ProxyCmp({
+        inputs: ['clickable', 'disabled', 'expandable', 'expanded', 'highlight', 'rowgroup', 'selectable', 'selected', 'value'],
+        methods: ['toggle']
+    })
+], MdTableRow);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clickable', 'disabled', 'expandable', 'expanded', 'highlight', 'rowgroup', 'selectable', 'selected', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableSortLabel = class MdTableSortLabel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdSortRequest']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableSortLabel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableSortLabel, selector: "md-table-sort-label", inputs: { active: "active", column: "column", defaultOrder: "defaultOrder", density: "density", disabled: "disabled", icon: "icon", iconPosition: "iconPosition", order: "order" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableSortLabel = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'column', 'defaultOrder', 'density', 'disabled', 'icon', 'iconPosition', 'order']
+    })
+], MdTableSortLabel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableSortLabel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-sort-label',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'column', 'defaultOrder', 'density', 'disabled', 'icon', 'iconPosition', 'order'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTableToolbar = class MdTableToolbar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableToolbar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTableToolbar, selector: "md-table-toolbar", inputs: { autoBind: "autoBind", compact: "compact", density: "density", headline: "headline", labelSelected: "labelSelected", numSelected: "numSelected", supportingText: "supportingText" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTableToolbar = __decorate([
+    ProxyCmp({
+        inputs: ['autoBind', 'compact', 'density', 'headline', 'labelSelected', 'numSelected', 'supportingText']
+    })
+], MdTableToolbar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTableToolbar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-table-toolbar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoBind', 'compact', 'density', 'headline', 'labelSelected', 'numSelected', 'supportingText'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTabs = class MdTabs {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdTabChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTabs, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTabs, selector: "md-tabs", inputs: { activeTabIndex: "activeTabIndex", ariaLabelProp: "ariaLabelProp", tabWidth: "tabWidth", variant: "variant", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTabs = __decorate([
+    ProxyCmp({
+        inputs: ['activeTabIndex', 'ariaLabelProp', 'tabWidth', 'variant', 'width'],
+        methods: ['selectTab']
+    })
+], MdTabs);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTabs, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-tabs',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['activeTabIndex', 'ariaLabelProp', 'tabWidth', 'variant', 'width'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTextField = class MdTextField {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdInput', 'mdChange', 'mdSearch', 'mdClear', 'mdPasswordToggle', 'mdSpeechResult', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTextField, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTextField, selector: "md-text-field", inputs: { appearFocused: "appearFocused", autoCapitalize: "autoCapitalize", autocomplete: "autocomplete", chipsWrap: "chipsWrap", clearable: "clearable", debounce: "debounce", density: "density", disabled: "disabled", enterKeyHint: "enterKeyHint", error: "error", errorText: "errorText", focusBorderWidth: "focusBorderWidth", formatOn: "formatOn", formatter: "formatter", inputAriaAutocomplete: "inputAriaAutocomplete", inputExpanded: "inputExpanded", inputMode: "inputMode", inputRole: "inputRole", label: "label", max: "max", maxLength: "maxLength", min: "min", minLength: "minLength", multiline: "multiline", name: "name", parser: "parser", passwordToggle: "passwordToggle", pattern: "pattern", placeholder: "placeholder", prefixText: "prefixText", readOnly: "readOnly", required: "required", reserveSupportingSpace: "reserveSupportingSpace", restrict: "restrict", rows: "rows", speechLang: "speechLang", speechToText: "speechToText", spellcheck: "spellcheck", step: "step", suffixText: "suffixText", supportingText: "supportingText", throttle: "throttle", type: "type", value: "value", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTextField = __decorate([
+    ProxyCmp({
+        inputs: ['appearFocused', 'autoCapitalize', 'autocomplete', 'chipsWrap', 'clearable', 'debounce', 'density', 'disabled', 'enterKeyHint', 'error', 'errorText', 'focusBorderWidth', 'formatOn', 'formatter', 'inputAriaAutocomplete', 'inputExpanded', 'inputMode', 'inputRole', 'label', 'max', 'maxLength', 'min', 'minLength', 'multiline', 'name', 'parser', 'passwordToggle', 'pattern', 'placeholder', 'prefixText', 'readOnly', 'required', 'reserveSupportingSpace', 'restrict', 'rows', 'speechLang', 'speechToText', 'spellcheck', 'step', 'suffixText', 'supportingText', 'throttle', 'type', 'value', 'variant'],
+        methods: ['setFocus', 'select', 'getInputElement', 'getValidity', 'setCustomValidity', 'checkValidity', 'reportValidity']
+    })
+], MdTextField);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTextField, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-text-field',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['appearFocused', 'autoCapitalize', 'autocomplete', 'chipsWrap', 'clearable', 'debounce', 'density', 'disabled', 'enterKeyHint', 'error', 'errorText', 'focusBorderWidth', 'formatOn', 'formatter', 'inputAriaAutocomplete', 'inputExpanded', 'inputMode', 'inputRole', 'label', 'max', 'maxLength', 'min', 'minLength', 'multiline', 'name', 'parser', 'passwordToggle', 'pattern', 'placeholder', 'prefixText', 'readOnly', 'required', 'reserveSupportingSpace', 'restrict', 'rows', 'speechLang', 'speechToText', 'spellcheck', 'step', 'suffixText', 'supportingText', 'throttle', 'type', 'value', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTimePicker = class MdTimePicker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdInput', 'mdOpen', 'mdClose', 'mdCancel', 'mdModeChange', 'mdValidityChange']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTimePicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTimePicker, selector: "md-time-picker", inputs: { amLabel: "amLabel", cancelLabel: "cancelLabel", density: "density", disabled: "disabled", format: "format", headline: "headline", headlineDialLabel: "headlineDialLabel", headlineInputLabel: "headlineInputLabel", hideTrigger: "hideTrigger", hourLabel: "hourLabel", label: "label", max: "max", min: "min", minuteLabel: "minuteLabel", minuteStep: "minuteStep", name: "name", okLabel: "okLabel", open: "open", orientation: "orientation", periodLabel: "periodLabel", periodLayout: "periodLayout", pmLabel: "pmLabel", rangeOutsideLabel: "rangeOutsideLabel", rangeOverflowLabel: "rangeOverflowLabel", rangeUnderflowLabel: "rangeUnderflowLabel", required: "required", responsive: "responsive", toggleDialLabel: "toggleDialLabel", toggleInputLabel: "toggleInputLabel", value: "value", valueMissingLabel: "valueMissingLabel", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTimePicker = __decorate([
+    ProxyCmp({
+        inputs: ['amLabel', 'cancelLabel', 'density', 'disabled', 'format', 'headline', 'headlineDialLabel', 'headlineInputLabel', 'hideTrigger', 'hourLabel', 'label', 'max', 'min', 'minuteLabel', 'minuteStep', 'name', 'okLabel', 'open', 'orientation', 'periodLabel', 'periodLayout', 'pmLabel', 'rangeOutsideLabel', 'rangeOverflowLabel', 'rangeUnderflowLabel', 'required', 'responsive', 'toggleDialLabel', 'toggleInputLabel', 'value', 'valueMissingLabel', 'variant'],
+        methods: ['show', 'hide', 'checkValidity', 'reportValidity', 'getValidity']
+    })
+], MdTimePicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTimePicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-time-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['amLabel', 'cancelLabel', 'density', 'disabled', 'format', 'headline', 'headlineDialLabel', 'headlineInputLabel', 'hideTrigger', 'hourLabel', 'label', 'max', 'min', 'minuteLabel', 'minuteStep', 'name', 'okLabel', 'open', 'orientation', 'periodLabel', 'periodLayout', 'pmLabel', 'rangeOutsideLabel', 'rangeOverflowLabel', 'rangeUnderflowLabel', 'required', 'responsive', 'toggleDialLabel', 'toggleInputLabel', 'value', 'valueMissingLabel', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdToolbar = class MdToolbar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdToolbar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdToolbar, selector: "md-toolbar", inputs: { alignment: "alignment", ariaLabelProp: "ariaLabelProp", ariaLabelledby: "ariaLabelledby", color: "color", containerSemantics: "containerSemantics", density: "density", layout: "layout", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdToolbar = __decorate([
+    ProxyCmp({
+        inputs: ['alignment', 'ariaLabelProp', 'ariaLabelledby', 'color', 'containerSemantics', 'density', 'layout', 'variant'],
+        methods: ['setFocus']
+    })
+], MdToolbar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdToolbar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-toolbar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['alignment', 'ariaLabelProp', 'ariaLabelledby', 'color', 'containerSemantics', 'density', 'layout', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTooltip = class MdTooltip {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdOpen', 'mdClose']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTooltip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTooltip, selector: "md-tooltip", inputs: { autoPosition: "autoPosition", crossOffset: "crossOffset", density: "density", disabled: "disabled", hideDelay: "hideDelay", offset: "offset", open: "open", position: "position", showDelay: "showDelay", subhead: "subhead", text: "text", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTooltip = __decorate([
+    ProxyCmp({
+        inputs: ['autoPosition', 'crossOffset', 'density', 'disabled', 'hideDelay', 'offset', 'open', 'position', 'showDelay', 'subhead', 'text', 'variant'],
+        methods: ['show', 'hide']
+    })
+], MdTooltip);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTooltip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-tooltip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoPosition', 'crossOffset', 'density', 'disabled', 'hideDelay', 'offset', 'open', 'position', 'showDelay', 'subhead', 'text', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let MdTransferList = class MdTransferList {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['mdChange', 'mdMove']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTransferList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MdTransferList, selector: "md-transfer-list", inputs: { countTemplate: "countTemplate", density: "density", disabled: "disabled", emptyIcon: "emptyIcon", emptyText: "emptyText", items: "items", moveAllLeftIcon: "moveAllLeftIcon", moveAllLeftLabel: "moveAllLeftLabel", moveAllRightIcon: "moveAllRightIcon", moveAllRightLabel: "moveAllRightLabel", moveLeftIcon: "moveLeftIcon", moveLeftLabel: "moveLeftLabel", moveRightIcon: "moveRightIcon", moveRightLabel: "moveRightLabel", searchIcon: "searchIcon", searchable: "searchable", showSelectAll: "showSelectAll", singleStepOnly: "singleStepOnly", sourceSearchPlaceholder: "sourceSearchPlaceholder", sourceTitle: "sourceTitle", targetSearchPlaceholder: "targetSearchPlaceholder", targetTitle: "targetTitle", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+MdTransferList = __decorate([
+    ProxyCmp({
+        inputs: ['countTemplate', 'density', 'disabled', 'emptyIcon', 'emptyText', 'items', 'moveAllLeftIcon', 'moveAllLeftLabel', 'moveAllRightIcon', 'moveAllRightLabel', 'moveLeftIcon', 'moveLeftLabel', 'moveRightIcon', 'moveRightLabel', 'searchIcon', 'searchable', 'showSelectAll', 'singleStepOnly', 'sourceSearchPlaceholder', 'sourceTitle', 'targetSearchPlaceholder', 'targetTitle', 'value'],
+        methods: ['moveSelectedRight', 'moveSelectedLeft']
+    })
+], MdTransferList);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MdTransferList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'md-transfer-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['countTemplate', 'density', 'disabled', 'emptyIcon', 'emptyText', 'items', 'moveAllLeftIcon', 'moveAllLeftLabel', 'moveAllRightIcon', 'moveAllRightLabel', 'moveLeftIcon', 'moveLeftLabel', 'moveRightIcon', 'moveRightLabel', 'searchIcon', 'searchable', 'showSelectAll', 'singleStepOnly', 'sourceSearchPlaceholder', 'sourceTitle', 'targetSearchPlaceholder', 'targetTitle', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+
+const DIRECTIVES = [
+    MdAccordion,
+    MdAccordionItem,
+    MdAppBar,
+    MdAreaChart,
+    MdAutocomplete,
+    MdAvatar,
+    MdBadge,
+    MdBarChart,
+    MdBottomSheet,
+    MdBreadcrumbItem,
+    MdBreadcrumbs,
+    MdButton,
+    MdButtonGroup,
+    MdCard,
+    MdCheckbox,
+    MdChip,
+    MdColorPicker,
+    MdDatePicker,
+    MdDialog,
+    MdDivider,
+    MdFab,
+    MdFabMenu,
+    MdFabMenuItem,
+    MdIconButton,
+    MdLineChart,
+    MdList,
+    MdListItem,
+    MdLoadingIndicator,
+    MdMenu,
+    MdMenuItem,
+    MdMenuItemGroup,
+    MdMeter,
+    MdMultiSelect,
+    MdNavigationBar,
+    MdNavigationRail,
+    MdNavigationRailTab,
+    MdNavigationTab,
+    MdNumberField,
+    MdOrganizationChart,
+    MdOtpField,
+    MdPieChart,
+    MdProgressIndicator,
+    MdRadio,
+    MdRating,
+    MdRipple,
+    MdSearch,
+    MdSegmentedButton,
+    MdSegmentedButtonSet,
+    MdSelect,
+    MdSelectOption,
+    MdSideSheet,
+    MdSkeleton,
+    MdSlider,
+    MdSnackbar,
+    MdSparkline,
+    MdSplitButton,
+    MdStatusDot,
+    MdStep,
+    MdStepper,
+    MdSubMenuItem,
+    MdSwitch,
+    MdTab,
+    MdTabPanel,
+    MdTabPanels,
+    MdTable,
+    MdTableBody,
+    MdTableCell,
+    MdTableContainer,
+    MdTableExpandToggle,
+    MdTableFoot,
+    MdTableHead,
+    MdTablePagination,
+    MdTableRow,
+    MdTableSortLabel,
+    MdTableToolbar,
+    MdTabs,
+    MdTextField,
+    MdTimePicker,
+    MdToolbar,
+    MdTooltip,
+    MdTransferList
+];
+
+class ValueAccessor {
+    constructor(el) {
+        this.el = el;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+    }
+    writeValue(value) {
+        this.el.nativeElement.value = this.lastValue = value == null ? '' : value;
+    }
+    handleChangeEvent(value) {
+        if (value !== this.lastValue) {
+            this.lastValue = value;
+            this.onChange(value);
+        }
+    }
+    _handleBlurEvent() {
+        this.onTouched();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.el.nativeElement.disabled = isDisabled;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ValueAccessor, host: { listeners: { "focusout": "_handleBlurEvent()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValueAccessor, decorators: [{
+            type: Directive,
+            args: [{}]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { _handleBlurEvent: [{
+                type: HostListener,
+                args: ['focusout']
+            }] } });
+
+class TextValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: TextValueAccessor, selector: "md-text-field, md-autocomplete, md-otp-field", host: { listeners: { "mdInput": "handleChangeEvent($event.target.value)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: TextValueAccessor,
+                multi: true
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'md-text-field, md-autocomplete, md-otp-field',
+                    host: {
+                        '(mdInput)': 'handleChangeEvent($event.target.value)'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: TextValueAccessor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+class SelectValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SelectValueAccessor, selector: "md-select, md-multi-select, md-date-picker, md-time-picker", host: { listeners: { "mdChange": "handleChangeEvent($event.target.value)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: SelectValueAccessor,
+                multi: true
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'md-select, md-multi-select, md-date-picker, md-time-picker',
+                    host: {
+                        '(mdChange)': 'handleChangeEvent($event.target.value)'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: SelectValueAccessor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+class BooleanValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+    writeValue(value) {
+        this.el.nativeElement.checked = this.lastValue = value == null ? false : value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BooleanValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BooleanValueAccessor, selector: "md-checkbox", host: { listeners: { "mdChange": "handleChangeEvent($event.target.checked)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: BooleanValueAccessor,
+                multi: true
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BooleanValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'md-checkbox',
+                    host: {
+                        '(mdChange)': 'handleChangeEvent($event.target.checked)'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: BooleanValueAccessor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+class RadioValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RadioValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: RadioValueAccessor, selector: "md-radio", host: { listeners: { "mdChange": "handleChangeEvent($event.target.checked)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: RadioValueAccessor,
+                multi: true
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RadioValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'md-radio',
+                    host: {
+                        '(mdChange)': 'handleChangeEvent($event.target.checked)'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: RadioValueAccessor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+class NumericValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+    registerOnChange(fn) {
+        super.registerOnChange(value => {
+            fn(value === '' ? null : parseFloat(value));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NumericValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: NumericValueAccessor, selector: "md-rating, md-slider, md-number-field", host: { listeners: { "mdChange": "handleChangeEvent($event.target.value)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: NumericValueAccessor,
+                multi: true
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NumericValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'md-rating, md-slider, md-number-field',
+                    host: {
+                        '(mdChange)': 'handleChangeEvent($event.target.value)'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: NumericValueAccessor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+/**
+ * ControlValueAccessor for `md-switch`.
+ *
+ * Hand-written rather than generated because md-switch stores its state in
+ * `selected`, not `checked`. The Stencil Angular output target merges every
+ * config that shares a `type`, so listing md-switch alongside md-checkbox under
+ * `boolean` produced ONE directive whose writeValue hardcoded `.checked` while
+ * its host binding read `.selected` — silently breaking both controls in
+ * opposite directions.
+ *
+ * This file is NOT generated, so the build will not overwrite it.
+ */
+class SwitchValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+    writeValue(value) {
+        this.el.nativeElement.selected = this.lastValue = value == null ? false : value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SwitchValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SwitchValueAccessor, selector: "md-switch", host: { listeners: { "mdChange": "handleChangeEvent($event.target.selected)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: SwitchValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SwitchValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'md-switch',
+                    host: {
+                        '(mdChange)': 'handleChangeEvent($event.target.selected)',
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: SwitchValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+/**
+ * ControlValueAccessor directives, so `[(ngModel)]` and `formControlName` bind
+ * to AWC UI inputs. Declared here rather than in `DIRECTIVES` because that
+ * array is GENERATED by the Stencil output target on every build and would
+ * discard anything added to it.
+ */
+const VALUE_ACCESSORS = [
+    TextValueAccessor,
+    SelectValueAccessor,
+    BooleanValueAccessor,
+    RadioValueAccessor,
+    NumericValueAccessor,
+    SwitchValueAccessor,
+];
+/**
+ * Registers the AWC UI custom elements (the Stencil lazy loader) during
+ * application bootstrap. Add it to your root providers instead of calling
+ * `defineCustomElements()` manually:
+ *
+ * @example
+ * // NgModule app
+ * @NgModule({
+ *   imports: [AwcUiModule],
+ *   providers: [provideAwcUi()],
+ * })
+ * export class AppModule {}
+ *
+ * // Standalone app
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideAwcUi(), importProvidersFrom(AwcUiModule)],
+ * });
+ *
+ * SSR-safe: it is a no-op when `window` is not available.
+ */
+function provideAwcUi() {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useValue: () => typeof window !== 'undefined' ? defineCustomElements(window) : Promise.resolve(),
+    };
+}
+/**
+ * AwcUiModule
+ *
+ * Import this module in your Angular application to use all AWC UI
+ * component proxies (typed inputs, outputs and methods).
+ *
+ * The underlying custom elements must be registered once. Either add
+ * `provideAwcUi()` to your root providers (recommended, see above), or
+ * call `defineCustomElements()` from `@awc-ui/core/loader` in `main.ts`:
+ *
+ * @example
+ * // main.ts
+ * import { defineCustomElements } from '@awc-ui/core/loader';
+ * defineCustomElements(window);
+ *
+ * // app.module.ts (or standalone component)
+ * import { AwcUiModule } from '@awc-ui/angular';
+ *
+ * @NgModule({
+ *   imports: [AwcUiModule, ...],
+ * })
+ * export class AppModule {}
+ */
+class AwcUiModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AwcUiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: AwcUiModule, declarations: [MdAccordion, MdAccordionItem, MdAppBar, MdAreaChart, MdAutocomplete, MdAvatar, MdBadge, MdBarChart, MdBottomSheet, MdBreadcrumbItem, MdBreadcrumbs, MdButton, MdButtonGroup, MdCard, MdCheckbox, MdChip, MdColorPicker, MdDatePicker, MdDialog, MdDivider, MdFab, MdFabMenu, MdFabMenuItem, MdIconButton, MdLineChart, MdList, MdListItem, MdLoadingIndicator, MdMenu, MdMenuItem, MdMenuItemGroup, MdMeter, MdMultiSelect, MdNavigationBar, MdNavigationRail, MdNavigationRailTab, MdNavigationTab, MdNumberField, MdOrganizationChart, MdOtpField, MdPieChart, MdProgressIndicator, MdRadio, MdRating, MdRipple, MdSearch, MdSegmentedButton, MdSegmentedButtonSet, MdSelect, MdSelectOption, MdSideSheet, MdSkeleton, MdSlider, MdSnackbar, MdSparkline, MdSplitButton, MdStatusDot, MdStep, MdStepper, MdSubMenuItem, MdSwitch, MdTab, MdTabPanel, MdTabPanels, MdTable, MdTableBody, MdTableCell, MdTableContainer, MdTableExpandToggle, MdTableFoot, MdTableHead, MdTablePagination, MdTableRow, MdTableSortLabel, MdTableToolbar, MdTabs, MdTextField, MdTimePicker, MdToolbar, MdTooltip, MdTransferList, TextValueAccessor,
+            SelectValueAccessor,
+            BooleanValueAccessor,
+            RadioValueAccessor,
+            NumericValueAccessor,
+            SwitchValueAccessor], imports: [CommonModule], exports: [MdAccordion, MdAccordionItem, MdAppBar, MdAreaChart, MdAutocomplete, MdAvatar, MdBadge, MdBarChart, MdBottomSheet, MdBreadcrumbItem, MdBreadcrumbs, MdButton, MdButtonGroup, MdCard, MdCheckbox, MdChip, MdColorPicker, MdDatePicker, MdDialog, MdDivider, MdFab, MdFabMenu, MdFabMenuItem, MdIconButton, MdLineChart, MdList, MdListItem, MdLoadingIndicator, MdMenu, MdMenuItem, MdMenuItemGroup, MdMeter, MdMultiSelect, MdNavigationBar, MdNavigationRail, MdNavigationRailTab, MdNavigationTab, MdNumberField, MdOrganizationChart, MdOtpField, MdPieChart, MdProgressIndicator, MdRadio, MdRating, MdRipple, MdSearch, MdSegmentedButton, MdSegmentedButtonSet, MdSelect, MdSelectOption, MdSideSheet, MdSkeleton, MdSlider, MdSnackbar, MdSparkline, MdSplitButton, MdStatusDot, MdStep, MdStepper, MdSubMenuItem, MdSwitch, MdTab, MdTabPanel, MdTabPanels, MdTable, MdTableBody, MdTableCell, MdTableContainer, MdTableExpandToggle, MdTableFoot, MdTableHead, MdTablePagination, MdTableRow, MdTableSortLabel, MdTableToolbar, MdTabs, MdTextField, MdTimePicker, MdToolbar, MdTooltip, MdTransferList, TextValueAccessor,
+            SelectValueAccessor,
+            BooleanValueAccessor,
+            RadioValueAccessor,
+            NumericValueAccessor,
+            SwitchValueAccessor] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AwcUiModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AwcUiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [...DIRECTIVES, ...VALUE_ACCESSORS],
+                    exports: [...DIRECTIVES, ...VALUE_ACCESSORS],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AwcUiModule, BooleanValueAccessor, DIRECTIVES, MdAccordion, MdAccordionItem, MdAppBar, MdAreaChart, MdAutocomplete, MdAvatar, MdBadge, MdBarChart, MdBottomSheet, MdBreadcrumbItem, MdBreadcrumbs, MdButton, MdButtonGroup, MdCard, MdCheckbox, MdChip, MdColorPicker, MdDatePicker, MdDialog, MdDivider, MdFab, MdFabMenu, MdFabMenuItem, MdIconButton, MdLineChart, MdList, MdListItem, MdLoadingIndicator, MdMenu, MdMenuItem, MdMenuItemGroup, MdMeter, MdMultiSelect, MdNavigationBar, MdNavigationRail, MdNavigationRailTab, MdNavigationTab, MdNumberField, MdOrganizationChart, MdOtpField, MdPieChart, MdProgressIndicator, MdRadio, MdRating, MdRipple, MdSearch, MdSegmentedButton, MdSegmentedButtonSet, MdSelect, MdSelectOption, MdSideSheet, MdSkeleton, MdSlider, MdSnackbar, MdSparkline, MdSplitButton, MdStatusDot, MdStep, MdStepper, MdSubMenuItem, MdSwitch, MdTab, MdTabPanel, MdTabPanels, MdTable, MdTableBody, MdTableCell, MdTableContainer, MdTableExpandToggle, MdTableFoot, MdTableHead, MdTablePagination, MdTableRow, MdTableSortLabel, MdTableToolbar, MdTabs, MdTextField, MdTimePicker, MdToolbar, MdTooltip, MdTransferList, NumericValueAccessor, RadioValueAccessor, SelectValueAccessor, SwitchValueAccessor, TextValueAccessor, VALUE_ACCESSORS, ValueAccessor, provideAwcUi };
+//# sourceMappingURL=awc-ui-angular.mjs.map