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

package/dist/types/list/mdc-list-item/mdc-list-item.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @selector mdc-list-item
+ */
+export declare class MdcListItem {
+    root: HTMLElement;
+    constructor(root: HTMLElement);
+    cssClasses: {
+        LIST_ITEM_ACTIVATED_CLASS: string;
+        LIST_ITEM_CLASS: string;
+        LIST_ITEM_DISABLED_CLASS: string;
+        LIST_ITEM_SELECTED_CLASS: string;
+        LIST_ITEM_TEXT_CLASS: string;
+        LIST_ITEM_PRIMARY_TEXT_CLASS: string;
+        ROOT: string;
+    };
+    id: string;
+    /** Disables the list item */
+    disabled: boolean;
+    /** Styles the row in an activated state */
+    activated: boolean;
+    /** Styles the row in an selected state */
+    selected: boolean;
+    /** Indicates a non-interactive item */
+    nonInteractive: boolean;
+    /** Indicates a two-line item */
+    twoLine: boolean;
+    /** Indicates a three-line item */
+    threeLine: boolean;
+    /** Random data associated with the list item. Passed in events payload. */
+    value: unknown;
+    /** Disables ripple effect */
+    disableRipple: boolean;
+    attached(): void;
+    onKeydown(evt: KeyboardEvent): boolean;
+    onClick(): boolean;
+}
+/** @hidden */
+export interface IMdcListItemElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcListItem;
+        };
+    };
+}
+export interface IMdcListActionEventDetail {
+    index: number;
+    data: unknown;
+}
+/** @hidden */
+export interface IMdcListActionEvent extends Event {
+    detail: IMdcListActionEventDetail;
+}

package/dist/types/list/mdc-list-item-overline-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Optional, overline text for the list item
+ * @selector mdc-list-item-overline-text
+ */
+export declare class MdcListItemOverlineText {
+}

package/dist/types/list/mdc-list-item-primary-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Optional, primary text for the list item
+ * @selector mdc-list-item-primary-text
+ */
+export declare class MdcListItemPrimaryText {
+}

package/dist/types/list/mdc-list-item-secondary-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Optional, secondary text for the list item. Displayed below the primary text.
+ * @selector mdc-list-item-secondary-text
+ */
+export declare class MdcListItemSecondaryText {
+}

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

@@ -0,0 +1,107 @@
+import { MdcComponent } from '../base';
+import { MDCListFoundation, MDCListIndex } from '@material/list';
+import { MdcListItem } from './mdc-list-item/mdc-list-item';
+export declare const mdcListStrings: {
+    ITEMS_CHANGED: string;
+};
+/**
+ * @selector mdc-list
+ * @emits mdclist:action | Indicates that a list item with the specified index has been activated
+ * @emits mdclist:itemschanged | Indicates that the list of items has changed
+ */
+export declare class MdcList extends MdcComponent<MDCListFoundation> {
+    cssClasses: {
+        LIST_ITEM_ACTIVATED_CLASS: string;
+        LIST_ITEM_CLASS: string;
+        LIST_ITEM_DISABLED_CLASS: string;
+        LIST_ITEM_SELECTED_CLASS: string;
+        LIST_ITEM_TEXT_CLASS: string;
+        LIST_ITEM_PRIMARY_TEXT_CLASS: string;
+        ROOT: string;
+    };
+    /** When enabled, the space and enter keys (or click event) will trigger an single list item to become selected and any other previous selected element to become deselected */
+    singleSelection: boolean;
+    singleSelectionChanged(): void;
+    /** Sets the selection logic to apply/remove the mdc-list-item--activated class */
+    activated: boolean;
+    activatedChanged(): void;
+    itemElements: HTMLElement[];
+    itemsChanged(): void;
+    get items(): MdcListItem[];
+    typeahead: boolean;
+    typeaheadChanged(hasTypeahead: boolean): void;
+    /** Prevent list items receive styles for hover, focus, and press states (including the ripple) */
+    nonInteractive: boolean;
+    /** Sets the list to allow the up arrow on the first element to focus the last element of the list and vice versa */
+    wrapFocus: boolean;
+    wrapFocusChanged(): void;
+    initialSyncWithDOM(): void;
+    get listElements(): Element[];
+    /**
+     * Extracts the primary text from a list item.
+     * @param item The list item element.
+     * @return The primary text in the element.
+     */
+    getPrimaryText(item: Element): string;
+    getDefaultFoundation(): MDCListFoundation;
+    /**
+     * @hidden
+     * Used to figure out which list item this event is targetting. Or returns -1 if
+     * there is no list item
+     */
+    private getListItemIndex_;
+    /**
+     * @hidden
+     * Used to figure out which element was clicked before sending the event to the foundation.
+     */
+    handleFocusInEvent_(evt: FocusEvent): void;
+    /**
+     * @hidden
+     * Used to figure out which element was clicked before sending the event to the foundation.
+     */
+    handleFocusOutEvent_(evt: FocusEvent): void;
+    /**
+     * @hidden
+     * Used to figure out which element was focused when keydown event occurred before sending the event to the
+     * foundation.
+     */
+    handleKeydownEvent_(evt: KeyboardEvent): boolean;
+    /**
+     * @hidden
+     * Used to figure out which element was clicked before sending the event to the foundation.
+     */
+    handleClickEvent_(evt: MouseEvent): boolean;
+    /**
+     * @hidden
+     * @return Whether typeahead is currently matching a user-specified prefix.
+     */
+    get typeaheadInProgress(): boolean;
+    /**
+     * @hidden
+     * Given the next desired character from the user, adds it to the typeahead
+     * buffer. Then, attempts to find the next option matching the buffer. Wraps
+     * around if at the end of options.
+     *
+     * @param nextChar The next character to add to the prefix buffer.
+     * @param startingIndex The index from which to start matching. Defaults to
+     *     the currently focused index.
+     * @return The index of the matched item.
+     */
+    typeaheadMatchItem(nextChar: string, startingIndex?: number): number;
+    layout(): void;
+    get selectedIndex(): MDCListIndex;
+    set selectedIndex(index: MDCListIndex);
+    /**
+     * @hidden
+     * Initialize selectedIndex value based on pre-selected checkbox list items, single selection or radio.
+     */
+    initializeListType(): void;
+}
+/** @hidden */
+export interface IMdcListElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcList;
+        };
+    };
+}

package/dist/types/lookup/discardable-promise.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A wrapper-promise which rejects when discarded
+ */
+export declare class DiscardablePromise<T> implements PromiseLike<T> {
+    private promise;
+    constructor(promise: Promise<T>);
+    static discarded: symbol;
+    isDiscarded: boolean;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: unknown) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
+    discard(): void;
+}

package/dist/types/lookup/mdc-lookup-configuration.d.ts

@@ -0,0 +1,9 @@
+/** Configuration object */
+export declare class MdcDefaultLookupConfiguration {
+    /** Default debounce time in milliseconds */
+    debounce: number;
+    /** Default message displayed while async options function is being executed */
+    searchingMessage: string;
+    /** Default message displayed when options are not found */
+    notFoundMessage: string;
+}

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

@@ -0,0 +1,107 @@
+import { DiscardablePromise } from './discardable-promise';
+import { MdcDefaultLookupConfiguration } from './mdc-lookup-configuration';
+import { IValidatedElement, IError } from '../base';
+import { MdcMenu, IMdcMenuItemComponentEvent } from '../menu/mdc-menu';
+/**
+ * @selector mdc-lookup
+ */
+export declare class MdcLookup implements EventListenerObject {
+    private root;
+    private defaultConfiguration;
+    constructor(root: HTMLElement, defaultConfiguration: MdcDefaultLookupConfiguration);
+    private menuSurface;
+    isWrapperOpen: boolean;
+    optionsArray?: unknown[];
+    focusedOption: unknown;
+    searching: boolean;
+    errorMessage: string | undefined;
+    notFound: boolean;
+    menu: MdcMenu;
+    /** Reference to the input */
+    input?: HTMLInputElement & {
+        isFocused: boolean;
+    };
+    /** Sets the menu list to have two lines */
+    twoLine: boolean;
+    /**
+     * Sets the way an option is displayed in the input element.
+     * When set to a string, the object property with such name is used.
+     * When set to a function, it is called with an option as a parameter to retrieve the display string.
+     * When undefined, an option.toString() is used.
+     */
+    displayField: string | undefined | ((option: unknown) => string);
+    displayFieldChanged(): void;
+    getDisplay: (option: unknown) => string;
+    /**
+     * Sets the way a value is set.
+     * When set to a string, the object property with such name is used.
+     * When set to a function, it is called with an option as a parameter to retrieve the value.
+     * When undefined, an option is used as a value.
+     */
+    valueField: string | undefined | ((option: unknown) => unknown);
+    valueFieldChanged(): void;
+    getValue: (option: unknown) => unknown;
+    /**
+     * Sets the array of options to display.
+     * Can be an async function which returns an array.
+     */
+    options: unknown[] | undefined | ((filter: string, value: unknown) => Promise<unknown[]>);
+    optionsChanged(): void;
+    setGetOptions(): void;
+    /** Hoists the menu to document body */
+    hoistToBody: boolean;
+    /** Sets the menu width to fit content */
+    naturalWidth: boolean;
+    /** The CSS class to set on the menu. Helps styling body hoisted menus */
+    menuClass: string;
+    getOptions: (filter: string | undefined, value: unknown) => Promise<unknown[]>;
+    getOptionsDefault(filter: string, value: unknown): Promise<unknown[]>;
+    /** The selected value */
+    value: unknown;
+    suppressValueChanged: boolean;
+    valueChanged(): Promise<void>;
+    setValue(value: unknown): void;
+    /** Sets debounce in milliseconds */
+    debounce: number;
+    /** Loads the options to the menu when attached */
+    preloadOptions: boolean;
+    /** Enables a first option select on blur */
+    selectOnBlur: boolean;
+    /** Enables an item selection on Tab press */
+    selectOnTab: boolean;
+    /** TODO: Enables the options list virtualisation */
+    virtual: boolean;
+    bound(): void;
+    attached(): Promise<void>;
+    detaching(): void;
+    /** Opens lookup menu */
+    open(): void;
+    /** Closes lookup menu */
+    close(): void;
+    handleEvent(evt: Event): void;
+    debouncePromise: DiscardablePromise<void>;
+    searchPromise: DiscardablePromise<unknown[]>;
+    filterChanged(): Promise<void>;
+    loadOptions(open: boolean): Promise<void>;
+    setFilter(filter: string | undefined): void;
+    updateFilterBasedOnValue(): Promise<void>;
+    handleMenuItemAction(evt: IMdcMenuItemComponentEvent): void;
+    select(option: unknown): void;
+    suppressBlur: boolean;
+    onBlur(): Promise<void>;
+    onInputKeydown(evt: KeyboardEvent): void;
+    onBodyMousedown(evt: MouseEvent | TouchEvent): boolean;
+    handleBodyClick(evt: MouseEvent): void;
+    handleMenuKeydown(event: KeyboardEvent): boolean;
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    renderErrors(): void;
+}
+/** @hidden */
+export interface IMdcLookupElement extends IValidatedElement {
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcLookup;
+        };
+    };
+}

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

@@ -0,0 +1,10 @@
+import { MdcDefaultLookupConfiguration } from './lookup/mdc-lookup-configuration';
+import { MdcDefaultSelectConfiguration } from './select/mdc-default-select-configuration';
+import { MdcDefaultTextFieldConfiguration } from './text-field/mdc-default-text-field-configuration';
+import { MdcDefaultTooltipConfiguration } from './tooltip/mdc-default-tooltip-configuration';
+export declare class MdcConfiguration {
+    lookup: MdcDefaultLookupConfiguration;
+    select: MdcDefaultSelectConfiguration;
+    textField: MdcDefaultTextFieldConfiguration;
+    tooltip: MdcDefaultTooltipConfiguration;
+}

package/dist/types/menu/mdc-menu-selection-group-icon.d.ts

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

package/dist/types/menu/mdc-menu-selection-group.d.ts

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

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

@@ -0,0 +1,127 @@
+import { MdcComponent } from '../base';
+import { MDCMenuFoundation, DefaultFocusState, Corner, MDCMenuItemComponentEventDetail } from '@material/menu';
+import { MDCListIndex } from '@material/list';
+import { MDCMenuDistance } from '@material/menu-surface';
+import { MdcList } from '../list/mdc-list';
+import { IMdcListActionEvent } from '../list/mdc-list-item/mdc-list-item';
+import { MdcMenuSurface } from '../menu-surface/mdc-menu-surface';
+/**
+ * @selector mdc-menu
+ * @emits mdcmenu:selected | Indicates that a menu item has been selected
+ */
+export declare class MdcMenu extends MdcComponent<MDCMenuFoundation> {
+    menuSurface: MdcMenuSurface;
+    get list_(): MdcList | undefined;
+    /** Used to indicate that the menu is using fixed positioning */
+    fixed: boolean;
+    typeahead?: boolean;
+    typeaheadChanged(): void;
+    /** Makes the menu element direct child of the body */
+    hoistToBody: boolean;
+    /** Set to indicate an element the menu should be anchored to */
+    anchor?: Element | null;
+    /** Sets default focus state where the menu should focus every time when menu is opened. Focuses the list root ('list') element by default. */
+    defaultFocusState: keyof typeof DefaultFocusState;
+    defaultFocusStateChanged(): void;
+    /** Override the opening point of the menu. (Default: TOP_START) */
+    anchorCorner: keyof typeof Corner;
+    /** Sets the distance from the anchor point that the menu surface should be shown */
+    anchorMargin: Partial<MDCMenuDistance>;
+    /** Sets whether the menu should open and close without animation when the open/close methods are called */
+    quickOpen: boolean;
+    /** Sets whether the menu surface should stay open after item selection */
+    stayOpenOnSelection: boolean;
+    maxHeight: number;
+    openBottomBias: number;
+    /** Sets whether focus should be restored after the menu is closed */
+    skipRestoreFocus: boolean;
+    skipRestoreFocusChanged(): void;
+    selectOnTab: boolean;
+    stayOpen: boolean;
+    handleKeydown_(evt: KeyboardEvent): boolean;
+    handleItemAction_(evt: IMdcListActionEvent): boolean;
+    handleMenuSurfaceOpened_(): boolean;
+    get open(): boolean;
+    set open(value: boolean);
+    /** Toggles the menu to open or close */
+    toggle(): void;
+    openAnchored(anchor: HTMLElement): void;
+    get wrapFocus(): boolean;
+    set wrapFocus(value: boolean);
+    /**
+     * @return Whether typeahead logic is currently matching some user prefix.
+     */
+    get typeaheadInProgress(): boolean;
+    /**
+     * Return the items within the menu. Note that this only contains the set of elements within
+     * the items container that are proper list items, and not supplemental / presentational DOM
+     * elements.
+     */
+    get items(): Element[];
+    /**
+     * Retrieves the selected index. Only applicable to select menus.
+     * @return The selected index, which is a number for single selection and
+     *     radio lists, and an array of numbers for checkbox lists.
+     */
+    get selectedIndex(): MDCListIndex;
+    /**
+     * Sets the selected index of the list. Only applicable to select menus.
+     * @param index The selected index, which is a number for single selection and
+     *     radio lists, and an array of numbers for checkbox lists.
+     */
+    set selectedIndex(index: MDCListIndex);
+    attaching(): void;
+    initialSyncWithDOM(): void;
+    /**
+     * Given the next desired character from the user, adds it to the typeahead
+     * buffer. Then, attempts to find the next option matching the buffer. Wraps
+     * around if at the end of options.
+     *
+     * @param nextChar The next character to add to the prefix buffer.
+     * @param startingIndex The index from which to start matching. Only relevant
+     *     when starting a new match sequence. To start a new match sequence,
+     *     clear the buffer using `clearTypeaheadBuffer`, or wait for the buffer
+     *     to clear after a set interval defined in list foundation. Defaults to
+     *     the currently focused index.
+     * @return The index of the matched item, or -1 if no match.
+     */
+    typeaheadMatchItem(nextChar: string, startingIndex?: number): number;
+    /**
+     * Layout the underlying list element in the case of any dynamic updates
+     * to its structure.
+     */
+    layout(): void;
+    /**
+     * @param corner Default anchor corner alignment of top-left menu corner.
+     */
+    setAnchorCorner(corner: Corner): void;
+    /**
+     * Sets the list item as the selected row at the specified index.
+     * @param index Index of list item within menu.
+     */
+    setSelectedIndex(index: number): void;
+    /**
+     * Sets the enabled state to isEnabled for the menu item at the given index.
+     * @param index Index of the menu item
+     * @param isEnabled The desired enabled state of the menu item.
+     */
+    setEnabled(index: number, isEnabled: boolean): void;
+    /**
+     * @return The item within the menu at the index specified.
+     */
+    getOptionByIndex(index: number): Element | null;
+    /**
+     * @param index A menu item's index.
+     * @return The primary text within the menu at the index specified.
+     */
+    getPrimaryTextAtIndex(index: number): string;
+    setAbsolutePosition(x: number, y: number): void;
+    getDefaultFoundation(): MDCMenuFoundation;
+}
+export interface IMdcMenuItemComponentEventDetail extends MDCMenuItemComponentEventDetail {
+    data: unknown;
+}
+/** @hidden */
+export interface IMdcMenuItemComponentEvent extends Event {
+    readonly detail: IMdcMenuItemComponentEventDetail;
+}

package/dist/types/menu-surface/mdc-menu-surface-anchor.d.ts

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

package/dist/types/menu-surface/mdc-menu-surface.d.ts

@@ -0,0 +1,44 @@
+import { MdcComponent } from '../base';
+import { MDCMenuSurfaceFoundation, Corner, MDCMenuDistance } from '@material/menu-surface';
+export declare class MdcMenuSurface extends MdcComponent<MDCMenuSurfaceFoundation> implements EventListenerObject {
+    originalParent: HTMLElement | null;
+    private previousFocus?;
+    anchor?: Element | null;
+    /** Sets the foundation to use page offsets for an positioning when the menu is hoisted to the body. */
+    hoistToBody: boolean;
+    fixed: boolean;
+    fixedChanged(): void;
+    anchorCorner?: keyof typeof Corner;
+    anchorCornerChanged(): void;
+    anchorMargin?: Partial<MDCMenuDistance>;
+    anchorMarginChanged(): void;
+    quickOpen: boolean;
+    quickOpenChanged(): void;
+    fullWidth: boolean;
+    fullWidthChanged(): void;
+    stayOpen: boolean;
+    maxHeight: number;
+    maxHeightChanged(): Promise<void>;
+    horizontallyCenteredOnViewport: boolean;
+    horizontallyCenteredOnViewportChanged(): Promise<void>;
+    openBottomBias: number;
+    openBottomBiasChanged(): Promise<void>;
+    get open(): boolean;
+    set open(value: boolean);
+    handleKeydown(evt: KeyboardEvent): void;
+    handleBodyClick(evt: MouseEvent): void;
+    attaching(): void;
+    handleEvent(evt: Event): void;
+    registerBodyClickListener(): void;
+    deregisterBodyClickListener(): void;
+    initialSyncWithDOM(): void;
+    destroy(): void;
+    close(skipRestoreFocus?: boolean): void;
+    /** Sets the absolute x/y position to position based on. Requires the menu to be hoisted. */
+    setAbsolutePosition(x: number, y: number): void;
+    /**
+     * @param corner Default anchor corner alignment of top-left surface corner.
+     */
+    setAnchorCorner(corner: Corner): void;
+    getDefaultFoundation(): MDCMenuSurfaceFoundation;
+}

package/dist/types/notched-outline/mdc-notched-outline.d.ts

@@ -0,0 +1,19 @@
+import { MdcComponent } from '../base';
+import { MDCNotchedOutlineFoundation } from '@material/notched-outline';
+export declare class MdcNotchedOutline extends MdcComponent<MDCNotchedOutlineFoundation> {
+    private notchElement_;
+    label?: HTMLElement;
+    labels: HTMLElement[];
+    labelsChanged(): void;
+    initialSyncWithDOM(): void;
+    /**
+     * Updates classes and styles to open the notch to the specified width.
+     * @param notchWidth The notch width in the outline.
+     */
+    notch(notchWidth: number): void;
+    /**
+     * Updates classes and styles to close the notch.
+     */
+    closeNotch(): void;
+    getDefaultFoundation(): MDCNotchedOutlineFoundation;
+}

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

@@ -0,0 +1,40 @@
+import { MdcComponent } from '../base';
+import { MDCRadioFoundation } from '@material/radio';
+/**
+ * @selector mdc-radio
+ */
+export declare class MdcRadio extends MdcComponent<MDCRadioFoundation> {
+    constructor(root: IMdcRadioElement);
+    nativeControl_: HTMLInputElement;
+    id: string;
+    /** Disables the component */
+    disabled: boolean;
+    disabledChanged(): void;
+    /** Set the component touch target to 48 x 48 px */
+    touch: boolean;
+    _checked?: boolean;
+    /** Use to verify the checked value */
+    get checked(): boolean;
+    set checked(checked: boolean);
+    _value?: string;
+    /** Value of the radio button */
+    get value(): string;
+    set value(value: string);
+    attaching(): void;
+    initialSyncWithDOM(): void;
+    destroy(): void;
+    getDefaultFoundation(): MDCRadioFoundation;
+    /** Set focus to the radio button */
+    focus(): void;
+    /** Set focus away from the radio button */
+    blur(): void;
+}
+/** @hidden */
+export interface IMdcRadioElement extends HTMLElement {
+    checked: boolean;
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcRadio;
+        };
+    };
+}

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

@@ -0,0 +1,29 @@
+import { MdcComponent } from '../base';
+import { MDCRippleFoundation, MDCRippleAdapter } from '@material/ripple';
+export declare class MdcRipple extends MdcComponent<MDCRippleFoundation> {
+    input?: HTMLInputElement;
+    surface?: HTMLElement;
+    computeBoundingRect: () => ClientRect;
+    disabled: boolean;
+    unbounded: boolean;
+    unboundedChanged(): void;
+    activeSurface: boolean;
+    noClass: boolean;
+    primary: boolean;
+    accent: boolean;
+    attaching(): void;
+    initialSyncWithDOM(): void;
+    activate(): void;
+    deactivate(): void;
+    layout(): void;
+    getDefaultFoundation(): MDCRippleFoundation;
+    createAdapter(): MDCRippleAdapter;
+}
+/** @hidden */
+export interface IMdcRippleElement extends HTMLElement {
+    $au: {
+        'au:resource:custom-attribute:mdc-ripple': {
+            viewModel: MdcRipple;
+        };
+    };
+}

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

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

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

@@ -0,0 +1,49 @@
+import { MdcComponent } from '../../base';
+import { MDCSegmentedButtonSegmentFoundation } from '@material/segmented-button';
+/**
+ * @selector button[mdc-segmented-button-segment]
+ */
+export declare class MdcSegmentedButtonSegment extends MdcComponent<MDCSegmentedButtonSegmentFoundation> {
+    constructor(root: IMdcSegmentedButtonSegmentElement);
+    private isSingleSelect;
+    private index;
+    /** Indicates the segment has touch target support */
+    touch: boolean;
+    /** Sets an icon in the segment */
+    icon: string;
+    private _checked?;
+    /** Use to verify the checked value */
+    get checked(): boolean;
+    /**
+     * Whether the segment is checked.
+     */
+    set checked(value: boolean);
+    handleClick(): void;
+    beforeFoundationCreated(): Promise<void>;
+    initialSyncWithDOM(): void;
+    getDefaultFoundation(): MDCSegmentedButtonSegmentFoundation;
+    notifySelectedChange(event: string, selected: boolean): void;
+    setIsSingleSelect(isSingleSelect: boolean): void;
+    /**
+     * Sets segment's index value
+     *
+     * @hidden
+     * @param index Segment's index within wrapping segmented button
+     */
+    setIndex(index: number): void;
+    /**
+     * @hidden
+     * @return Returns segment's segmentId if it was set by client
+     */
+    getSegmentId(): string | undefined;
+}
+/** @hidden */
+export interface IMdcSegmentedButtonSegmentElement extends HTMLElement {
+    checked: boolean;
+    indeterminate: boolean;
+    $au: {
+        'au:resource:custom-element': {
+            viewModel: MdcSegmentedButtonSegment;
+        };
+    };
+}