@aurelia-mdc-web/all 9.2.2-au2 → 9.3.0-au2

package/dist/types/segmented-button/mdc-segmented-button.d.ts

@@ -0,0 +1,20 @@
+import { MdcComponent } from '../base';
+import { MDCSegmentedButtonFoundation, SegmentDetail } from '@material/segmented-button';
+import { MdcSegmentedButtonSegment } from './mdc-segmented-button-segment/mdc-segmented-button-segment';
+/**
+ * @selector mdc-segmented-button
+ */
+export declare class MdcSegmentedButton extends MdcComponent<MDCSegmentedButtonFoundation> {
+    /** Indicates the segmented button only allows one segment to be selected at a time */
+    single: boolean;
+    singleChanged(): void;
+    segmentElements: HTMLElement[];
+    get segmentsList(): MdcSegmentedButtonSegment[];
+    initialSyncWithDOM(): void;
+    handleSelected(event: CustomEvent<SegmentDetail>): void;
+    getDefaultFoundation(): MDCSegmentedButtonFoundation;
+    /**
+     * @return Returns child segments mapped to readonly SegmentDetail list
+     */
+    private mappedSegments;
+}

package/dist/types/select/mdc-default-select-configuration.d.ts

@@ -0,0 +1,3 @@
+export declare class MdcDefaultSelectConfiguration {
+    outlined?: boolean;
+}

package/dist/types/select/mdc-select-adapter-aurelia.d.ts

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+import { Corner } from '@material/menu-surface/constants';
+/**
+ * Defines the shape of the adapter expected by the foundation.
+ * Implement this adapter for your framework of choice to delegate updates to
+ * the component in your framework of choice. See architecture documentation
+ * for more details.
+ * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md
+ * @hidden
+ */
+export interface MDCSelectAdapterAurelia {
+    /**
+     * Adds class to select anchor element.
+     */
+    addClass(className: string): void;
+    /**
+     * Removes a class from the select anchor element.
+     */
+    removeClass(className: string): void;
+    /**
+     * Returns true if the select anchor element contains the given class name.
+     */
+    hasClass(className: string): boolean;
+    /**
+     * Activates the bottom line, showing a focused state.
+     */
+    activateBottomLine(): void;
+    /**
+     * Deactivates the bottom line.
+     */
+    deactivateBottomLine(): void;
+    /**
+     * Returns true if label exists, false if it doesn't.
+     */
+    hasLabel(): boolean;
+    /**
+     * Floats label determined based off of the shouldFloat argument.
+     */
+    floatLabel(shouldFloat: boolean): void;
+    /**
+     * Returns width of label in pixels, if the label exists.
+     */
+    getLabelWidth(): number;
+    /**
+     * Styles the label as required, if the label exists.
+     */
+    setLabelRequired(isRequired: boolean): void;
+    /**
+     * Returns true if outline element exists, false if it doesn't.
+     */
+    hasOutline(): boolean;
+    /**
+     * Only implement if outline element exists.
+     */
+    notchOutline(labelWidth: number): void;
+    /**
+     * Closes notch in outline element, if the outline exists.
+     */
+    closeOutline(): void;
+    /**
+     * Sets the line ripple transform origin center.
+     */
+    setRippleCenter(normalizedX: number): void;
+    /**
+     * Emits a change event when an element is selected.
+     * !!! MODIFIED FOR AURELIA !!!
+     */
+    notifyChange(value: unknown): void;
+    /**
+     * Sets the text content of the selectedText element to the given string.
+     */
+    setSelectedText(text: string): void;
+    /**
+     * Returns whether the select anchor is focused.
+     */
+    isSelectAnchorFocused(): boolean;
+    /**
+     * Gets the given attribute on the select anchor element.
+     */
+    getSelectAnchorAttr(attr: string): string | null;
+    /**
+     * Sets the given attribute on the select anchor element.
+     */
+    setSelectAnchorAttr(attr: string, value: string): void;
+    /**
+     * Removes the given attribute on the select anchor element.
+     */
+    removeSelectAnchorAttr(attr: string): void;
+    /**
+     * Adds class to the menu element.
+     */
+    addMenuClass(className: string): void;
+    /**
+     * Removes a class from the menu element.
+     */
+    removeMenuClass(className: string): void;
+    /**
+     * Opens the menu.
+     */
+    openMenu(): void;
+    /**
+     * Closes the menu.
+     */
+    closeMenu(): void;
+    /**
+     * Returns the select anchor element.
+     */
+    getAnchorElement(): Element | null;
+    /**
+     * Sets the menu anchor element.
+     */
+    setMenuAnchorElement(anchorEl: Element): void;
+    /**
+     * Sets the menu anchor corner.
+     */
+    setMenuAnchorCorner(anchorCorner: Corner): void;
+    /**
+     * Sets whether the menu should wrap focus.
+     */
+    setMenuWrapFocus(wrapFocus: boolean): void;
+    /**
+     * Focuses the menu item element at the given index.
+     */
+    focusMenuItemAtIndex(index: number): void;
+    /**
+     * Returns the number of menu items.
+     */
+    getMenuItemCount(): number;
+    /**
+     * Returns an array representing the VALUE_ATTR attributes of each menu item.
+     * !!! MODIFIED FOR AURELIA !!!
+     */
+    getMenuItemValues(): unknown[];
+    /**
+     * Gets the text content of the menu item element at the given index.
+     */
+    getMenuItemTextAtIndex(index: number): string;
+    /**
+     * Returns the selected index.
+     */
+    getSelectedIndex(): number;
+    /**
+     * Sets the selected index in the menu.
+     */
+    setSelectedIndex(index: number): void;
+    /**
+     * Returns whether typeahead is in progress in the menu.
+     */
+    isTypeaheadInProgress(): boolean;
+    /**
+     * Adds a character to the list typeahead buffer and returns index of the
+     * next item in the list matching the buffer.
+     */
+    typeaheadMatchItem(nextChar: string, startingIndex: number): number;
+}

package/dist/types/select/mdc-select-foundation-aurelia.d.ts

@@ -0,0 +1,142 @@
+/**
+ * @license
+ * Copyright 2016 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+import { MDCFoundation } from '@material/base/foundation';
+import { MDCSelectAdapterAurelia } from './mdc-select-adapter-aurelia';
+import { MDCSelectFoundationMap } from '@material/select';
+export declare class MDCSelectFoundationAurelia extends MDCFoundation<MDCSelectAdapterAurelia> {
+    static get cssClasses(): {
+        ACTIVATED: string;
+        DISABLED: string;
+        FOCUSED: string;
+        INVALID: string;
+        MENU_INVALID: string;
+        OUTLINED: string;
+        REQUIRED: string;
+        ROOT: string;
+        WITH_LEADING_ICON: string;
+    };
+    static get numbers(): {
+        LABEL_SCALE: number;
+        UNSET_INDEX: number;
+        CLICK_DEBOUNCE_TIMEOUT_MS: number;
+    };
+    static get strings(): {
+        ARIA_CONTROLS: string;
+        ARIA_DESCRIBEDBY: string;
+        ARIA_SELECTED_ATTR: string;
+        CHANGE_EVENT: string;
+        HIDDEN_INPUT_SELECTOR: string;
+        LABEL_SELECTOR: string;
+        LEADING_ICON_SELECTOR: string;
+        LINE_RIPPLE_SELECTOR: string;
+        MENU_SELECTOR: string;
+        OUTLINE_SELECTOR: string;
+        SELECTED_TEXT_SELECTOR: string;
+        SELECT_ANCHOR_SELECTOR: string;
+        VALUE_ATTR: string;
+    };
+    /**
+     * See {@link MDCSelectAdapter} for typing information on parameters and return types.
+     */
+    static get defaultAdapter(): MDCSelectAdapterAurelia;
+    private readonly leadingIcon;
+    private readonly helperText;
+    private disabled;
+    private isMenuOpen;
+    private useDefaultValidation;
+    private customValidity;
+    private lastSelectedIndex;
+    /**
+     * @param adapter
+     * @param foundationMap Map from subcomponent names to their subfoundations.
+     */
+    constructor(adapter?: Partial<MDCSelectAdapterAurelia>, foundationMap?: Partial<MDCSelectFoundationMap>);
+    /** Returns the index of the currently selected menu item, or -1 if none. */
+    getSelectedIndex(): number;
+    setSelectedIndex(index: number, closeMenu?: boolean, skipNotify?: boolean): void;
+    setValue(value: unknown, skipNotify?: boolean): void;
+    getValue(): unknown;
+    getDisabled(): boolean;
+    setDisabled(isDisabled: boolean): void;
+    /** Opens the menu. */
+    openMenu(): void;
+    /**
+     * @param content Sets the content of the helper text.
+     */
+    setHelperTextContent(content: string): void;
+    /**
+     * Re-calculates if the notched outline should be notched and if the label
+     * should float.
+     */
+    layout(): void;
+    /**
+     * Synchronizes the list of options with the state of the foundation. Call
+     * this whenever menu options are dynamically updated.
+     */
+    layoutOptions(): void;
+    handleMenuOpened(): void;
+    handleMenuClosed(): void;
+    /**
+     * Handles value changes, via change event or programmatic updates.
+     */
+    handleChange(): void;
+    handleMenuItemAction(index: number): void;
+    /**
+     * Handles focus events from select element.
+     */
+    handleFocus(): void;
+    /**
+     * Handles blur events from select element.
+     */
+    handleBlur(): void;
+    handleClick(normalizedX: number): void;
+    /**
+     * Handles keydown events on select element. Depending on the type of
+     * character typed, does typeahead matching or opens menu.
+     */
+    handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Opens/closes the notched outline.
+     */
+    notchOutline(openNotch: boolean): void;
+    /**
+     * Sets the aria label of the leading icon.
+     */
+    setLeadingIconAriaLabel(label: string): void;
+    /**
+     * Sets the text content of the leading icon.
+     */
+    setLeadingIconContent(content: string): void;
+    setUseDefaultValidation(useDefaultValidation: boolean): void;
+    setValid(isValid: boolean): void;
+    isValid(): boolean;
+    setRequired(isRequired: boolean): void;
+    getRequired(): boolean;
+    init(): void;
+    /**
+     * Unfocuses the select component.
+     */
+    private blur;
+    private syncHelperTextValidity;
+}
+export default MDCSelectFoundationAurelia;

package/dist/types/select/mdc-select-helper-text/mdc-select-helper-text.d.ts

@@ -0,0 +1,25 @@
+import { MdcComponent } from '../../base';
+import { MDCSelectHelperTextFoundation } from '@material/select';
+export declare const mdcHelperTextCssClasses: {
+    ROOT: string;
+};
+export declare class MdcSelectHelperText extends MdcComponent<MDCSelectHelperTextFoundation> {
+    helperTextCssClasses: {
+        HELPER_TEXT_VALIDATION_MSG: string;
+        HELPER_TEXT_VALIDATION_MSG_PERSISTENT: string;
+    };
+    ROOT: string;
+    persistent: boolean;
+    validation: boolean;
+    errors: string[];
+    get foundationForTextField(): MDCSelectHelperTextFoundation;
+    getDefaultFoundation(): MDCSelectHelperTextFoundation;
+}
+/** @hidden */
+export interface IMdcSelectHelperTextElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcSelectHelperText;
+        };
+    };
+}

package/dist/types/select/mdc-select-icon.d.ts

@@ -0,0 +1,17 @@
+import { MdcComponent } from '../base';
+import { MDCSelectIconFoundation } from '@material/select';
+export declare const mdcIconStrings: {
+    ATTRIBUTE: string;
+};
+export declare class MdcSelectIcon extends MdcComponent<MDCSelectIconFoundation> {
+    attaching(): void;
+    getDefaultFoundation(): MDCSelectIconFoundation;
+}
+/** @hidden */
+export interface IMdcSelectIconElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-attribute:mdc-select-icon': {
+            viewModel: MdcSelectIcon;
+        };
+    };
+}

package/dist/types/select/mdc-select-value-observer.d.ts

@@ -0,0 +1,59 @@
+import { AccessorType } from '@aurelia/runtime';
+import type { ICollectionObserver, IndexMap, IObserver, IObserverLocator, ISubscriber, ISubscriberCollection } from '@aurelia/runtime';
+import { INode } from '@aurelia/runtime-html';
+import { IMdcSelectElement } from './mdc-select';
+export interface IOptionElement extends HTMLOptionElement {
+    model?: unknown;
+}
+export interface MdcSelectValueObserver extends ISubscriberCollection {
+}
+export interface INodeObserverConfigBase {
+    /**
+     * Indicates the list of events can be used to observe a particular property
+     */
+    readonly events: string[];
+    /**
+     * Indicates whether this property is readonly, so observer wont attempt to assign value
+     * example: input.files
+     */
+    readonly readonly?: boolean;
+    /**
+     * A default value to assign to the corresponding property if the incoming value is null/undefined
+     */
+    readonly default?: unknown;
+}
+export interface INodeObserver extends IObserver {
+    /**
+     * Instruct this node observer event observation behavior
+     */
+    useConfig(config: INodeObserverConfigBase): void;
+}
+export declare class MdcSelectValueObserver implements INodeObserver {
+    currentValue: unknown;
+    oldValue: unknown;
+    readonly obj: IMdcSelectElement;
+    config: INodeObserverConfigBase;
+    hasChanges: boolean;
+    type: AccessorType;
+    arrayObserver?: ICollectionObserver<'array'>;
+    nodeObserver?: MutationObserver;
+    private observing;
+    private listened;
+    constructor(obj: INode, _key: PropertyKey, config: INodeObserverConfigBase, _: IObserverLocator);
+    optionsWereSet: boolean;
+    setElementValue(skipNotify: boolean): void;
+    getValue(): unknown;
+    setValue(newValue: unknown): void;
+    flushChanges(): void;
+    handleCollectionChange(): void;
+    notify(): void;
+    handleEvent(): void;
+    synchronizeOptions(_indexMap?: IndexMap): void;
+    synchronizeValue(): boolean;
+    private start;
+    private stop;
+    handleNodeChange(records: MutationRecord[]): void;
+    subscribe(subscriber: ISubscriber): void;
+    unsubscribe(subscriber: ISubscriber): void;
+    useConfig(config: INodeObserverConfigBase): void;
+}

package/dist/types/select/mdc-select.d.ts

@@ -0,0 +1,99 @@
+import { MdcComponent, IValidatedElement, IError } from '../base';
+import { IPlatform } from 'aurelia';
+import { MDCMenuItemEvent } from '@material/menu';
+import { MDCSelectFoundationAurelia } from './mdc-select-foundation-aurelia';
+import { MDCMenuDistance } from '@material/menu-surface';
+import { MdcDefaultSelectConfiguration } from './mdc-default-select-configuration';
+import { MdcListItem } from '../list/mdc-list-item/mdc-list-item';
+import { MdcMenu } from '../menu/mdc-menu';
+/**
+ * @selector mdc-select
+ * @emits mdcselect:change | Emitted if user changed the value
+ */
+export declare class MdcSelect extends MdcComponent<MDCSelectFoundationAurelia> {
+    private platform;
+    private defaultConfiguration;
+    constructor(root: HTMLElement, platform: IPlatform, defaultConfiguration: MdcDefaultSelectConfiguration);
+    id: string;
+    menu: MdcMenu;
+    private selectAnchor;
+    private selectedText;
+    private menuElement?;
+    get items(): MdcListItem[] | undefined;
+    private leadingIcon?;
+    private helperText?;
+    private lineRipple?;
+    private mdcLabel;
+    private outline?;
+    errors: Map<IError, boolean>;
+    /** Sets the select label */
+    label: string;
+    labelChanged(): void;
+    /** Styles the select as an outlined select */
+    outlined?: boolean;
+    outlinedChanged(): void;
+    /** Makes the value required */
+    required: boolean;
+    requiredChanged(): void;
+    /** Enables/disables the select */
+    disabled?: boolean;
+    disabledChanged(): void;
+    /** Hoists the select DOM to document.body */
+    hoistToBody: boolean;
+    /** Sets the select DOM position to fixed */
+    fixed: boolean;
+    /** Sets the margin between the select input and the dropdown */
+    anchorMargin: Partial<MDCMenuDistance>;
+    /** Sets the select dropdown width to match content */
+    naturalWidth: boolean;
+    private _value;
+    get value(): unknown;
+    set value(value: unknown);
+    setValue(value: unknown, skipNotify?: boolean): void;
+    get valid(): boolean;
+    set valid(value: boolean);
+    get selectedIndex(): number;
+    set selectedIndex(selectedIndex: number);
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    renderErrors(): void;
+    attaching(): Promise<void>;
+    beforeFoundationCreated(): void;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MDCSelectFoundationAurelia;
+    private getSelectAdapterMethods;
+    private getCommonAdapterMethods;
+    private getOutlineAdapterMethods;
+    private getLabelAdapterMethods;
+    handleChange(): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    handleClick(evt: MouseEvent): void;
+    handleKeydown(evt: KeyboardEvent): boolean;
+    handleMenuItemAction(evt: MDCMenuItemEvent): void;
+    handleMenuOpened(): void;
+    handleMenuClosed(): void;
+    handleItemsChanged(): void;
+    focus(): void;
+    blur(): void;
+    /**
+     * @hidden
+     * Calculates where the line ripple should start based on the x coordinate within the component.
+     */
+    private getNormalizedXCoordinate;
+    private isTouchEvent;
+    /**
+     * @hidden
+     * Returns a map of all subcomponents to subfoundations.
+     */
+    private getFoundationMap;
+}
+/** @hidden */
+export interface IMdcSelectElement extends IValidatedElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcSelect;
+        };
+    };
+    value: unknown;
+}

package/dist/types/slider/mdc-slider-foundation-aurelia.d.ts

@@ -0,0 +1,5 @@
+import { MDCSliderFoundation } from '@material/slider';
+export declare class MdcSliderFoundationAurelia extends MDCSliderFoundation {
+    get rect(): ClientRect;
+    set rect(_: ClientRect);
+}

package/dist/types/slider/mdc-slider.d.ts

@@ -0,0 +1,66 @@
+import { MdcComponent } from '../base';
+import { Thumb, TickMark } from '@material/slider';
+import { MdcSliderFoundationAurelia } from './mdc-slider-foundation-aurelia';
+import { EventType, SpecificEventListener } from '@material/base';
+interface IEventHandler {
+    element: HTMLElement | Window;
+    evtType: EventType;
+    handler: SpecificEventListener<EventType>;
+}
+export declare class MdcSlider extends MdcComponent<MdcSliderFoundationAurelia> {
+    constructor(root: HTMLElement);
+    private startInput?;
+    private endInput;
+    private startThumb?;
+    private endThumb;
+    private startRipple?;
+    private endRipple;
+    private trackActive;
+    tickMarkStatuses: TickMark[];
+    TickMark: typeof TickMark;
+    eventHandlers: IEventHandler[];
+    discrete: boolean;
+    tickMarks: boolean;
+    range: boolean;
+    disabled: boolean;
+    disabledChanged(): void;
+    /** Set if focus styles should be hidden for pointer events */
+    hideFocus: boolean;
+    min: number;
+    minChanged(): Promise<void>;
+    max: number;
+    maxChanged(): Promise<void>;
+    minRange: number;
+    minRangeChanged(): Promise<void>;
+    step: number;
+    stepChanged(): void;
+    valueToAriaValueTextFn: ((value: number) => string) | null;
+    _value: number;
+    get value(): number;
+    set value(value: number);
+    _valueStart: number;
+    get valueStart(): number;
+    set valueStart(value: number);
+    beforeFoundationCreated(): void;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MdcSliderFoundationAurelia;
+    addEventHandler(element: HTMLElement | Window, evtType: EventType, handler: SpecificEventListener<EventType>): void;
+    removeEventHandler(element: HTMLElement | Window, evtType: EventType, handler: SpecificEventListener<EventType>): void;
+    cleanupEventHandlers(): void;
+    getThumbEl(thumb: Thumb): HTMLElement | undefined;
+    private getInput;
+    private getRipple;
+    focus(): void;
+    blur(): void;
+}
+/** @hidden */
+export interface IMdcSliderElement extends HTMLElement {
+    value: number;
+    valuestart: number;
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcSlider;
+        };
+    };
+}
+export {};

package/dist/types/snackbar/mdc-snackbar-service.d.ts

@@ -0,0 +1,16 @@
+import Aurelia from 'aurelia';
+export interface ISnackbarOptions {
+    timeout: number;
+    closeOnEscape: boolean;
+    dismissible: boolean;
+    stacked: boolean;
+    leading: boolean;
+    classes: string;
+    actionClasses: string;
+    dismissClasses: string;
+}
+export declare class MdcSnackbarService {
+    private readonly au;
+    constructor(au?: Aurelia);
+    open(label: string, actions?: string | string[], options?: Partial<ISnackbarOptions>): Promise<string>;
+}

package/dist/types/snackbar/mdc-snackbar.d.ts

@@ -0,0 +1,37 @@
+import { MdcComponent } from '../base';
+import { MDCSnackbarFoundation } from '@material/snackbar';
+export declare class MdcSnackbar extends MdcComponent<MDCSnackbarFoundation> {
+    private labelEl_;
+    label: string;
+    actions: string[];
+    dismissible: boolean;
+    stacked: boolean;
+    timeout?: number;
+    timeoutChanged(): void;
+    closeOnEscape: boolean;
+    closeOnEscapeChanged(): void;
+    classes: string;
+    actionClasses: string;
+    dismissClasses: string;
+    leading: boolean;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MDCSnackbarFoundation;
+    open(): void;
+    /**
+     * @param reason Why the snackbar was closed. Value will be passed to CLOSING_EVENT and CLOSED_EVENT via the
+     *     `event.detail.reason` property. Standard values are REASON_ACTION and REASON_DISMISS, but custom
+     *     client-specific values may also be used if desired.
+     */
+    close(reason?: string): void;
+    handleAction(action: string): void;
+    handleDismiss(): void;
+    handleKeyDown(evt: KeyboardEvent): boolean;
+}
+/** @hidden */
+export interface IMdcSnackbarElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcSnackbar;
+        };
+    };
+}

package/dist/types/switch/enhance-mdc-switch.d.ts

@@ -0,0 +1,3 @@
+export declare class EnhanceMdcSwitch {
+    compiling(template: HTMLElement | HTMLTemplateElement): void;
+}