@material/chips

  • Version 12.0.0
  • Published
  • 1.61 MB
  • 14 dependencies
  • MIT license

Install

npm i @material/chips
yarn add @material/chips
pnpm add @material/chips

Overview

The Material Components for the Web chips component

Index

Namespaces

Namespaces

namespace @material/chips

module '@material/chips' {}

    class MDCChipSet

    class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {}
    • MDCChip provides component encapsulation of the foundation implementation.

    method addChip

    addChip: (index: number) => void;
    • Animates the chip addition at the given index.

    method attachTo

    static attachTo: (root: Element) => MDCChipSet;

      method destroy

      destroy: () => void;

        method getChipIdAtIndex

        getChipIdAtIndex: (index: number) => string;
        • Returns the ID of the chip at the given index or an empty string if the index is out of bounds.

        method getChipIndexByID

        getChipIndexByID: (chipID: string) => number;
        • Returns the index of the chip with the given ID or -1 if none exists.

        method getDefaultFoundation

        getDefaultFoundation: () => MDCChipSetFoundation;

          method getSelectedChipIndexes

          getSelectedChipIndexes: () => ReadonlySet<number>;
          • Returns the unique indexes of the selected chips.

          method initialize

          initialize: (chipFactory?: MDCChipFactory) => void;

            method initialSyncWithDOM

            initialSyncWithDOM: () => void;

              method isChipSelected

              isChipSelected: (index: number, action: ActionType) => boolean;
              • Returns the selection state of the chip.

              method removeChip

              removeChip: (index: number) => void;
              • Removes the chip at the given index.

              method setChipSelected

              setChipSelected: (
              index: number,
              action: ActionType,
              isSelected: boolean
              ) => void;
              • Sets the selection state of the chip.

              class MDCChipSetFoundation

              class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {}
              • MDCChipSetFoundation provides a foundation for all chips.

              constructor

              constructor(adapter?: Partial<MDCChipSetAdapter>);

                property defaultAdapter

                static readonly defaultAdapter: MDCChipSetAdapter;

                  method addChip

                  addChip: (index: number) => void;

                    method getSelectedChipIndexes

                    getSelectedChipIndexes: () => ReadonlySet<number>;
                    • Returns the unique selected indexes of the chips.

                    method handleChipAnimation

                    handleChipAnimation: ({ detail }: ChipAnimationEvent) => void;

                      method handleChipInteraction

                      handleChipInteraction: ({ detail }: ChipInteractionEvent) => void;

                        method handleChipNavigation

                        handleChipNavigation: ({ detail }: ChipNavigationEvent) => void;

                          method isChipSelected

                          isChipSelected: (index: number, action: ActionType) => boolean;
                          • Returns the selected state of the chip at the given index and action.

                          method removeChip

                          removeChip: (index: number) => void;
                          • Removes the chip at the given index.

                          method setChipSelected

                          setChipSelected: (
                          index: number,
                          action: ActionType,
                          isSelected: boolean
                          ) => void;
                          • Sets the selected state of the chip at the given index and action.

                          interface MDCChipSetAdapter

                          interface MDCChipSetAdapter {}
                          • 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

                          method announceMessage

                          announceMessage: (message: string) => void;
                          • Announces the message via an aria-live region

                          method emitEvent

                          emitEvent: <D extends object>(eventName: Events, eventDetail: D) => void;
                          • Emits the given event with the given detail.

                          method getAttribute

                          getAttribute: (attrName: Attributes) => string | null;
                          • Returns the value for the given attribute, if it exists.

                          method getChipActionsAtIndex

                          getChipActionsAtIndex: (index: number) => ActionType[];
                          • Returns the actions provided by the child chip at the given index.

                          method getChipCount

                          getChipCount: () => number;
                          • Returns the number of child chips.

                          method getChipIdAtIndex

                          getChipIdAtIndex: (index: number) => string;
                          • Returns the ID of the chip at the given index.

                          method getChipIndexById

                          getChipIndexById: (chipID: string) => number;
                          • Returns the index of the child chip with the matching ID.

                          method isChipFocusableAtIndex

                          isChipFocusableAtIndex: (index: number, actionType: ActionType) => boolean;
                          • Proxies to the MDCChip#isActionFocusable method.

                          method isChipSelectableAtIndex

                          isChipSelectableAtIndex: (index: number, actionType: ActionType) => boolean;
                          • Proxies to the MDCChip#isActionSelectable method.

                          method isChipSelectedAtIndex

                          isChipSelectedAtIndex: (index: number, actionType: ActionType) => boolean;
                          • Proxies to the MDCChip#isActionSelected method.

                          method removeChipAtIndex

                          removeChipAtIndex: (index: number) => void;
                          • Removes the chip at the given index.

                          method setChipFocusAtIndex

                          setChipFocusAtIndex: (
                          index: number,
                          action: ActionType,
                          focus: FocusBehavior
                          ) => void;
                          • Proxies to the MDCChip#setActionFocus method.

                          method setChipSelectedAtIndex

                          setChipSelectedAtIndex: (
                          index: number,
                          actionType: ActionType,
                          isSelected: boolean
                          ) => void;
                          • Proxies to the MDCChip#setActionSelected method.

                          method startChipAnimationAtIndex

                          startChipAnimationAtIndex: (index: number, animation: Animation) => void;
                          • Starts the chip animation at the given index.

                          enum Attributes

                          enum Attributes {
                          ARIA_MULTISELECTABLE = 'aria-multiselectable',
                          }
                          • Events provides the named constants for strings used by the foundation.

                          member ARIA_MULTISELECTABLE

                          ARIA_MULTISELECTABLE = 'aria-multiselectable'

                            enum CssClasses

                            enum CssClasses {
                            CHIP = 'mdc-evolution-chip',
                            }
                            • CssClasses provides the named constants for class names.

                            member CHIP

                            CHIP = 'mdc-evolution-chip'

                              enum Events

                              enum Events {
                              INTERACTION = 'MDCChipSet:interaction',
                              REMOVAL = 'MDCChipSet:removal',
                              SELECTION = 'MDCChipSet:selection',
                              }
                              • Events provides the constants for emitted events.

                              member INTERACTION

                              INTERACTION = 'MDCChipSet:interaction'

                                member REMOVAL

                                REMOVAL = 'MDCChipSet:removal'

                                  member SELECTION

                                  SELECTION = 'MDCChipSet:selection'

                                    namespace @material/chips.deprecated

                                    namespace @material/chips.deprecated {}

                                      variable chipCssClasses

                                      const chipCssClasses: {
                                      CHECKMARK: string;
                                      CHIP_EXIT: string;
                                      DELETABLE: string;
                                      EDITABLE: string;
                                      EDITING: string;
                                      HIDDEN_LEADING_ICON: string;
                                      LEADING_ICON: string;
                                      PRIMARY_ACTION: string;
                                      PRIMARY_ACTION_FOCUSED: string;
                                      SELECTED: string;
                                      TEXT: string;
                                      TRAILING_ACTION: string;
                                      TRAILING_ICON: string;
                                      };

                                        variable chipSetCssClasses

                                        const chipSetCssClasses: { CHOICE: string; FILTER: string };

                                          variable chipSetStrings

                                          const chipSetStrings: { CHIP_SELECTOR: string };
                                          • 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.

                                          variable chipStrings

                                          const chipStrings: {
                                          ADDED_ANNOUNCEMENT_ATTRIBUTE: string;
                                          ARIA_CHECKED: string;
                                          ARROW_DOWN_KEY: string;
                                          ARROW_LEFT_KEY: string;
                                          ARROW_RIGHT_KEY: string;
                                          ARROW_UP_KEY: string;
                                          BACKSPACE_KEY: string;
                                          CHECKMARK_SELECTOR: string;
                                          DELETE_KEY: string;
                                          END_KEY: string;
                                          ENTER_KEY: string;
                                          ENTRY_ANIMATION_NAME: string;
                                          HOME_KEY: string;
                                          IE_ARROW_DOWN_KEY: string;
                                          IE_ARROW_LEFT_KEY: string;
                                          IE_ARROW_RIGHT_KEY: string;
                                          IE_ARROW_UP_KEY: string;
                                          IE_DELETE_KEY: string;
                                          INTERACTION_EVENT: string;
                                          LEADING_ICON_SELECTOR: string;
                                          NAVIGATION_EVENT: string;
                                          PRIMARY_ACTION_SELECTOR: string;
                                          REMOVED_ANNOUNCEMENT_ATTRIBUTE: string;
                                          REMOVAL_EVENT: string;
                                          SELECTION_EVENT: string;
                                          SPACEBAR_KEY: string;
                                          TAB_INDEX: string;
                                          TRAILING_ACTION_SELECTOR: string;
                                          TRAILING_ICON_INTERACTION_EVENT: string;
                                          TRAILING_ICON_SELECTOR: string;
                                          };

                                            variable trailingActionStrings

                                            const trailingActionStrings: {
                                            ARIA_HIDDEN: string;
                                            INTERACTION_EVENT: string;
                                            NAVIGATION_EVENT: string;
                                            TAB_INDEX: string;
                                            };

                                              class MDCChip

                                              class MDCChip
                                              extends MDCComponent<MDCChipFoundation>
                                              implements MDCRippleCapableSurface {}

                                                property id

                                                readonly id: string;

                                                  property ripple

                                                  readonly ripple: any;

                                                    property selected

                                                    selected: boolean;
                                                    • Whether the chip is selected.

                                                    property shouldRemoveOnTrailingIconClick

                                                    shouldRemoveOnTrailingIconClick: boolean;
                                                    • Whether a trailing icon click should trigger exit/removal of the chip.

                                                    method attachTo

                                                    static attachTo: (root: Element) => MDCChip;

                                                      method beginExit

                                                      beginExit: () => void;
                                                      • Begins the exit animation which leads to removal of the chip.

                                                      method destroy

                                                      destroy: () => void;

                                                        method focusPrimaryAction

                                                        focusPrimaryAction: () => void;

                                                          method focusTrailingAction

                                                          focusTrailingAction: () => void;

                                                            method getDefaultFoundation

                                                            getDefaultFoundation: () => MDCChipFoundation;

                                                              method initialize

                                                              initialize: (
                                                              rippleFactory?: any,
                                                              trailingActionFactory?: MDCChipTrailingActionFactory
                                                              ) => void;

                                                                method initialSyncWithDOM

                                                                initialSyncWithDOM: () => void;

                                                                  method remove

                                                                  remove: () => void;

                                                                    method removeFocus

                                                                    removeFocus: () => void;

                                                                      method setSelectedFromChipSet

                                                                      setSelectedFromChipSet: (
                                                                      selected: boolean,
                                                                      shouldNotifyClients: boolean
                                                                      ) => void;

                                                                        class MDCChipFoundation

                                                                        class MDCChipFoundation extends MDCFoundation<MDCChipAdapter> {}

                                                                          constructor

                                                                          constructor(adapter?: Partial<MDCChipAdapter>);

                                                                            property cssClasses

                                                                            static readonly cssClasses: {
                                                                            CHECKMARK: string;
                                                                            CHIP_EXIT: string;
                                                                            DELETABLE: string;
                                                                            EDITABLE: string;
                                                                            EDITING: string;
                                                                            HIDDEN_LEADING_ICON: string;
                                                                            LEADING_ICON: string;
                                                                            PRIMARY_ACTION: string;
                                                                            PRIMARY_ACTION_FOCUSED: string;
                                                                            SELECTED: string;
                                                                            TEXT: string;
                                                                            TRAILING_ACTION: string;
                                                                            TRAILING_ICON: string;
                                                                            };

                                                                              property defaultAdapter

                                                                              static readonly defaultAdapter: MDCChipAdapter;

                                                                                property strings

                                                                                static readonly strings: {
                                                                                ADDED_ANNOUNCEMENT_ATTRIBUTE: string;
                                                                                ARIA_CHECKED: string;
                                                                                ARROW_DOWN_KEY: string;
                                                                                ARROW_LEFT_KEY: string;
                                                                                ARROW_RIGHT_KEY: string;
                                                                                ARROW_UP_KEY: string;
                                                                                BACKSPACE_KEY: string;
                                                                                CHECKMARK_SELECTOR: string;
                                                                                DELETE_KEY: string;
                                                                                END_KEY: string;
                                                                                ENTER_KEY: string;
                                                                                ENTRY_ANIMATION_NAME: string;
                                                                                HOME_KEY: string;
                                                                                IE_ARROW_DOWN_KEY: string;
                                                                                IE_ARROW_LEFT_KEY: string;
                                                                                IE_ARROW_RIGHT_KEY: string;
                                                                                IE_ARROW_UP_KEY: string;
                                                                                IE_DELETE_KEY: string;
                                                                                INTERACTION_EVENT: string;
                                                                                LEADING_ICON_SELECTOR: string;
                                                                                NAVIGATION_EVENT: string;
                                                                                PRIMARY_ACTION_SELECTOR: string;
                                                                                REMOVED_ANNOUNCEMENT_ATTRIBUTE: string;
                                                                                REMOVAL_EVENT: string;
                                                                                SELECTION_EVENT: string;
                                                                                SPACEBAR_KEY: string;
                                                                                TAB_INDEX: string;
                                                                                TRAILING_ACTION_SELECTOR: string;
                                                                                TRAILING_ICON_INTERACTION_EVENT: string;
                                                                                TRAILING_ICON_SELECTOR: string;
                                                                                };

                                                                                  method beginExit

                                                                                  beginExit: () => void;
                                                                                  • Begins the exit animation which leads to removal of the chip.

                                                                                  method focusPrimaryAction

                                                                                  focusPrimaryAction: () => void;
                                                                                  • Called by the chip set to focus the primary action.

                                                                                  method focusTrailingAction

                                                                                  focusTrailingAction: () => void;
                                                                                  • Called by the chip set to focus the trailing action (if present), otherwise gives focus to the trailing action.

                                                                                  method getDimensions

                                                                                  getDimensions: () => ClientRect;

                                                                                    method getShouldRemoveOnTrailingIconClick

                                                                                    getShouldRemoveOnTrailingIconClick: () => boolean;

                                                                                      method handleClick

                                                                                      handleClick: () => void;

                                                                                        method handleDoubleClick

                                                                                        handleDoubleClick: () => void;

                                                                                          method handleFocusIn

                                                                                          handleFocusIn: (evt: FocusEvent) => void;

                                                                                            method handleFocusOut

                                                                                            handleFocusOut: (evt: FocusEvent) => void;

                                                                                              method handleKeydown

                                                                                              handleKeydown: (evt: KeyboardEvent) => void;
                                                                                              • Handles a keydown event from the root element.

                                                                                              method handleTrailingActionInteraction

                                                                                              handleTrailingActionInteraction: () => void;
                                                                                              • Handles an interaction event on the trailing icon element. This is used to prevent the ripple from activating on interaction with the trailing icon.

                                                                                              method handleTrailingActionNavigation

                                                                                              handleTrailingActionNavigation: (
                                                                                              evt: MDCChipTrailingActionNavigationEvent
                                                                                              ) => void;

                                                                                                method handleTransitionEnd

                                                                                                handleTransitionEnd: (evt: TransitionEvent) => void;
                                                                                                • Handles a transition end event on the root element.

                                                                                                method isEditable

                                                                                                isEditable: () => boolean;

                                                                                                  method isEditing

                                                                                                  isEditing: () => boolean;

                                                                                                    method isSelected

                                                                                                    isSelected: () => boolean;

                                                                                                      method removeFocus

                                                                                                      removeFocus: () => void;
                                                                                                      • Called by the chip set to remove focus from the chip actions.

                                                                                                      method setSelected

                                                                                                      setSelected: (selected: boolean) => void;

                                                                                                        method setSelectedFromChipSet

                                                                                                        setSelectedFromChipSet: (
                                                                                                        selected: boolean,
                                                                                                        shouldNotifyClients: boolean
                                                                                                        ) => void;

                                                                                                          method setShouldFocusPrimaryActionOnClick

                                                                                                          setShouldFocusPrimaryActionOnClick: (shouldFocus: boolean) => void;

                                                                                                            method setShouldRemoveOnTrailingIconClick

                                                                                                            setShouldRemoveOnTrailingIconClick: (shouldRemove: boolean) => void;

                                                                                                              class MDCChipSet

                                                                                                              class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {}

                                                                                                                property chips

                                                                                                                readonly chips: readonly MDCChip[];

                                                                                                                  property selectedChipIds

                                                                                                                  readonly selectedChipIds: readonly string[];
                                                                                                                  • An array of the IDs of all selected chips.

                                                                                                                  method addChip

                                                                                                                  addChip: (chipEl: Element) => void;
                                                                                                                  • Adds a new chip object to the chip set from the given chip element.

                                                                                                                  method attachTo

                                                                                                                  static attachTo: (root: Element) => MDCChipSet;

                                                                                                                    method destroy

                                                                                                                    destroy: () => void;

                                                                                                                      method getDefaultFoundation

                                                                                                                      getDefaultFoundation: () => MDCChipSetFoundation;

                                                                                                                        method initialize

                                                                                                                        initialize: (chipFactory?: MDCChipFactory) => void;
                                                                                                                        • Parameter chipFactory

                                                                                                                          A function which creates a new MDCChip.

                                                                                                                        method initialSyncWithDOM

                                                                                                                        initialSyncWithDOM: () => void;

                                                                                                                          class MDCChipSetFoundation

                                                                                                                          class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {}

                                                                                                                            constructor

                                                                                                                            constructor(adapter?: Partial<MDCChipSetAdapter>);

                                                                                                                              property cssClasses

                                                                                                                              static readonly cssClasses: { CHOICE: string; FILTER: string };

                                                                                                                                property defaultAdapter

                                                                                                                                static readonly defaultAdapter: MDCChipSetAdapter;

                                                                                                                                  property strings

                                                                                                                                  static readonly strings: { CHIP_SELECTOR: string };

                                                                                                                                    method getSelectedChipIds

                                                                                                                                    getSelectedChipIds: () => ReadonlyArray<string>;
                                                                                                                                    • Returns an array of the IDs of all selected chips.

                                                                                                                                    method handleChipInteraction

                                                                                                                                    handleChipInteraction: ({ chipId }: MDCChipInteractionEventDetail) => void;
                                                                                                                                    • Handles a chip interaction event

                                                                                                                                    method handleChipNavigation

                                                                                                                                    handleChipNavigation: ({
                                                                                                                                    chipId,
                                                                                                                                    key,
                                                                                                                                    source,
                                                                                                                                    }: MDCChipNavigationEventDetail) => void;
                                                                                                                                    • Handles a chip navigation event.

                                                                                                                                    method handleChipRemoval

                                                                                                                                    handleChipRemoval: ({
                                                                                                                                    chipId,
                                                                                                                                    removedAnnouncement,
                                                                                                                                    }: MDCChipRemovalEventDetail) => void;
                                                                                                                                    • Handles the event when a chip is removed.

                                                                                                                                    method handleChipSelection

                                                                                                                                    handleChipSelection: ({
                                                                                                                                    chipId,
                                                                                                                                    selected,
                                                                                                                                    shouldIgnore,
                                                                                                                                    }: MDCChipSelectionEventDetail) => void;
                                                                                                                                    • Handles a chip selection event, used to handle discrepancy when selection state is set directly on the Chip.

                                                                                                                                    method select

                                                                                                                                    select: (chipId: string) => void;
                                                                                                                                    • Selects the chip with the given id. Deselects all other chips if the chip set is of the choice variant. Does not notify clients of the updated selection state.

                                                                                                                                    class MDCChipTrailingAction

                                                                                                                                    class MDCChipTrailingAction
                                                                                                                                    extends MDCComponent<MDCChipTrailingActionFoundation>
                                                                                                                                    implements MDCRippleCapableSurface {}

                                                                                                                                      property ripple

                                                                                                                                      readonly ripple: any;

                                                                                                                                        method attachTo

                                                                                                                                        static attachTo: (root: Element) => MDCChipTrailingAction;

                                                                                                                                          method destroy

                                                                                                                                          destroy: () => void;

                                                                                                                                            method focus

                                                                                                                                            focus: () => void;

                                                                                                                                              method getDefaultFoundation

                                                                                                                                              getDefaultFoundation: () => MDCChipTrailingActionFoundation;

                                                                                                                                                method initialize

                                                                                                                                                initialize: (rippleFactory?: any) => void;

                                                                                                                                                  method initialSyncWithDOM

                                                                                                                                                  initialSyncWithDOM: () => void;

                                                                                                                                                    method isNavigable

                                                                                                                                                    isNavigable: () => boolean;

                                                                                                                                                      method removeFocus

                                                                                                                                                      removeFocus: () => void;

                                                                                                                                                        class MDCChipTrailingActionFoundation

                                                                                                                                                        class MDCChipTrailingActionFoundation extends MDCFoundation<MDCChipTrailingActionAdapter> {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(adapter?: Partial<MDCChipTrailingActionAdapter>);

                                                                                                                                                            property defaultAdapter

                                                                                                                                                            static readonly defaultAdapter: MDCChipTrailingActionAdapter;

                                                                                                                                                              property strings

                                                                                                                                                              static readonly strings: {
                                                                                                                                                              ARIA_HIDDEN: string;
                                                                                                                                                              INTERACTION_EVENT: string;
                                                                                                                                                              NAVIGATION_EVENT: string;
                                                                                                                                                              TAB_INDEX: string;
                                                                                                                                                              };

                                                                                                                                                                method focus

                                                                                                                                                                focus: () => void;

                                                                                                                                                                  method handleClick

                                                                                                                                                                  handleClick: (evt: MouseEvent) => void;

                                                                                                                                                                    method handleKeydown

                                                                                                                                                                    handleKeydown: (evt: KeyboardEvent) => void;

                                                                                                                                                                      method isNavigable

                                                                                                                                                                      isNavigable: () => boolean;

                                                                                                                                                                        method removeFocus

                                                                                                                                                                        removeFocus: () => void;

                                                                                                                                                                          interface MDCChipAdapter

                                                                                                                                                                          interface MDCChipAdapter {}
                                                                                                                                                                          • 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

                                                                                                                                                                          method addClass

                                                                                                                                                                          addClass: (className: string) => void;
                                                                                                                                                                          • Adds a class to the root element.

                                                                                                                                                                          method addClassToLeadingIcon

                                                                                                                                                                          addClassToLeadingIcon: (className: string) => void;
                                                                                                                                                                          • Adds a class to the leading icon element.

                                                                                                                                                                          method eventTargetHasClass

                                                                                                                                                                          eventTargetHasClass: (target: EventTarget | null, className: string) => boolean;
                                                                                                                                                                          • true if target has className, false otherwise.

                                                                                                                                                                          method focusPrimaryAction

                                                                                                                                                                          focusPrimaryAction: () => void;
                                                                                                                                                                          • Gives focus to the primary action.

                                                                                                                                                                          method focusTrailingAction

                                                                                                                                                                          focusTrailingAction: () => void;
                                                                                                                                                                          • Sets focus to the trailing action.

                                                                                                                                                                          method getAttribute

                                                                                                                                                                          getAttribute: (attr: string) => string | null;
                                                                                                                                                                          • the attribute string value if present, otherwise null

                                                                                                                                                                          method getCheckmarkBoundingClientRect

                                                                                                                                                                          getCheckmarkBoundingClientRect: () => ClientRect | null;
                                                                                                                                                                          • The bounding client rect of the checkmark element or null if it doesn't exist.

                                                                                                                                                                          method getComputedStyleValue

                                                                                                                                                                          getComputedStyleValue: (propertyName: string) => string;
                                                                                                                                                                          • The computed property value of the given style property on the root element.

                                                                                                                                                                          method getRootBoundingClientRect

                                                                                                                                                                          getRootBoundingClientRect: () => ClientRect;
                                                                                                                                                                          • The bounding client rect of the root element.

                                                                                                                                                                          method hasClass

                                                                                                                                                                          hasClass: (className: string) => boolean;
                                                                                                                                                                          • true if the root element contains the given class.

                                                                                                                                                                          method hasLeadingIcon

                                                                                                                                                                          hasLeadingIcon: () => boolean;
                                                                                                                                                                          • Whether the chip has a leading icon.

                                                                                                                                                                          method isRTL

                                                                                                                                                                          isRTL: () => boolean;
                                                                                                                                                                          • true if the text direction is right-to-left.

                                                                                                                                                                          method isTrailingActionNavigable

                                                                                                                                                                          isTrailingActionNavigable: () => boolean;
                                                                                                                                                                          • Returns true if the trailing action is navigable. Should return the value of MDCChipTrailingAction#isNavigable() or false.

                                                                                                                                                                          method notifyEditFinish

                                                                                                                                                                          notifyEditFinish: () => void;
                                                                                                                                                                          • Emits when editing finishes.

                                                                                                                                                                          method notifyEditStart

                                                                                                                                                                          notifyEditStart: () => void;
                                                                                                                                                                          • Emits when editing starts.

                                                                                                                                                                          method notifyInteraction

                                                                                                                                                                          notifyInteraction: () => void;
                                                                                                                                                                          • Emits a custom "MDCChip:interaction" event denoting the chip has been interacted with (typically on click or keydown).

                                                                                                                                                                          method notifyNavigation

                                                                                                                                                                          notifyNavigation: (key: string, source: EventSource) => void;
                                                                                                                                                                          • Emits a custom event "MDCChip:navigation" denoting a focus navigation event.

                                                                                                                                                                          method notifyRemoval

                                                                                                                                                                          notifyRemoval: (removedAnnouncement: string | null) => void;
                                                                                                                                                                          • Emits a custom event "MDCChip:removal" denoting the chip will be removed.

                                                                                                                                                                          method notifySelection

                                                                                                                                                                          notifySelection: (selected: boolean, chipSetShouldIgnore: boolean) => void;
                                                                                                                                                                          • Emits a custom "MDCChip:selection" event denoting the chip has been selected or deselected.

                                                                                                                                                                          method notifyTrailingIconInteraction

                                                                                                                                                                          notifyTrailingIconInteraction: () => void;
                                                                                                                                                                          • Emits a custom "MDCChip:trailingIconInteraction" event denoting the trailing icon has been interacted with (typically on click or keydown).

                                                                                                                                                                          method removeClass

                                                                                                                                                                          removeClass: (className: string) => void;
                                                                                                                                                                          • Removes a class from the root element.

                                                                                                                                                                          method removeClassFromLeadingIcon

                                                                                                                                                                          removeClassFromLeadingIcon: (className: string) => void;
                                                                                                                                                                          • Removes a class from the leading icon element.

                                                                                                                                                                          method removeTrailingActionFocus

                                                                                                                                                                          removeTrailingActionFocus: () => void;
                                                                                                                                                                          • Removes focus from the trailing action.

                                                                                                                                                                          method setPrimaryActionAttr

                                                                                                                                                                          setPrimaryActionAttr: (attr: string, value: string) => void;
                                                                                                                                                                          • Sets the value of the attribute on the primary action content.

                                                                                                                                                                          method setStyleProperty

                                                                                                                                                                          setStyleProperty: (propertyName: string, value: string) => void;
                                                                                                                                                                          • Sets the property value of the given style property on the root element.

                                                                                                                                                                          interface MDCChipInteractionEvent

                                                                                                                                                                          interface MDCChipInteractionEvent extends Event {}

                                                                                                                                                                            property detail

                                                                                                                                                                            readonly detail: MDCChipInteractionEventDetail;

                                                                                                                                                                              interface MDCChipInteractionEventDetail

                                                                                                                                                                              interface MDCChipInteractionEventDetail {}

                                                                                                                                                                                property chipId

                                                                                                                                                                                chipId: string;

                                                                                                                                                                                  interface MDCChipNavigationEvent

                                                                                                                                                                                  interface MDCChipNavigationEvent extends Event {}

                                                                                                                                                                                    property detail

                                                                                                                                                                                    readonly detail: MDCChipNavigationEventDetail;

                                                                                                                                                                                      interface MDCChipNavigationEventDetail

                                                                                                                                                                                      interface MDCChipNavigationEventDetail extends MDCChipInteractionEventDetail {}

                                                                                                                                                                                        property key

                                                                                                                                                                                        key: string;

                                                                                                                                                                                          property source

                                                                                                                                                                                          source: EventSource;

                                                                                                                                                                                            interface MDCChipRemovalEvent

                                                                                                                                                                                            interface MDCChipRemovalEvent extends Event {}

                                                                                                                                                                                              property detail

                                                                                                                                                                                              readonly detail: MDCChipRemovalEventDetail;

                                                                                                                                                                                                interface MDCChipRemovalEventDetail

                                                                                                                                                                                                interface MDCChipRemovalEventDetail extends MDCChipInteractionEventDetail {}

                                                                                                                                                                                                  property removedAnnouncement

                                                                                                                                                                                                  removedAnnouncement: string | null;

                                                                                                                                                                                                    interface MDCChipSelectionEvent

                                                                                                                                                                                                    interface MDCChipSelectionEvent extends Event {}

                                                                                                                                                                                                      property detail

                                                                                                                                                                                                      readonly detail: MDCChipSelectionEventDetail;

                                                                                                                                                                                                        interface MDCChipSelectionEventDetail

                                                                                                                                                                                                        interface MDCChipSelectionEventDetail extends MDCChipInteractionEventDetail {}

                                                                                                                                                                                                          property selected

                                                                                                                                                                                                          selected: boolean;

                                                                                                                                                                                                            property shouldIgnore

                                                                                                                                                                                                            shouldIgnore: boolean;

                                                                                                                                                                                                              interface MDCChipSetAdapter

                                                                                                                                                                                                              interface MDCChipSetAdapter {}
                                                                                                                                                                                                              • 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

                                                                                                                                                                                                              method announceMessage

                                                                                                                                                                                                              announceMessage: (message: string) => void;
                                                                                                                                                                                                              • Announces the message via an aria-live region.

                                                                                                                                                                                                              method focusChipPrimaryActionAtIndex

                                                                                                                                                                                                              focusChipPrimaryActionAtIndex: (index: number) => void;
                                                                                                                                                                                                              • Calls Chip#focusPrimaryAction() on the chip at the given index.

                                                                                                                                                                                                                Parameter index

                                                                                                                                                                                                                the index of the chip

                                                                                                                                                                                                              method focusChipTrailingActionAtIndex

                                                                                                                                                                                                              focusChipTrailingActionAtIndex: (index: number) => void;
                                                                                                                                                                                                              • Calls Chip#focusTrailingAction() on the chip at the given index.

                                                                                                                                                                                                                Parameter index

                                                                                                                                                                                                                the index of the chip

                                                                                                                                                                                                              method getChipListCount

                                                                                                                                                                                                              getChipListCount: () => number;
                                                                                                                                                                                                              • the number of chips in the chip set.

                                                                                                                                                                                                              method getIndexOfChipById

                                                                                                                                                                                                              getIndexOfChipById: (chipId: string) => number;
                                                                                                                                                                                                              • Returns the index of the chip at the given ID.

                                                                                                                                                                                                                Parameter chipId

                                                                                                                                                                                                                the unique ID of the chip the numerical index of the chip with the matching id or -1.

                                                                                                                                                                                                              method hasClass

                                                                                                                                                                                                              hasClass: (className: string) => boolean;
                                                                                                                                                                                                              • true if the root element contains the given class name.

                                                                                                                                                                                                              method isRTL

                                                                                                                                                                                                              isRTL: () => boolean;
                                                                                                                                                                                                              • true if the text direction is RTL.

                                                                                                                                                                                                              method removeChipAtIndex

                                                                                                                                                                                                              removeChipAtIndex: (index: number) => void;
                                                                                                                                                                                                              • Removes the chip with the given index from the chip set. Make sure to remove it from the chip list, too.

                                                                                                                                                                                                              method removeFocusFromChipAtIndex

                                                                                                                                                                                                              removeFocusFromChipAtIndex: (index: number) => void;
                                                                                                                                                                                                              • Removes focus from the chip at the given index.

                                                                                                                                                                                                                Parameter index

                                                                                                                                                                                                                the index of the chip

                                                                                                                                                                                                              method selectChipAtIndex

                                                                                                                                                                                                              selectChipAtIndex: (
                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                              isSelected: boolean,
                                                                                                                                                                                                              shouldNotifyClients: boolean
                                                                                                                                                                                                              ) => void;
                                                                                                                                                                                                              • Sets the selected state of the chip at the given index.

                                                                                                                                                                                                              interface MDCChipTrailingActionAdapter

                                                                                                                                                                                                              interface MDCChipTrailingActionAdapter {}
                                                                                                                                                                                                              • 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

                                                                                                                                                                                                              method focus

                                                                                                                                                                                                              focus: () => void;

                                                                                                                                                                                                                method getAttribute

                                                                                                                                                                                                                getAttribute: (attr: string) => string | null;

                                                                                                                                                                                                                  method notifyInteraction

                                                                                                                                                                                                                  notifyInteraction: (trigger: InteractionTrigger) => void;

                                                                                                                                                                                                                    method notifyNavigation

                                                                                                                                                                                                                    notifyNavigation: (key: string) => void;

                                                                                                                                                                                                                      method setAttribute

                                                                                                                                                                                                                      setAttribute: (attr: string, value: string) => void;

                                                                                                                                                                                                                        interface MDCChipTrailingActionInteractionEvent

                                                                                                                                                                                                                        interface MDCChipTrailingActionInteractionEvent extends Event {}

                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                          readonly detail: MDCChipTrailingActionInteractionEventDetail;

                                                                                                                                                                                                                            interface MDCChipTrailingActionInteractionEventDetail

                                                                                                                                                                                                                            interface MDCChipTrailingActionInteractionEventDetail {}

                                                                                                                                                                                                                              property trigger

                                                                                                                                                                                                                              trigger: InteractionTrigger;

                                                                                                                                                                                                                                interface MDCChipTrailingActionNavigationEvent

                                                                                                                                                                                                                                interface MDCChipTrailingActionNavigationEvent extends Event {}

                                                                                                                                                                                                                                  property detail

                                                                                                                                                                                                                                  readonly detail: MDCChipTrailingActionNavigationEventDetail;

                                                                                                                                                                                                                                    interface MDCChipTrailingActionNavigationEventDetail

                                                                                                                                                                                                                                    interface MDCChipTrailingActionNavigationEventDetail {}

                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                      key: string;

                                                                                                                                                                                                                                        type MDCChipFactory

                                                                                                                                                                                                                                        type MDCChipFactory = (el: Element, foundation?: MDCChipFoundation) => MDCChip;

                                                                                                                                                                                                                                          type MDCChipTrailingActionFactory

                                                                                                                                                                                                                                          type MDCChipTrailingActionFactory = (
                                                                                                                                                                                                                                          el: Element,
                                                                                                                                                                                                                                          foundation?: MDCChipTrailingActionFoundation
                                                                                                                                                                                                                                          ) => MDCChipTrailingAction;
                                                                                                                                                                                                                                          • Creates a trailing action component on the given element.

                                                                                                                                                                                                                                          namespace @material/chips/action/adapter

                                                                                                                                                                                                                                          module '@material/chips/action/adapter' {}

                                                                                                                                                                                                                                            interface MDCChipActionAdapter

                                                                                                                                                                                                                                            interface MDCChipActionAdapter {}
                                                                                                                                                                                                                                            • 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

                                                                                                                                                                                                                                            method emitEvent

                                                                                                                                                                                                                                            emitEvent: <D extends object>(eventName: Events, eventDetail: D) => void;

                                                                                                                                                                                                                                              method focus

                                                                                                                                                                                                                                              focus: () => void;

                                                                                                                                                                                                                                                method getAttribute

                                                                                                                                                                                                                                                getAttribute: (attr: Attributes) => string | null;

                                                                                                                                                                                                                                                  method getElementID

                                                                                                                                                                                                                                                  getElementID: () => string;

                                                                                                                                                                                                                                                    method removeAttribute

                                                                                                                                                                                                                                                    removeAttribute: (attr: Attributes) => void;

                                                                                                                                                                                                                                                      method setAttribute

                                                                                                                                                                                                                                                      setAttribute: (attr: Attributes, value: string) => void;

                                                                                                                                                                                                                                                        namespace @material/chips/action/component

                                                                                                                                                                                                                                                        module '@material/chips/action/component' {}

                                                                                                                                                                                                                                                          class MDCChipAction

                                                                                                                                                                                                                                                          class MDCChipAction
                                                                                                                                                                                                                                                          extends MDCComponent<MDCChipActionFoundation>
                                                                                                                                                                                                                                                          implements MDCRippleCapableSurface {}
                                                                                                                                                                                                                                                          • MDCChipAction provides component encapsulation of the different foundation implementations.

                                                                                                                                                                                                                                                          property ripple

                                                                                                                                                                                                                                                          readonly ripple: any;

                                                                                                                                                                                                                                                            method actionType

                                                                                                                                                                                                                                                            actionType: () => ActionType;

                                                                                                                                                                                                                                                              method attachTo

                                                                                                                                                                                                                                                              static attachTo: (root: Element) => MDCChipAction;

                                                                                                                                                                                                                                                                method destroy

                                                                                                                                                                                                                                                                destroy: () => void;

                                                                                                                                                                                                                                                                  method getDefaultFoundation

                                                                                                                                                                                                                                                                  getDefaultFoundation: () =>
                                                                                                                                                                                                                                                                  | MDCChipPrimaryActionFoundation
                                                                                                                                                                                                                                                                  | MDCChipTrailingActionFoundation;

                                                                                                                                                                                                                                                                    method initialize

                                                                                                                                                                                                                                                                    initialize: (rippleFactory?: any) => void;

                                                                                                                                                                                                                                                                      method initialSyncWithDOM

                                                                                                                                                                                                                                                                      initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                        method isDisabled

                                                                                                                                                                                                                                                                        isDisabled: () => boolean;

                                                                                                                                                                                                                                                                          method isFocusable

                                                                                                                                                                                                                                                                          isFocusable: () => boolean;

                                                                                                                                                                                                                                                                            method isSelectable

                                                                                                                                                                                                                                                                            isSelectable: () => boolean;

                                                                                                                                                                                                                                                                              method isSelected

                                                                                                                                                                                                                                                                              isSelected: () => boolean;

                                                                                                                                                                                                                                                                                method setDisabled

                                                                                                                                                                                                                                                                                setDisabled: (isDisabled: boolean) => void;

                                                                                                                                                                                                                                                                                  method setFocus

                                                                                                                                                                                                                                                                                  setFocus: (behavior: FocusBehavior) => void;

                                                                                                                                                                                                                                                                                    method setSelected

                                                                                                                                                                                                                                                                                    setSelected: (isSelected: boolean) => void;

                                                                                                                                                                                                                                                                                      type MDCChipActionFactory

                                                                                                                                                                                                                                                                                      type MDCChipActionFactory = (
                                                                                                                                                                                                                                                                                      el: Element,
                                                                                                                                                                                                                                                                                      foundation?: MDCChipActionFoundation
                                                                                                                                                                                                                                                                                      ) => MDCChipAction;
                                                                                                                                                                                                                                                                                      • MDCChipActionFactory is used by the parent MDCChip component to initialize chip actions.

                                                                                                                                                                                                                                                                                      namespace @material/chips/action/constants

                                                                                                                                                                                                                                                                                      module '@material/chips/action/constants' {}

                                                                                                                                                                                                                                                                                        enum ActionType

                                                                                                                                                                                                                                                                                        enum ActionType {
                                                                                                                                                                                                                                                                                        UNSPECIFIED = 0,
                                                                                                                                                                                                                                                                                        PRIMARY = 1,
                                                                                                                                                                                                                                                                                        TRAILING = 2,
                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                        • ActionType provides the different types of available actions.

                                                                                                                                                                                                                                                                                        member PRIMARY

                                                                                                                                                                                                                                                                                        PRIMARY = 1

                                                                                                                                                                                                                                                                                          member TRAILING

                                                                                                                                                                                                                                                                                          TRAILING = 2

                                                                                                                                                                                                                                                                                            member UNSPECIFIED

                                                                                                                                                                                                                                                                                            UNSPECIFIED = 0

                                                                                                                                                                                                                                                                                              enum Attributes

                                                                                                                                                                                                                                                                                              enum Attributes {
                                                                                                                                                                                                                                                                                              ARIA_DISABLED = 'aria-disabled',
                                                                                                                                                                                                                                                                                              ARIA_HIDDEN = 'aria-hidden',
                                                                                                                                                                                                                                                                                              ARIA_SELECTED = 'aria-selected',
                                                                                                                                                                                                                                                                                              DATA_DELETABLE = 'data-mdc-deletable',
                                                                                                                                                                                                                                                                                              DISABLED = 'disabled',
                                                                                                                                                                                                                                                                                              ROLE = 'role',
                                                                                                                                                                                                                                                                                              TAB_INDEX = 'tabindex',
                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                              • Attributes provides the HTML attributes used by the foundation.

                                                                                                                                                                                                                                                                                              member ARIA_DISABLED

                                                                                                                                                                                                                                                                                              ARIA_DISABLED = 'aria-disabled'

                                                                                                                                                                                                                                                                                                member ARIA_HIDDEN

                                                                                                                                                                                                                                                                                                ARIA_HIDDEN = 'aria-hidden'

                                                                                                                                                                                                                                                                                                  member ARIA_SELECTED

                                                                                                                                                                                                                                                                                                  ARIA_SELECTED = 'aria-selected'

                                                                                                                                                                                                                                                                                                    member DATA_DELETABLE

                                                                                                                                                                                                                                                                                                    DATA_DELETABLE = 'data-mdc-deletable'

                                                                                                                                                                                                                                                                                                      member DISABLED

                                                                                                                                                                                                                                                                                                      DISABLED = 'disabled'

                                                                                                                                                                                                                                                                                                        member ROLE

                                                                                                                                                                                                                                                                                                        ROLE = 'role'

                                                                                                                                                                                                                                                                                                          member TAB_INDEX

                                                                                                                                                                                                                                                                                                          TAB_INDEX = 'tabindex'

                                                                                                                                                                                                                                                                                                            enum CssClasses

                                                                                                                                                                                                                                                                                                            enum CssClasses {
                                                                                                                                                                                                                                                                                                            PRIMARY_ACTION = 'mdc-evolution-chip__action--primary',
                                                                                                                                                                                                                                                                                                            TRAILING_ACTION = 'mdc-evolution-chip__action--trailing',
                                                                                                                                                                                                                                                                                                            CHIP_ROOT = 'mdc-evolution-chip',
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                            • CssClasses provides the classes to be queried and manipulated on the root.

                                                                                                                                                                                                                                                                                                            member CHIP_ROOT

                                                                                                                                                                                                                                                                                                            CHIP_ROOT = 'mdc-evolution-chip'

                                                                                                                                                                                                                                                                                                              member PRIMARY_ACTION

                                                                                                                                                                                                                                                                                                              PRIMARY_ACTION = 'mdc-evolution-chip__action--primary'

                                                                                                                                                                                                                                                                                                                member TRAILING_ACTION

                                                                                                                                                                                                                                                                                                                TRAILING_ACTION = 'mdc-evolution-chip__action--trailing'

                                                                                                                                                                                                                                                                                                                  enum Events

                                                                                                                                                                                                                                                                                                                  enum Events {
                                                                                                                                                                                                                                                                                                                  INTERACTION = 'MDCChipAction:interaction',
                                                                                                                                                                                                                                                                                                                  NAVIGATION = 'MDCChipAction:navigation',
                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                  • Events provides the different events emitted by the action.

                                                                                                                                                                                                                                                                                                                  member INTERACTION

                                                                                                                                                                                                                                                                                                                  INTERACTION = 'MDCChipAction:interaction'

                                                                                                                                                                                                                                                                                                                    member NAVIGATION

                                                                                                                                                                                                                                                                                                                    NAVIGATION = 'MDCChipAction:navigation'

                                                                                                                                                                                                                                                                                                                      enum FocusBehavior

                                                                                                                                                                                                                                                                                                                      enum FocusBehavior {
                                                                                                                                                                                                                                                                                                                      FOCUSABLE = 0,
                                                                                                                                                                                                                                                                                                                      FOCUSABLE_AND_FOCUSED = 1,
                                                                                                                                                                                                                                                                                                                      NOT_FOCUSABLE = 2,
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                      • FocusBehavior provides configurations for focusing or unfocusing an action.

                                                                                                                                                                                                                                                                                                                      member FOCUSABLE

                                                                                                                                                                                                                                                                                                                      FOCUSABLE = 0

                                                                                                                                                                                                                                                                                                                        member FOCUSABLE_AND_FOCUSED

                                                                                                                                                                                                                                                                                                                        FOCUSABLE_AND_FOCUSED = 1

                                                                                                                                                                                                                                                                                                                          member NOT_FOCUSABLE

                                                                                                                                                                                                                                                                                                                          NOT_FOCUSABLE = 2

                                                                                                                                                                                                                                                                                                                            enum InteractionTrigger

                                                                                                                                                                                                                                                                                                                            enum InteractionTrigger {
                                                                                                                                                                                                                                                                                                                            UNSPECIFIED = 0,
                                                                                                                                                                                                                                                                                                                            CLICK = 1,
                                                                                                                                                                                                                                                                                                                            BACKSPACE_KEY = 2,
                                                                                                                                                                                                                                                                                                                            DELETE_KEY = 3,
                                                                                                                                                                                                                                                                                                                            SPACEBAR_KEY = 4,
                                                                                                                                                                                                                                                                                                                            ENTER_KEY = 5,
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                            • InteractionTrigger provides detail of the different triggers for action interactions.

                                                                                                                                                                                                                                                                                                                            member BACKSPACE_KEY

                                                                                                                                                                                                                                                                                                                            BACKSPACE_KEY = 2

                                                                                                                                                                                                                                                                                                                              member CLICK

                                                                                                                                                                                                                                                                                                                              CLICK = 1

                                                                                                                                                                                                                                                                                                                                member DELETE_KEY

                                                                                                                                                                                                                                                                                                                                DELETE_KEY = 3

                                                                                                                                                                                                                                                                                                                                  member ENTER_KEY

                                                                                                                                                                                                                                                                                                                                  ENTER_KEY = 5

                                                                                                                                                                                                                                                                                                                                    member SPACEBAR_KEY

                                                                                                                                                                                                                                                                                                                                    SPACEBAR_KEY = 4

                                                                                                                                                                                                                                                                                                                                      member UNSPECIFIED

                                                                                                                                                                                                                                                                                                                                      UNSPECIFIED = 0

                                                                                                                                                                                                                                                                                                                                        namespace @material/chips/action/foundation

                                                                                                                                                                                                                                                                                                                                        module '@material/chips/action/foundation' {}

                                                                                                                                                                                                                                                                                                                                          class MDCChipActionFoundation

                                                                                                                                                                                                                                                                                                                                          abstract class MDCChipActionFoundation extends MDCFoundation<MDCChipActionAdapter> {}
                                                                                                                                                                                                                                                                                                                                          • MDCChipActionFoundation provides a base abstract foundation for all chip actions.

                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                          constructor(adapter?: Partial<MDCChipActionAdapter>);

                                                                                                                                                                                                                                                                                                                                            property defaultAdapter

                                                                                                                                                                                                                                                                                                                                            static readonly defaultAdapter: MDCChipActionAdapter;

                                                                                                                                                                                                                                                                                                                                              method actionType

                                                                                                                                                                                                                                                                                                                                              abstract actionType: () => ActionType;

                                                                                                                                                                                                                                                                                                                                                method handleClick

                                                                                                                                                                                                                                                                                                                                                handleClick: () => void;

                                                                                                                                                                                                                                                                                                                                                  method handleKeydown

                                                                                                                                                                                                                                                                                                                                                  handleKeydown: (event: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                    method isDisabled

                                                                                                                                                                                                                                                                                                                                                    isDisabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                      method isFocusable

                                                                                                                                                                                                                                                                                                                                                      isFocusable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                        method isSelectable

                                                                                                                                                                                                                                                                                                                                                        abstract isSelectable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                          method isSelected

                                                                                                                                                                                                                                                                                                                                                          isSelected: () => boolean;

                                                                                                                                                                                                                                                                                                                                                            method setDisabled

                                                                                                                                                                                                                                                                                                                                                            setDisabled: (isDisabled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                              method setFocus

                                                                                                                                                                                                                                                                                                                                                              setFocus: (behavior: FocusBehavior) => void;

                                                                                                                                                                                                                                                                                                                                                                method setSelected

                                                                                                                                                                                                                                                                                                                                                                setSelected: (isSelected: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                  method shouldEmitInteractionOnRemoveKey

                                                                                                                                                                                                                                                                                                                                                                  protected abstract shouldEmitInteractionOnRemoveKey: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                    namespace @material/chips/action/primary-foundation

                                                                                                                                                                                                                                                                                                                                                                    module '@material/chips/action/primary-foundation' {}

                                                                                                                                                                                                                                                                                                                                                                      class MDCChipPrimaryActionFoundation

                                                                                                                                                                                                                                                                                                                                                                      class MDCChipPrimaryActionFoundation extends MDCChipActionFoundation {}
                                                                                                                                                                                                                                                                                                                                                                      • MDCChipPrimaryActionFoundation provides the business logic for the primary chip action.

                                                                                                                                                                                                                                                                                                                                                                      method actionType

                                                                                                                                                                                                                                                                                                                                                                      actionType: () => ActionType;

                                                                                                                                                                                                                                                                                                                                                                        method isSelectable

                                                                                                                                                                                                                                                                                                                                                                        isSelectable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                          method shouldEmitInteractionOnRemoveKey

                                                                                                                                                                                                                                                                                                                                                                          protected shouldEmitInteractionOnRemoveKey: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                            namespace @material/chips/action/trailing-foundation

                                                                                                                                                                                                                                                                                                                                                                            module '@material/chips/action/trailing-foundation' {}

                                                                                                                                                                                                                                                                                                                                                                              class MDCChipTrailingActionFoundation

                                                                                                                                                                                                                                                                                                                                                                              class MDCChipTrailingActionFoundation extends MDCChipActionFoundation {}
                                                                                                                                                                                                                                                                                                                                                                              • MDCChipTrailingActionFoundation provides the business logic for the trailing chip action.

                                                                                                                                                                                                                                                                                                                                                                              method actionType

                                                                                                                                                                                                                                                                                                                                                                              actionType: () => ActionType;

                                                                                                                                                                                                                                                                                                                                                                                method isSelectable

                                                                                                                                                                                                                                                                                                                                                                                isSelectable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                  method shouldEmitInteractionOnRemoveKey

                                                                                                                                                                                                                                                                                                                                                                                  protected shouldEmitInteractionOnRemoveKey: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                    namespace @material/chips/action/types

                                                                                                                                                                                                                                                                                                                                                                                    module '@material/chips/action/types' {}

                                                                                                                                                                                                                                                                                                                                                                                      interface MDCChipActionInteractionEventDetail

                                                                                                                                                                                                                                                                                                                                                                                      interface MDCChipActionInteractionEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                      • MDCChipActionInteractionEventDetail provides the details for the interaction event.

                                                                                                                                                                                                                                                                                                                                                                                      property actionID

                                                                                                                                                                                                                                                                                                                                                                                      actionID: string;

                                                                                                                                                                                                                                                                                                                                                                                        property source

                                                                                                                                                                                                                                                                                                                                                                                        source: ActionType;

                                                                                                                                                                                                                                                                                                                                                                                          property trigger

                                                                                                                                                                                                                                                                                                                                                                                          trigger: InteractionTrigger;

                                                                                                                                                                                                                                                                                                                                                                                            interface MDCChipActionNavigationEventDetail

                                                                                                                                                                                                                                                                                                                                                                                            interface MDCChipActionNavigationEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                            • MDCChipActionNavigationEventDetail provides the details for the navigation event.

                                                                                                                                                                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                                                                                                                                                                            key: string;

                                                                                                                                                                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                                                                                                                                                                              source: ActionType;

                                                                                                                                                                                                                                                                                                                                                                                                namespace @material/chips/chip-set/adapter

                                                                                                                                                                                                                                                                                                                                                                                                module '@material/chips/chip-set/adapter' {}

                                                                                                                                                                                                                                                                                                                                                                                                  interface MDCChipSetAdapter

                                                                                                                                                                                                                                                                                                                                                                                                  interface MDCChipSetAdapter {}
                                                                                                                                                                                                                                                                                                                                                                                                  • 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

                                                                                                                                                                                                                                                                                                                                                                                                  method announceMessage

                                                                                                                                                                                                                                                                                                                                                                                                  announceMessage: (message: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  • Announces the message via an aria-live region

                                                                                                                                                                                                                                                                                                                                                                                                  method emitEvent

                                                                                                                                                                                                                                                                                                                                                                                                  emitEvent: <D extends object>(eventName: Events, eventDetail: D) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  • Emits the given event with the given detail.

                                                                                                                                                                                                                                                                                                                                                                                                  method getAttribute

                                                                                                                                                                                                                                                                                                                                                                                                  getAttribute: (attrName: Attributes) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the value for the given attribute, if it exists.

                                                                                                                                                                                                                                                                                                                                                                                                  method getChipActionsAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  getChipActionsAtIndex: (index: number) => ActionType[];
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the actions provided by the child chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                  method getChipCount

                                                                                                                                                                                                                                                                                                                                                                                                  getChipCount: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the number of child chips.

                                                                                                                                                                                                                                                                                                                                                                                                  method getChipIdAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  getChipIdAtIndex: (index: number) => string;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the ID of the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                  method getChipIndexById

                                                                                                                                                                                                                                                                                                                                                                                                  getChipIndexById: (chipID: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the index of the child chip with the matching ID.

                                                                                                                                                                                                                                                                                                                                                                                                  method isChipFocusableAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  isChipFocusableAtIndex: (index: number, actionType: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                  • Proxies to the MDCChip#isActionFocusable method.

                                                                                                                                                                                                                                                                                                                                                                                                  method isChipSelectableAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  isChipSelectableAtIndex: (index: number, actionType: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                  • Proxies to the MDCChip#isActionSelectable method.

                                                                                                                                                                                                                                                                                                                                                                                                  method isChipSelectedAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  isChipSelectedAtIndex: (index: number, actionType: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                  • Proxies to the MDCChip#isActionSelected method.

                                                                                                                                                                                                                                                                                                                                                                                                  method removeChipAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  removeChipAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  • Removes the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                  method setChipFocusAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  setChipFocusAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                  action: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                  focus: FocusBehavior
                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  • Proxies to the MDCChip#setActionFocus method.

                                                                                                                                                                                                                                                                                                                                                                                                  method setChipSelectedAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  setChipSelectedAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                  actionType: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                  isSelected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  • Proxies to the MDCChip#setActionSelected method.

                                                                                                                                                                                                                                                                                                                                                                                                  method startChipAnimationAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                  startChipAnimationAtIndex: (index: number, animation: Animation) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  • Starts the chip animation at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                  namespace @material/chips/chip-set/component

                                                                                                                                                                                                                                                                                                                                                                                                  module '@material/chips/chip-set/component' {}

                                                                                                                                                                                                                                                                                                                                                                                                    class MDCChipSet

                                                                                                                                                                                                                                                                                                                                                                                                    class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {}
                                                                                                                                                                                                                                                                                                                                                                                                    • MDCChip provides component encapsulation of the foundation implementation.

                                                                                                                                                                                                                                                                                                                                                                                                    method addChip

                                                                                                                                                                                                                                                                                                                                                                                                    addChip: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                    • Animates the chip addition at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                    method attachTo

                                                                                                                                                                                                                                                                                                                                                                                                    static attachTo: (root: Element) => MDCChipSet;

                                                                                                                                                                                                                                                                                                                                                                                                      method destroy

                                                                                                                                                                                                                                                                                                                                                                                                      destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method getChipIdAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                        getChipIdAtIndex: (index: number) => string;
                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the ID of the chip at the given index or an empty string if the index is out of bounds.

                                                                                                                                                                                                                                                                                                                                                                                                        method getChipIndexByID

                                                                                                                                                                                                                                                                                                                                                                                                        getChipIndexByID: (chipID: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the index of the chip with the given ID or -1 if none exists.

                                                                                                                                                                                                                                                                                                                                                                                                        method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                        getDefaultFoundation: () => MDCChipSetFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                          method getSelectedChipIndexes

                                                                                                                                                                                                                                                                                                                                                                                                          getSelectedChipIndexes: () => ReadonlySet<number>;
                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the unique indexes of the selected chips.

                                                                                                                                                                                                                                                                                                                                                                                                          method initialize

                                                                                                                                                                                                                                                                                                                                                                                                          initialize: (chipFactory?: MDCChipFactory) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                            initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                              method isChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                              isChipSelected: (index: number, action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the selection state of the chip.

                                                                                                                                                                                                                                                                                                                                                                                                              method removeChip

                                                                                                                                                                                                                                                                                                                                                                                                              removeChip: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                              • Removes the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                              method setChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                              setChipSelected: (
                                                                                                                                                                                                                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                                                                                                                                                                                                                              action: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                              isSelected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                              • Sets the selection state of the chip.

                                                                                                                                                                                                                                                                                                                                                                                                              namespace @material/chips/chip-set/constants

                                                                                                                                                                                                                                                                                                                                                                                                              module '@material/chips/chip-set/constants' {}

                                                                                                                                                                                                                                                                                                                                                                                                                enum Attributes

                                                                                                                                                                                                                                                                                                                                                                                                                enum Attributes {
                                                                                                                                                                                                                                                                                                                                                                                                                ARIA_MULTISELECTABLE = 'aria-multiselectable',
                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                • Events provides the named constants for strings used by the foundation.

                                                                                                                                                                                                                                                                                                                                                                                                                member ARIA_MULTISELECTABLE

                                                                                                                                                                                                                                                                                                                                                                                                                ARIA_MULTISELECTABLE = 'aria-multiselectable'

                                                                                                                                                                                                                                                                                                                                                                                                                  enum CssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                  enum CssClasses {
                                                                                                                                                                                                                                                                                                                                                                                                                  CHIP = 'mdc-evolution-chip',
                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                  • CssClasses provides the named constants for class names.

                                                                                                                                                                                                                                                                                                                                                                                                                  member CHIP

                                                                                                                                                                                                                                                                                                                                                                                                                  CHIP = 'mdc-evolution-chip'

                                                                                                                                                                                                                                                                                                                                                                                                                    enum Events

                                                                                                                                                                                                                                                                                                                                                                                                                    enum Events {
                                                                                                                                                                                                                                                                                                                                                                                                                    INTERACTION = 'MDCChipSet:interaction',
                                                                                                                                                                                                                                                                                                                                                                                                                    REMOVAL = 'MDCChipSet:removal',
                                                                                                                                                                                                                                                                                                                                                                                                                    SELECTION = 'MDCChipSet:selection',
                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                    • Events provides the constants for emitted events.

                                                                                                                                                                                                                                                                                                                                                                                                                    member INTERACTION

                                                                                                                                                                                                                                                                                                                                                                                                                    INTERACTION = 'MDCChipSet:interaction'

                                                                                                                                                                                                                                                                                                                                                                                                                      member REMOVAL

                                                                                                                                                                                                                                                                                                                                                                                                                      REMOVAL = 'MDCChipSet:removal'

                                                                                                                                                                                                                                                                                                                                                                                                                        member SELECTION

                                                                                                                                                                                                                                                                                                                                                                                                                        SELECTION = 'MDCChipSet:selection'

                                                                                                                                                                                                                                                                                                                                                                                                                          namespace @material/chips/chip-set/foundation

                                                                                                                                                                                                                                                                                                                                                                                                                          module '@material/chips/chip-set/foundation' {}

                                                                                                                                                                                                                                                                                                                                                                                                                            class MDCChipSetFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                            class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {}
                                                                                                                                                                                                                                                                                                                                                                                                                            • MDCChipSetFoundation provides a foundation for all chips.

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(adapter?: Partial<MDCChipSetAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly defaultAdapter: MDCChipSetAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                method addChip

                                                                                                                                                                                                                                                                                                                                                                                                                                addChip: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getSelectedChipIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                                  getSelectedChipIndexes: () => ReadonlySet<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the unique selected indexes of the chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                  method handleChipAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                  handleChipAnimation: ({ detail }: ChipAnimationEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleChipInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                    handleChipInteraction: ({ detail }: ChipInteractionEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleChipNavigation

                                                                                                                                                                                                                                                                                                                                                                                                                                      handleChipNavigation: ({ detail }: ChipNavigationEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method isChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                        isChipSelected: (index: number, action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the selected state of the chip at the given index and action.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method removeChip

                                                                                                                                                                                                                                                                                                                                                                                                                                        removeChip: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Removes the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method setChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                        setChipSelected: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                        action: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                        isSelected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Sets the selected state of the chip at the given index and action.

                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace @material/chips/chip-set/index

                                                                                                                                                                                                                                                                                                                                                                                                                                        module '@material/chips/chip-set/index' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCChipSet

                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                          • MDCChip provides component encapsulation of the foundation implementation.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method addChip

                                                                                                                                                                                                                                                                                                                                                                                                                                          addChip: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Animates the chip addition at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method attachTo

                                                                                                                                                                                                                                                                                                                                                                                                                                          static attachTo: (root: Element) => MDCChipSet;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                            destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getChipIdAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                              getChipIdAtIndex: (index: number) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the ID of the chip at the given index or an empty string if the index is out of bounds.

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getChipIndexByID

                                                                                                                                                                                                                                                                                                                                                                                                                                              getChipIndexByID: (chipID: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the index of the chip with the given ID or -1 if none exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                              getDefaultFoundation: () => MDCChipSetFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method getSelectedChipIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                getSelectedChipIndexes: () => ReadonlySet<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the unique indexes of the selected chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                method initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                initialize: (chipFactory?: MDCChipFactory) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                                  initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                    isChipSelected: (index: number, action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns the selection state of the chip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method removeChip

                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeChip: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removes the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                    setChipSelected: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    action: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    isSelected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sets the selection state of the chip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class MDCChipSetFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • MDCChipSetFoundation provides a foundation for all chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(adapter?: Partial<MDCChipSetAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly defaultAdapter: MDCChipSetAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method addChip

                                                                                                                                                                                                                                                                                                                                                                                                                                                        addChip: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSelectedChipIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSelectedChipIndexes: () => ReadonlySet<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the unique selected indexes of the chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method handleChipAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                          handleChipAnimation: ({ detail }: ChipAnimationEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method handleChipInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                            handleChipInteraction: ({ detail }: ChipInteractionEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleChipNavigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleChipNavigation: ({ detail }: ChipNavigationEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                isChipSelected: (index: number, action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the selected state of the chip at the given index and action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method removeChip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeChip: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Removes the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setChipSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                setChipSelected: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                action: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                isSelected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Sets the selected state of the chip at the given index and action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCChipSetAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCChipSetAdapter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method announceMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                announceMessage: (message: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Announces the message via an aria-live region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method emitEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                emitEvent: <D extends object>(eventName: Events, eventDetail: D) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emits the given event with the given detail.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                getAttribute: (attrName: Attributes) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the value for the given attribute, if it exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChipActionsAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChipActionsAtIndex: (index: number) => ActionType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the actions provided by the child chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChipCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChipCount: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the number of child chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChipIdAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChipIdAtIndex: (index: number) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the ID of the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChipIndexById

                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChipIndexById: (chipID: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the index of the child chip with the matching ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isChipFocusableAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                isChipFocusableAtIndex: (index: number, actionType: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Proxies to the MDCChip#isActionFocusable method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isChipSelectableAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                isChipSelectableAtIndex: (index: number, actionType: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Proxies to the MDCChip#isActionSelectable method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isChipSelectedAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                isChipSelectedAtIndex: (index: number, actionType: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Proxies to the MDCChip#isActionSelected method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method removeChipAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeChipAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Removes the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setChipFocusAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                setChipFocusAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                action: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                focus: FocusBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Proxies to the MDCChip#setActionFocus method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setChipSelectedAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                setChipSelectedAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                actionType: ActionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                isSelected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Proxies to the MDCChip#setActionSelected method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method startChipAnimationAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                startChipAnimationAtIndex: (index: number, animation: Animation) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Starts the chip animation at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum Attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum Attributes {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ARIA_MULTISELECTABLE = 'aria-multiselectable',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Events provides the named constants for strings used by the foundation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                member ARIA_MULTISELECTABLE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                ARIA_MULTISELECTABLE = 'aria-multiselectable'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum CssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum CssClasses {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CHIP = 'mdc-evolution-chip',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • CssClasses provides the named constants for class names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member CHIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CHIP = 'mdc-evolution-chip'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum Events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum Events {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INTERACTION = 'MDCChipSet:interaction',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    REMOVAL = 'MDCChipSet:removal',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SELECTION = 'MDCChipSet:selection',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Events provides the constants for emitted events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member INTERACTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INTERACTION = 'MDCChipSet:interaction'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member REMOVAL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      REMOVAL = 'MDCChipSet:removal'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member SELECTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SELECTION = 'MDCChipSet:selection'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace @material/chips/chip-set/types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module '@material/chips/chip-set/types' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MDCChipSetInteractionEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MDCChipSetInteractionEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • MDCChipSetInteractionEventDetail provides detail about the interaction event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chipID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chipID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property chipIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              chipIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCChipSetRemovalEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCChipSetRemovalEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • MDCChipSetRemovalEventDetail provides detail about the removal event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property chipID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                chipID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property chipIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  chipIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isComplete: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MDCChipSetSelectionEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MDCChipSetSelectionEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • MDCChipSetSelectionEventDetail provides detail about the selection event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property chipID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      chipID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property chipIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        chipIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isSelected: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChipAnimationEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChipAnimationEvent = CustomEvent<MDCChipAnimationEventDetail>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ChipAnimationEvent is the custom event for the animation event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChipInteractionEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChipInteractionEvent = CustomEvent<MDCChipInteractionEventDetail>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ChipInteractionEvent is the custom event for the interaction event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChipNavigationEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChipNavigationEvent = CustomEvent<MDCChipNavigationEventDetail>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ChipNavigationEvent is the custom event for the navigation event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace @material/chips/chip/adapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module '@material/chips/chip/adapter' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCChipAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCChipAdapter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addClass: (className: CssClasses) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Adds the given class to the root element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method emitEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              emitEvent: <D extends object>(eventName: Events, eventDetail: D) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Emits the given event with the given detail.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getActions: () => ActionType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the child actions provided by the chip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getAttribute: (attrName: Attributes) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the value for the given attribute, if it exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getElementID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getElementID: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the ID of the root element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getOffsetWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getOffsetWidth: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the offset width of the root element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method hasClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasClass: (className: CssClasses) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns true if the root element has the given class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isActionDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isActionDisabled: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#isDisabled method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isActionFocusable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isActionFocusable: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#isFocusable method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isActionSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isActionSelectable: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#isSelectable method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isActionSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isActionSelected: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#isSelected method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isRTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isRTL: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns true if the text direction is right-to-left.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeClass: (className: CssClasses) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Removes the given class from the root element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setActionDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setActionDisabled: (action: ActionType, isDisabled: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#setDisabled method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setActionFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setActionFocus: (action: ActionType, behavior: FocusBehavior) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#setFocus method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setActionSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setActionSelected: (action: ActionType, isSelected: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Proxies to the MDCChipAction#setSelected method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setStyleProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setStyleProperty: (property: string, value: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Sets the style property to the given value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace @material/chips/chip/component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module '@material/chips/chip/component' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class MDCChip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class MDCChip extends MDCComponent<MDCChipFoundation> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • MDCChip provides component encapsulation of the foundation implementation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method attachTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static attachTo: (root: Element) => MDCChip;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getActions: () => ActionType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns the ActionTypes for the encapsulated actions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getDefaultFoundation: () => MDCChipFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getElementID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getElementID: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Returns the ID of the root element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initialize: (actionFactory?: MDCChipActionFactory) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isActionFocusable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isActionFocusable: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the focusability of the action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isActionSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isActionSelectable: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the selectability of the action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isActionSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isActionSelected: (action: ActionType) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the selected state of the action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDisabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            remove: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Exposed to be called by the parent chip set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setActionFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setActionFocus: (action: ActionType, focus: FocusBehavior) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Sets the focus behavior of the action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setActionSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setActionSelected: (action: ActionType, isSelected: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Sets the selected state of the action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setDisabled: (isDisabled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method startAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startAnimation: (animation: Animation) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Starts the animation on the chip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MDCChipFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MDCChipFactory = (el: Element, foundation?: MDCChipFoundation) => MDCChip;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • MDCChipFactory is used by the parent MDCChipSet component to initialize chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace @material/chips/chip/constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module '@material/chips/chip/constants' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum Animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum Animation {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ENTER = 'mdc-evolution-chip-enter',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                EXIT = 'mdc-evolution-chip-exit',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Animation provides the names of runnable animations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member ENTER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ENTER = 'mdc-evolution-chip-enter'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member EXIT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  EXIT = 'mdc-evolution-chip-exit'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum Attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum Attributes {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DATA_REMOVED_ANNOUNCEMENT = 'data-mdc-removed-announcement',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DATA_ADDED_ANNOUNCEMENT = 'data-mdc-added-announcement',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Events provides the named constants for strings used by the foundation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member DATA_ADDED_ANNOUNCEMENT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DATA_ADDED_ANNOUNCEMENT = 'data-mdc-added-announcement'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member DATA_REMOVED_ANNOUNCEMENT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DATA_REMOVED_ANNOUNCEMENT = 'data-mdc-removed-announcement'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CssClasses {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SELECTING = 'mdc-evolution-chip--selecting',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DESELECTING = 'mdc-evolution-chip--deselecting',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SELECTING_WITH_PRIMARY_ICON = 'mdc-evolution-chip--selecting-with-primary-icon',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DESELECTING_WITH_PRIMARY_ICON = 'mdc-evolution-chip--deselecting-with-primary-icon',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DISABLED = 'mdc-evolution-chip--disabled',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ENTER = 'mdc-evolution-chip--enter',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EXIT = 'mdc-evolution-chip--exit',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SELECTED = 'mdc-evolution-chip--selected',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HIDDEN = 'mdc-evolution-chip--hidden',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WITH_PRIMARY_ICON = 'mdc-evolution-chip--with-primary-icon',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • CssClasses provides the named constants for class names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member DESELECTING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DESELECTING = 'mdc-evolution-chip--deselecting'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member DESELECTING_WITH_PRIMARY_ICON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DESELECTING_WITH_PRIMARY_ICON = 'mdc-evolution-chip--deselecting-with-primary-icon'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member DISABLED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DISABLED = 'mdc-evolution-chip--disabled'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member ENTER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ENTER = 'mdc-evolution-chip--enter'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member EXIT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                EXIT = 'mdc-evolution-chip--exit'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member HIDDEN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  HIDDEN = 'mdc-evolution-chip--hidden'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member SELECTED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SELECTED = 'mdc-evolution-chip--selected'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member SELECTING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SELECTING = 'mdc-evolution-chip--selecting'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member SELECTING_WITH_PRIMARY_ICON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SELECTING_WITH_PRIMARY_ICON = 'mdc-evolution-chip--selecting-with-primary-icon'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member WITH_PRIMARY_ICON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WITH_PRIMARY_ICON = 'mdc-evolution-chip--with-primary-icon'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum Events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum Events {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            INTERACTION = 'MDCChip:interaction',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NAVIGATION = 'MDCChip:navigation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ANIMATION = 'MDCChip:animation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Events provides the named constants for emitted events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member ANIMATION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ANIMATION = 'MDCChip:animation'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member INTERACTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              INTERACTION = 'MDCChip:interaction'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member NAVIGATION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NAVIGATION = 'MDCChip:navigation'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace @material/chips/chip/foundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module '@material/chips/chip/foundation' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class MDCChipFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class MDCChipFoundation extends MDCFoundation<MDCChipAdapter> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • MDCChipFoundation provides a foundation for all chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(adapter?: Partial<MDCChipAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly defaultAdapter: MDCChipAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getActions: () => ActionType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getElementID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getElementID: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleActionInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleActionInteraction: ({ detail }: ActionInteractionEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleActionNavigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleActionNavigation: ({ detail }: ActionNavigationEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method handleAnimationEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handleAnimationEnd: (event: AnimationEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleTransitionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handleTransitionEnd: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isActionFocusable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isActionFocusable: (action: ActionType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isActionSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isActionSelectable: (action: ActionType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isActionSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isActionSelected: (action: ActionType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDisabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setActionFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setActionFocus: (action: ActionType, focus: FocusBehavior) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setActionSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setActionSelected: (action: ActionType, isSelected: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setDisabled: (isDisabled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method startAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startAnimation: (animation: Animation) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/chips/chip/types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/chips/chip/types' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCChipAnimationEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCChipAnimationEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • MDCChipAnimationEventDetail provides details for the animation event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property addedAnnouncement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        addedAnnouncement?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation: Animation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chipID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chipID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isComplete: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property removedAnnouncement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removedAnnouncement?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MDCChipInteractionEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MDCChipInteractionEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • MDCChipInteractionEventDetail provides details for the interaction event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property actionID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  actionID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property chipID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    chipID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSelectable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSelected: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property shouldRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shouldRemove: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            source: ActionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCChipNavigationEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCChipNavigationEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • MDCChipNavigationEventDetail provides details for the navigation event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property chipID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              chipID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isRTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isRTL: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source: ActionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ActionInteractionEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ActionInteractionEvent = CustomEvent<MDCChipActionInteractionEventDetail>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • MDCChipActionInteractionEvent is the custom event for the interaction event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ActionNavigationEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ActionNavigationEvent = CustomEvent<MDCChipActionNavigationEventDetail>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • MDCChipActionInteractionEvent is the custom event for the interaction event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/chips/deprecated/chip-set/adapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/chips/deprecated/chip-set/adapter' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCChipSetAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCChipSetAdapter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method announceMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        announceMessage: (message: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Announces the message via an aria-live region.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method focusChipPrimaryActionAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        focusChipPrimaryActionAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Calls Chip#focusPrimaryAction() on the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          the index of the chip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method focusChipTrailingActionAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        focusChipTrailingActionAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Calls Chip#focusTrailingAction() on the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          the index of the chip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getChipListCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getChipListCount: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • the number of chips in the chip set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getIndexOfChipById

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getIndexOfChipById: (chipId: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the index of the chip at the given ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter chipId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          the unique ID of the chip the numerical index of the chip with the matching id or -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method hasClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasClass: (className: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • true if the root element contains the given class name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isRTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isRTL: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • true if the text direction is RTL.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method removeChipAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeChipAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Removes the chip with the given index from the chip set. Make sure to remove it from the chip list, too.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method removeFocusFromChipAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeFocusFromChipAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Removes focus from the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          the index of the chip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method selectChipAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selectChipAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSelected: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        shouldNotifyClients: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Sets the selected state of the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace @material/chips/deprecated/chip-set/component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module '@material/chips/deprecated/chip-set/component' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCChipSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chips

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly chips: readonly MDCChip[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property selectedChipIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly selectedChipIds: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • An array of the IDs of all selected chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addChip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addChip: (chipEl: Element) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Adds a new chip object to the chip set from the given chip element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method attachTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static attachTo: (root: Element) => MDCChipSet;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDefaultFoundation: () => MDCChipSetFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialize: (chipFactory?: MDCChipFactory) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parameter chipFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function which creates a new MDCChip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/chips/deprecated/chip-set/constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/chips/deprecated/chip-set/constants' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const cssClasses: { CHOICE: string; FILTER: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const strings: { CHIP_SELECTOR: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace @material/chips/deprecated/chip-set/foundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module '@material/chips/deprecated/chip-set/foundation' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class MDCChipSetFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(adapter?: Partial<MDCChipSetAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly cssClasses: { CHOICE: string; FILTER: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly defaultAdapter: MDCChipSetAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly strings: { CHIP_SELECTOR: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getSelectedChipIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getSelectedChipIds: () => ReadonlyArray<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Returns an array of the IDs of all selected chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleChipInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleChipInteraction: ({ chipId }: MDCChipInteractionEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Handles a chip interaction event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleChipNavigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleChipNavigation: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      chipId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }: MDCChipNavigationEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Handles a chip navigation event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleChipRemoval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleChipRemoval: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      chipId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removedAnnouncement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }: MDCChipRemovalEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Handles the event when a chip is removed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleChipSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleChipSelection: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      chipId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selected,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shouldIgnore,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }: MDCChipSelectionEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Handles a chip selection event, used to handle discrepancy when selection state is set directly on the Chip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      select: (chipId: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Selects the chip with the given id. Deselects all other chips if the chip set is of the choice variant. Does not notify clients of the updated selection state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/chips/deprecated/chip-set/index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/chips/deprecated/chip-set/index' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable chipSetCssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const chipSetCssClasses: { CHOICE: string; FILTER: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable chipSetStrings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const chipSetStrings: { CHIP_SELECTOR: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCChipSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chips

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly chips: readonly MDCChip[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property selectedChipIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly selectedChipIds: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • An array of the IDs of all selected chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addChip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addChip: (chipEl: Element) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Adds a new chip object to the chip set from the given chip element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method attachTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static attachTo: (root: Element) => MDCChipSet;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDefaultFoundation: () => MDCChipSetFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialize: (chipFactory?: MDCChipFactory) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parameter chipFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function which creates a new MDCChip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class MDCChipSetFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(adapter?: Partial<MDCChipSetAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly cssClasses: { CHOICE: string; FILTER: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly defaultAdapter: MDCChipSetAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly strings: { CHIP_SELECTOR: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getSelectedChipIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getSelectedChipIds: () => ReadonlyArray<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns an array of the IDs of all selected chips.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleChipInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleChipInteraction: ({ chipId }: MDCChipInteractionEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Handles a chip interaction event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleChipNavigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleChipNavigation: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                chipId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                source,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }: MDCChipNavigationEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Handles a chip navigation event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleChipRemoval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleChipRemoval: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                chipId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removedAnnouncement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }: MDCChipRemovalEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Handles the event when a chip is removed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleChipSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleChipSelection: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                chipId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selected,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                shouldIgnore,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }: MDCChipSelectionEventDetail) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Handles a chip selection event, used to handle discrepancy when selection state is set directly on the Chip.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                select: (chipId: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Selects the chip with the given id. Deselects all other chips if the chip set is of the choice variant. Does not notify clients of the updated selection state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCChipSetAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCChipSetAdapter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method announceMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                announceMessage: (message: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Announces the message via an aria-live region.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method focusChipPrimaryActionAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                focusChipPrimaryActionAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Calls Chip#focusPrimaryAction() on the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  the index of the chip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method focusChipTrailingActionAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                focusChipTrailingActionAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Calls Chip#focusTrailingAction() on the chip at the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  the index of the chip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChipListCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChipListCount: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • the number of chips in the chip set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getIndexOfChipById

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getIndexOfChipById: (chipId: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the index of the chip at the given ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter chipId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  the unique ID of the chip the numerical index of the chip with the matching id or -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method hasClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hasClass: (className: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the root element contains the given class name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isRTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isRTL: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true if the text direction is RTL.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method removeChipAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeChipAtIndex: (index: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Removes the chip with the given index from the chip set. Make sure to remove it from the chip list, too.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method