@aurelia-mdc-web/all 9.2.3-au2 → 9.3.1-au2

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

@@ -0,0 +1,23 @@
+import { MdcComponent } from '../base';
+import { MDCSwitchState, MDCSwitchRenderAdapter, MDCSwitchRenderFoundation } from '@material/switch';
+import { MDCRippleCapableSurface } from '@material/ripple';
+export declare class MdcSwitch extends MdcComponent<MDCSwitchRenderFoundation> implements MDCSwitchState, MDCRippleCapableSurface {
+    root: IMdcSwitchElement;
+    constructor(root: IMdcSwitchElement);
+    disabled: boolean;
+    selected: boolean;
+    processing: boolean;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MDCSwitchRenderFoundation;
+    protected createAdapter(): MDCSwitchRenderAdapter;
+    handleClick(): void;
+}
+/** @hidden */
+export interface IMdcSwitchElement extends HTMLButtonElement {
+    selected: boolean;
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcSwitch;
+        };
+    };
+}

package/dist/types/tab-bar/indicator/mdc-tab-indicator.d.ts

@@ -0,0 +1,12 @@
+import { MdcComponent } from '../../base';
+import { MDCTabIndicatorFoundation, MDCFadingTabIndicatorFoundation, MDCSlidingTabIndicatorFoundation } from '@material/tab-indicator';
+export declare class MdcTabIndicator extends MdcComponent<MDCTabIndicatorFoundation> {
+    private content;
+    fade: boolean;
+    active: boolean;
+    icon: string;
+    computeContentClientRect(): ClientRect;
+    getDefaultFoundation(): MDCFadingTabIndicatorFoundation | MDCSlidingTabIndicatorFoundation;
+    activate(previousIndicatorClientRect?: ClientRect): void;
+    deactivate(): void;
+}

package/dist/types/tab-bar/mdc-tab-bar.d.ts

@@ -0,0 +1,30 @@
+import { MdcComponent } from '../base';
+import { MDCTabBarFoundation } from '@material/tab-bar';
+import { MdcTabScroller } from './scroller/mdc-tab-scroller';
+import { MDCTabInteractionEvent } from '@material/tab';
+export declare class MdcTabBar extends MdcComponent<MDCTabBarFoundation> {
+    private tabScroller_?;
+    focusOnActivate: boolean;
+    focusOnActivateChanged(): void;
+    useAutomaticActivation: boolean;
+    useAutomaticActivationChanged(): void;
+    align: MdcTabScroller['align'];
+    initialSyncWithDOM(): void;
+    handleKeyDown_(evt: KeyboardEvent): boolean;
+    handleTabInteraction_(evt: MDCTabInteractionEvent): void;
+    getDefaultFoundation(): MDCTabBarFoundation;
+    /**
+     * Activates the tab at the given index
+     * @param index The index of the tab
+     */
+    activateTab(index: number): void;
+    /**
+     * Scrolls the tab at the given index into view
+     * @param index THe index of the tab
+     */
+    scrollIntoView(index: number): void;
+    /**
+     * Returns all the tab elements in a nice clean array
+     */
+    private getTabElements_;
+}

package/dist/types/tab-bar/scroller/mdc-tab-scroller.d.ts

@@ -0,0 +1,31 @@
+import { MdcComponent } from '../../base';
+import { MDCTabScrollerFoundation } from '@material/tab-scroller';
+import { MdcTab } from '../tab/mdc-tab';
+export declare class MdcTabScroller extends MdcComponent<MDCTabScrollerFoundation> {
+    private content_;
+    private area_;
+    align: 'start' | 'end' | 'center';
+    tabElements: HTMLElement[];
+    get tabs(): MdcTab[];
+    getDefaultFoundation(): MDCTabScrollerFoundation;
+    handleInteraction_(): boolean;
+    handleTransitionEnd_(evt: Event): boolean;
+    /**
+     * Returns the current visual scroll position
+     */
+    getScrollPosition(): number;
+    /**
+     * Returns the width of the scroll content
+     */
+    getScrollContentWidth(): number;
+    /**
+     * Increments the scroll value by the given amount
+     * @param scrollXIncrement The pixel value by which to increment the scroll value
+     */
+    incrementScroll(scrollXIncrement: number): void;
+    /**
+     * Scrolls to the given pixel position
+     * @param scrollX The pixel value to scroll to
+     */
+    scrollTo(scrollX: number): void;
+}

package/dist/types/tab-bar/tab/mdc-tab.d.ts

@@ -0,0 +1,44 @@
+import { MdcComponent } from '../../base';
+import { MDCTabFoundation, MDCTabDimensions } from '@material/tab';
+export declare class MdcTab extends MdcComponent<MDCTabFoundation> {
+    private tabIndicator_;
+    private content_;
+    id: string;
+    fixed: boolean;
+    active: boolean;
+    icon: string;
+    label: string;
+    minWidth: boolean;
+    fade: boolean;
+    stacked: boolean;
+    indicatorIcon: string;
+    handleClick_(): boolean;
+    getDefaultFoundation(): MDCTabFoundation;
+    isActive(): boolean;
+    set focusOnActivate(focusOnActivate: boolean);
+    /**
+     * Activates the tab
+     */
+    activate(computeIndicatorClientRect?: ClientRect): void;
+    /**
+     * Deactivates the tab
+     */
+    deactivate(): void;
+    /**
+     * Returns the indicator's client rect
+     */
+    computeIndicatorClientRect(): ClientRect;
+    computeDimensions(): MDCTabDimensions;
+    /**
+     * Focuses the tab
+     */
+    focus(): void;
+}
+/** @hidden */
+export interface IMdcTabElement extends HTMLElement {
+    au: {
+        controller: {
+            viewModel: MdcTab;
+        };
+    };
+}

package/dist/types/text-field/enhance-mdc-text-field.d.ts

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

package/dist/types/text-field/mdc-default-text-field-configuration.d.ts

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

package/dist/types/text-field/mdc-text-field-character-counter.d.ts

@@ -0,0 +1,14 @@
+import { MDCTextFieldCharacterCounterFoundation } from '@material/textfield';
+import { MdcComponent } from '../base';
+export declare class MdcTextFieldCharacterCounter extends MdcComponent<MDCTextFieldCharacterCounterFoundation> {
+    get foundationForTextField(): MDCTextFieldCharacterCounterFoundation;
+    getDefaultFoundation(): MDCTextFieldCharacterCounterFoundation;
+}
+/** @hidden */
+export interface IMdcTextFieldCharacterCounterElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcTextFieldCharacterCounter;
+        };
+    };
+}

package/dist/types/text-field/mdc-text-field-helper-line/mdc-text-field-helper-line.d.ts

@@ -0,0 +1,17 @@
+export declare class MdcTextFieldHelperLine {
+    constructor();
+    errors: string[];
+    attachedPromise: Promise<unknown>;
+    protected attachedPromiseResolve: (value?: unknown) => void;
+    private createAttachedPromise;
+    attached(): void;
+    detached(): void;
+}
+/** @hidden */
+export interface IMdcTextFieldHelperLineElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcTextFieldHelperLine;
+        };
+    };
+}

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

@@ -0,0 +1,21 @@
+import { MdcComponent } from '../../base';
+import { MDCTextFieldHelperTextFoundation } from '@material/textfield';
+export declare class MdcTextFieldHelperText extends MdcComponent<MDCTextFieldHelperTextFoundation> {
+    helperTextCssClasses: {
+        HELPER_TEXT_PERSISTENT: string;
+        HELPER_TEXT_VALIDATION_MSG: string;
+        ROOT: string;
+    };
+    persistent: boolean;
+    validation: boolean;
+    get foundationForTextField(): MDCTextFieldHelperTextFoundation;
+    getDefaultFoundation(): MDCTextFieldHelperTextFoundation;
+}
+/** @hidden */
+export interface IMdcTextFieldHelperTextElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcTextFieldHelperText;
+        };
+    };
+}

package/dist/types/text-field/mdc-text-field-icon.d.ts

@@ -0,0 +1,20 @@
+import { MdcComponent } from '../base';
+import { MDCTextFieldIconFoundation } from '@material/textfield';
+export declare const mdcIconStrings: {
+    ATTRIBUTE: string;
+    LEADING: string;
+    TRAILING: string;
+};
+export declare class MdcTextFieldIcon extends MdcComponent<MDCTextFieldIconFoundation> {
+    attaching(): void;
+    get foundationForTextField(): MDCTextFieldIconFoundation;
+    getDefaultFoundation(): MDCTextFieldIconFoundation;
+}
+/** @hidden */
+export interface IMdcTextFieldIconElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-attribute:mdc-text-field-icon': {
+            viewModel: MdcTextFieldIcon;
+        };
+    };
+}

package/dist/types/text-field/mdc-text-field.d.ts

@@ -0,0 +1,105 @@
+import { MDCTextFieldFoundation } from '@material/textfield';
+import { MdcComponent, IValidatedElement, IError } from '../base';
+import { MdcTextFieldIcon } from './mdc-text-field-icon';
+import { MdcTextFieldHelperText } from './mdc-text-field-helper-text/mdc-text-field-helper-text';
+import { MdcTextFieldCharacterCounter } from './mdc-text-field-character-counter';
+import { IPlatform } from '@aurelia/runtime-html';
+import { MdcDefaultTextFieldConfiguration } from './mdc-default-text-field-configuration';
+import { MdcFloatingLabel } from '../floating-label/mdc-floating-label';
+import { MdcLineRipple } from '../line-ripple/mdc-line-ripple';
+import { MdcNotchedOutline } from '../notched-outline/mdc-notched-outline';
+export declare class MdcTextField extends MdcComponent<MDCTextFieldFoundation> {
+    private platform;
+    private defaultConfiguration;
+    constructor(root: HTMLElement, platform: IPlatform, defaultConfiguration: MdcDefaultTextFieldConfiguration);
+    id: string;
+    id1: string;
+    input_: HTMLInputElement;
+    label_?: MdcFloatingLabel;
+    lineRipple_: MdcLineRipple;
+    outline_: MdcNotchedOutline | null;
+    helperText_: MdcTextFieldHelperText | undefined;
+    characterCounter_?: MdcTextFieldCharacterCounter;
+    errors: Map<IError, boolean>;
+    leadingIcon_: MdcTextFieldIcon | undefined;
+    trailingIcon_: MdcTextFieldIcon | undefined;
+    mutationObserver: MutationObserver;
+    label: string;
+    labelChanged(): void;
+    textarea: boolean;
+    endAligned: boolean;
+    ltrText: boolean;
+    outlined?: boolean;
+    prefix: string;
+    suffix: string;
+    required?: boolean;
+    requiredChanged(): void;
+    disabled: boolean;
+    disabledChanged(): void;
+    readonly: boolean;
+    readonlyChanged(): void;
+    /** Makes the element blur on Enter key press */
+    blurOnEnter: boolean;
+    maxlength: string;
+    maxlengthChanged(): void;
+    rows: string;
+    rowsChanged(): void;
+    cols: string;
+    colsChanged(): void;
+    max: string;
+    maxChanged(): void;
+    min: string;
+    minChanged(): void;
+    step: string;
+    stepChanged(): void;
+    autocomplete: AutoFill;
+    autocompleteChanged(): void;
+    tabindex: number;
+    tabindexChanged(): void;
+    type: string;
+    typeChanged(): void;
+    name: string;
+    nameChanged(): void;
+    placeholder: string;
+    private initialValue;
+    get value(): string;
+    set value(value: string);
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    get valid(): boolean;
+    set valid(value: boolean);
+    renderErrors(): void;
+    attaching(): Promise<void>;
+    beforeFoundationCreated(): void;
+    mutated(mutations: MutationRecord[]): void;
+    trailingIconChanged(): void;
+    leadingIconChanged(): void;
+    destroy(): void;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MDCTextFieldFoundation;
+    private getRootAdapterMethods_;
+    private getInputAdapterMethods_;
+    private getLabelAdapterMethods_;
+    private getLineRippleAdapterMethods_;
+    private getOutlineAdapterMethods_;
+    /**
+     * @return A map of all subcomponents to subfoundations.
+     */
+    private getFoundationMap_;
+    onInput(evt: Event): void;
+    onFocus(): void;
+    onChange(evt: Event): void;
+    onBlur(): void;
+    focus(): void;
+    blur(): void;
+    onKeyup(e: KeyboardEvent): boolean;
+}
+/** @hidden */
+export interface IMdcTextFieldElement extends IValidatedElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcTextField;
+        };
+    };
+    value: string;
+}

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

@@ -0,0 +1,5 @@
+export declare class MdcDefaultTooltipConfiguration {
+    showDelay?: number;
+    hideDelay?: number;
+    scrollHost?: HTMLElement | string;
+}

package/dist/types/tooltip/mdc-tooltip-attribute.d.ts

@@ -0,0 +1,51 @@
+import { IAurelia, IAppRoot } from 'aurelia';
+import { XPosition, YPosition, AnchorBoundaryType } from '@material/tooltip';
+import { MdcDefaultTooltipConfiguration } from './mdc-default-tooltip-configuration';
+/**
+ * @selector [mdc-tooltip]
+ */
+export declare class MdcTooltipAttribute {
+    private defaultConfiguration;
+    private readonly au;
+    constructor(root: HTMLElement, defaultConfiguration: MdcDefaultTooltipConfiguration, au: IAurelia);
+    root: HTMLElement;
+    value: string;
+    valueChanged(): void;
+    rich: boolean;
+    richChanged(): void;
+    persistent: boolean;
+    persistenthanged(): void;
+    /** Sets the horizontal alignment of the tooltip */
+    xPosition: keyof typeof XPosition;
+    xPositionChanged(): void;
+    /** Sets the vertical alignment of the tooltip */
+    yPosition: keyof typeof YPosition;
+    yPositionChanged(): void;
+    /** Specifies whether the anchor element is bounded (element has an identifiable boundary such as a button) or unbounded (element does not have a visually declared boundary such as a text link).
+     * Tooltips are placed closer to bounded anchor elements compared to unbounded anchor elements. If no type is specified, defaults to BOUNDED.
+     **/
+    boundaryType: keyof typeof AnchorBoundaryType;
+    boundaryTypeChanged(): void;
+    showDelay: number;
+    showDelayChanged(): void;
+    hideDelay: number;
+    hideDelayChanged(): void;
+    scrollHost?: HTMLElement | string;
+    scrollHostChanged(): void;
+    tooltip: HTMLElement;
+    controller: IAppRoot<any>;
+    context: Partial<{
+        root: HTMLElement;
+        value: string;
+        rich: boolean;
+        persistent: boolean;
+        xPosition: keyof typeof XPosition;
+        yPosition: keyof typeof YPosition;
+        boundaryType: keyof typeof AnchorBoundaryType;
+        showDelay: number;
+        hideDelay: number;
+        scrollHost?: HTMLElement | string;
+    }>;
+    attached(): Promise<void>;
+    detached(): void;
+}

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

@@ -0,0 +1,47 @@
+import { MdcComponent } from '../base';
+import { MDCTooltipFoundation, XPosition, YPosition, AnchorBoundaryType, PositionWithCaret } from '@material/tooltip';
+import { MdcDefaultTooltipConfiguration } from './mdc-default-tooltip-configuration';
+/**
+ * @selector mdc-tooltip
+ */
+export declare class MdcTooltip extends MdcComponent<MDCTooltipFoundation> implements EventListenerObject {
+    private defaultConfiguration;
+    constructor(root: HTMLElement, defaultConfiguration: MdcDefaultTooltipConfiguration);
+    /** Sets the anchor element */
+    anchorElem?: HTMLElement;
+    rich: boolean;
+    persistent: boolean;
+    /** Sets the horizontal alignment of the tooltip */
+    xPosition?: keyof typeof XPosition;
+    xPositionChanged(): void;
+    /** Sets the vertical alignment of the tooltip */
+    yPosition?: keyof typeof YPosition;
+    yPositionChanged(): void;
+    /** Sets the caret position relative to the tooltip */
+    withCaretPos?: keyof typeof PositionWithCaret;
+    withCaretPosChanged(): Promise<void>;
+    /** Specifies whether the anchor element is bounded (element has an identifiable boundary such as a button) or unbounded (element does not have a visually declared boundary such as a text link).
+     * Tooltips are placed closer to bounded anchor elements compared to unbounded anchor elements. If no type is specified, defaults to BOUNDED.
+     **/
+    boundaryType?: keyof typeof AnchorBoundaryType;
+    boundaryTypeChanged(): void;
+    /** Sets show delay */
+    showDelay?: number;
+    showDelayChanged(): Promise<void>;
+    /** Sets hide delay */
+    hideDelay?: number;
+    hideDelayChanged(): Promise<void>;
+    scrollHost?: HTMLElement | string;
+    beforeFoundationCreated(): void;
+    initialSyncWithDOM(): void;
+    destroy(): void;
+    handleEvent(evt: Event): void;
+    handleMouseEnter(): void;
+    handleFocus(evt: FocusEvent): void;
+    handleMouseLeave(): void;
+    handleTouchstart(): void;
+    handleTouchend(): void;
+    handleClick(): void;
+    handleTransitionEnd(): void;
+    getDefaultFoundation(): MDCTooltipFoundation;
+}

package/dist/types/top-app-bar/enhance-top-app-bar-actions.d.ts

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

package/dist/types/top-app-bar/mdc-top-app-bar-action-item.d.ts

@@ -0,0 +1,5 @@
+export declare class MdcTopAppBarActionItem {
+    private root;
+    constructor(root: HTMLElement);
+    attached(): void;
+}

package/dist/types/top-app-bar/mdc-top-app-bar-fixed-adjust.d.ts

@@ -0,0 +1,6 @@
+export declare class MdcTopAppBarFixedAdjust {
+    private root;
+    constructor(root: HTMLElement);
+    value: 'prominent' | 'dense' | 'dense-prominent' | 'short';
+    attached(): void;
+}

package/dist/types/top-app-bar/mdc-top-app-bar-nav-icon.d.ts

@@ -0,0 +1,5 @@
+export declare class MdcTopAppBarNavIcon {
+    private root;
+    constructor(root: HTMLElement);
+    attached(): void;
+}

package/dist/types/top-app-bar/mdc-top-app-bar-row.d.ts

@@ -0,0 +1,2 @@
+export declare class MdcTopAppBarRow {
+}

package/dist/types/top-app-bar/mdc-top-app-bar-section/mdc-top-app-bar-section.d.ts

@@ -0,0 +1,3 @@
+export declare class MdcTopAppBarSection {
+    end: boolean;
+}

package/dist/types/top-app-bar/mdc-top-app-bar-title.d.ts

@@ -0,0 +1,2 @@
+export declare class MdcTopAppBarTitle {
+}

package/dist/types/top-app-bar/mdc-top-app-bar.d.ts

@@ -0,0 +1,18 @@
+import { MdcComponent } from '../base';
+import { MDCTopAppBarBaseFoundation } from '@material/top-app-bar';
+export declare class MdcTopAppBar extends MdcComponent<MDCTopAppBarBaseFoundation> {
+    private handleNavigationClick_;
+    private handleWindowResize_;
+    private handleTargetScroll_;
+    private navIcon_;
+    hasActionItems: boolean;
+    short: boolean;
+    collapsed: boolean;
+    fixed: boolean;
+    prominent: boolean;
+    dense: boolean;
+    scrollTarget: EventTarget;
+    scrollTargetChanged(newValue: EventTarget, oldValue: EventTarget): void;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MDCTopAppBarBaseFoundation;
+}

package/dist/types/tree-view/i-tree-node.d.ts

@@ -0,0 +1,7 @@
+import { MdcTreeView } from './mdc-tree-view';
+export interface ITreeNode {
+    children?: ITreeNode[];
+    expanded?: boolean;
+    selected?: boolean;
+    childTreeViewPromise?: Promise<MdcTreeView>;
+}

package/dist/types/tree-view/mdc-tree-node-meta.d.ts

@@ -0,0 +1,5 @@
+export declare class MdcTreeViewNodeMeta {
+    private root;
+    constructor(root: HTMLElement);
+    attached(): void;
+}

package/dist/types/tree-view/mdc-tree-node.d.ts

@@ -0,0 +1,2 @@
+export declare class MdcTreeNode {
+}

package/dist/types/tree-view/mdc-tree-view.d.ts

@@ -0,0 +1,35 @@
+import { MdcComponent } from '../base';
+import { MDCFoundation } from '@material/base';
+import { ViewFactory } from 'aurelia';
+import { ITreeNode } from './i-tree-node';
+export declare class MDCTreeViewFoundation extends MDCFoundation {
+}
+export declare class MdcTreeView extends MdcComponent<MDCTreeViewFoundation> {
+    getDefaultFoundation(): MDCTreeViewFoundation;
+    constructor(root: HTMLElement);
+    nodeViewFactory: ViewFactory;
+    selectedNode?: ITreeNode;
+    nodeTemplate: string;
+    nodes: ITreeNode[];
+    /**
+     * Allows for filtering tree nodes
+     */
+    filter: (n: ITreeNode) => boolean;
+    rootBindingContext: Record<string, unknown>;
+    bind(bindingContext: Record<string, unknown>): void;
+    toggleExpanded(n: ITreeNode, e: Event): boolean;
+    nodeClicked(n?: ITreeNode): boolean;
+    childNodeSelected(n: ITreeNode): void;
+    findPath<T extends ITreeNode>(nodes: T[], predicate: (node: T) => boolean): number[];
+    expandPath(path: number[]): Promise<void>;
+    find<T extends ITreeNode>(predicate: (node: T) => boolean): Promise<void>;
+    dispatchEvent(type: string, node: ITreeNode): void;
+}
+/** @hidden */
+export interface IMdcTreeElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcTreeView;
+        };
+    };
+}

package/dist/types/tree-view/node-filter.d.ts

@@ -0,0 +1,4 @@
+import { ITreeNode } from './i-tree-node';
+export declare class NodeFilterValueConverter {
+    toView(nodes: ITreeNode[], filter: (n: ITreeNode) => boolean): ITreeNode[];
+}

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

@@ -0,0 +1,46 @@
+declare class MdcTypography {
+    private root;
+    constructor(root: HTMLElement);
+    type: 'headline1' | 'headline2' | 'headline3' | 'headline4' | 'headline5' | 'headline6' | 'subtitle1' | 'subtitle2' | 'body1' | 'body2' | 'caption' | 'button' | 'overline';
+    attached(): void;
+}
+export declare class MdcHeadline1 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcHeadline2 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcHeadline3 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcHeadline4 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcHeadline5 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcHeadline6 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcSubtitle1 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcSubtitle2 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcBody1 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcBody2 extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcCaption extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcTypographyButton extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export declare class MdcOveline extends MdcTypography {
+    constructor(root: HTMLElement);
+}
+export {};

package/dist/types/validation/mdc-validation-controller-factory.d.ts

@@ -0,0 +1,7 @@
+import { IContainer, IFactory, Constructable, Transformer, Key } from '@aurelia/kernel';
+import { IValidationController } from '@aurelia/validation-html';
+export declare class MdcValidationControllerFactory implements IFactory<Constructable<IValidationController>> {
+    Type: Constructable<IValidationController>;
+    registerTransformer(_transformer: Transformer<Constructable<IValidationController>>): boolean;
+    construct(_: IContainer, _dynamicDependencies?: Key[] | undefined): IValidationController;
+}

package/dist/types/validation/mdc-validation-result-presenter.d.ts

@@ -0,0 +1,4 @@
+import { ValidationEvent, ValidationResultsSubscriber } from '@aurelia/validation-html';
+export declare class MdcValidationResultPresenter implements ValidationResultsSubscriber {
+    handleValidationEvent(event: ValidationEvent): void;
+}