Logo for jsDocs.io

@material/tabs

  • Version 2.3.0
  • Published
  • 1 MB
  • 7 dependencies
  • MIT license

Install

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

Overview

The Material Components for the web tabs component

Index

Namespaces

Namespaces

namespace @material/tabs

module '@material/tabs' {}

    variable tabBarCssClasses

    const tabBarCssClasses: { UPGRADED: string };

    • Copyright 2017 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 tabBarScrollerCssClasses

    const tabBarScrollerCssClasses: {
        INDICATOR_BACK: string;
        INDICATOR_ENABLED: string;
        INDICATOR_FORWARD: string;
        TAB: string;
    };

    • Copyright 2017 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 tabBarScrollerStrings

    const tabBarScrollerStrings: {
        FRAME_SELECTOR: string;
        INDICATOR_BACK_SELECTOR: string;
        INDICATOR_FORWARD_SELECTOR: string;
        TABS_SELECTOR: string;
        TAB_SELECTOR: string;
    };

      variable tabBarStrings

      const tabBarStrings: {
          CHANGE_EVENT: string;
          INDICATOR_SELECTOR: string;
          TAB_SELECTOR: string;
      };

        variable tabCssClasses

        const tabCssClasses: { ACTIVE: string };

        • Copyright 2017 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 tabStrings

        const tabStrings: { SELECTED_EVENT: string };

          class MDCTab

          class MDCTab extends MDCComponent<MDCTabFoundation> {}

            property computedLeft

            readonly computedLeft: number;

              property computedWidth

              readonly computedWidth: number;

                property isActive

                isActive: boolean;

                  property preventDefaultOnClick

                  preventDefaultOnClick: boolean;

                    property root_

                    protected root_: HTMLElement;

                      method attachTo

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

                        method destroy

                        destroy: () => void;

                          method getDefaultFoundation

                          getDefaultFoundation: () => MDCTabFoundation;

                            method initialSyncWithDOM

                            initialSyncWithDOM: () => void;

                              method measureSelf

                              measureSelf: () => void;

                                class MDCTabBar

                                class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {}

                                  property activeTab

                                  activeTab: MDCTab;

                                    property activeTabIndex

                                    activeTabIndex: number;

                                      property root_

                                      protected root_: HTMLElement;

                                        property tabs

                                        readonly tabs: MDCTab[];

                                          method attachTo

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

                                            method getDefaultFoundation

                                            getDefaultFoundation: () => MDCTabBarFoundation;

                                              method initialize

                                              initialize: (tabFactory?: MDCTabFactory) => void;

                                                method layout

                                                layout: () => void;

                                                  class MDCTabBarFoundation

                                                  class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {}

                                                    constructor

                                                    constructor(adapter?: Partial<MDCTabBarAdapter>);

                                                      property cssClasses

                                                      static readonly cssClasses: { UPGRADED: string };

                                                        property defaultAdapter

                                                        static readonly defaultAdapter: MDCTabBarAdapter;

                                                          property strings

                                                          static readonly strings: {
                                                              CHANGE_EVENT: string;
                                                              INDICATOR_SELECTOR: string;
                                                              TAB_SELECTOR: string;
                                                          };

                                                            method destroy

                                                            destroy: () => void;

                                                              method getActiveTabIndex

                                                              getActiveTabIndex: () => number;

                                                                method init

                                                                init: () => void;

                                                                  method layout

                                                                  layout: () => void;

                                                                    method switchToTabAtIndex

                                                                    switchToTabAtIndex: (index: number, shouldNotify: boolean) => void;

                                                                      class MDCTabBarScroller

                                                                      class MDCTabBarScroller extends MDCComponent<MDCTabBarScrollerFoundation> {}

                                                                        property root_

                                                                        protected root_: HTMLElement;

                                                                          property tabBar

                                                                          readonly tabBar: MDCTabBar;

                                                                            method attachTo

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

                                                                              method getDefaultFoundation

                                                                              getDefaultFoundation: () => MDCTabBarScrollerFoundation;

                                                                                method initialize

                                                                                initialize: (tabBarFactory?: MDCTabBarFactory) => void;

                                                                                  method layout

                                                                                  layout: () => void;

                                                                                    class MDCTabBarScrollerFoundation

                                                                                    class MDCTabBarScrollerFoundation extends MDCFoundation<MDCTabBarScrollerAdapter> {}

                                                                                      constructor

                                                                                      constructor(adapter?: Partial<MDCTabBarScrollerAdapter>);

                                                                                        property cssClasses

                                                                                        static readonly cssClasses: {
                                                                                            INDICATOR_BACK: string;
                                                                                            INDICATOR_ENABLED: string;
                                                                                            INDICATOR_FORWARD: string;
                                                                                            TAB: string;
                                                                                        };

                                                                                          property defaultAdapter

                                                                                          static readonly defaultAdapter: MDCTabBarScrollerAdapter;

                                                                                            property strings

                                                                                            static readonly strings: {
                                                                                                FRAME_SELECTOR: string;
                                                                                                INDICATOR_BACK_SELECTOR: string;
                                                                                                INDICATOR_FORWARD_SELECTOR: string;
                                                                                                TABS_SELECTOR: string;
                                                                                                TAB_SELECTOR: string;
                                                                                            };

                                                                                              method destroy

                                                                                              destroy: () => void;

                                                                                                method init

                                                                                                init: () => void;

                                                                                                  method layout

                                                                                                  layout: () => void;

                                                                                                    method scrollBack

                                                                                                    scrollBack: (evt?: MouseEvent) => void;

                                                                                                      method scrollForward

                                                                                                      scrollForward: (evt?: MouseEvent) => void;

                                                                                                        method scrollToTabAtIndex

                                                                                                        scrollToTabAtIndex: (index: number) => void;

                                                                                                          class MDCTabFoundation

                                                                                                          class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {}

                                                                                                            constructor

                                                                                                            constructor(adapter?: Partial<MDCTabAdapter>);

                                                                                                              property cssClasses

                                                                                                              static readonly cssClasses: { ACTIVE: string };

                                                                                                                property defaultAdapter

                                                                                                                static readonly defaultAdapter: MDCTabAdapter;

                                                                                                                  property strings

                                                                                                                  static readonly strings: { SELECTED_EVENT: string };

                                                                                                                    method destroy

                                                                                                                    destroy: () => void;

                                                                                                                      method getComputedLeft

                                                                                                                      getComputedLeft: () => number;

                                                                                                                        method getComputedWidth

                                                                                                                        getComputedWidth: () => number;

                                                                                                                          method init

                                                                                                                          init: () => void;

                                                                                                                            method isActive

                                                                                                                            isActive: () => boolean;

                                                                                                                              method measureSelf

                                                                                                                              measureSelf: () => void;

                                                                                                                                method preventsDefaultOnClick

                                                                                                                                preventsDefaultOnClick: () => boolean;

                                                                                                                                  method setActive

                                                                                                                                  setActive: (isActive: boolean) => void;

                                                                                                                                    method setPreventDefaultOnClick

                                                                                                                                    setPreventDefaultOnClick: (preventDefaultOnClick: boolean) => void;

                                                                                                                                      interface MDCTabAdapter

                                                                                                                                      interface MDCTabAdapter {}

                                                                                                                                        property addClass

                                                                                                                                        addClass: (className: string) => void;

                                                                                                                                          property deregisterInteractionHandler

                                                                                                                                          deregisterInteractionHandler: <K extends EventType>(
                                                                                                                                              type: K,
                                                                                                                                              handler: SpecificEventListener<K>
                                                                                                                                          ) => void;

                                                                                                                                            property getOffsetLeft

                                                                                                                                            getOffsetLeft: () => number;

                                                                                                                                              property getOffsetWidth

                                                                                                                                              getOffsetWidth: () => number;

                                                                                                                                                property notifySelected

                                                                                                                                                notifySelected: () => void;

                                                                                                                                                  property registerInteractionHandler

                                                                                                                                                  registerInteractionHandler: <K extends EventType>(
                                                                                                                                                      type: K,
                                                                                                                                                      handler: SpecificEventListener<K>
                                                                                                                                                  ) => void;

                                                                                                                                                    property removeClass

                                                                                                                                                    removeClass: (className: string) => void;

                                                                                                                                                      interface MDCTabBarAdapter

                                                                                                                                                      interface MDCTabBarAdapter {}

                                                                                                                                                        property addClass

                                                                                                                                                        addClass: (className: string) => void;

                                                                                                                                                          property bindOnMDCTabSelectedEvent

                                                                                                                                                          bindOnMDCTabSelectedEvent: () => void;

                                                                                                                                                            property deregisterResizeHandler

                                                                                                                                                            deregisterResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                              property getComputedLeftForTabAtIndex

                                                                                                                                                              getComputedLeftForTabAtIndex: (index: number) => number;

                                                                                                                                                                property getComputedWidthForTabAtIndex

                                                                                                                                                                getComputedWidthForTabAtIndex: (index: number) => number;

                                                                                                                                                                  property getNumberOfTabs

                                                                                                                                                                  getNumberOfTabs: () => number;

                                                                                                                                                                    property getOffsetWidth

                                                                                                                                                                    getOffsetWidth: () => number;

                                                                                                                                                                      property getOffsetWidthForIndicator

                                                                                                                                                                      getOffsetWidthForIndicator: () => number;

                                                                                                                                                                        property isDefaultPreventedOnClickForTabAtIndex

                                                                                                                                                                        isDefaultPreventedOnClickForTabAtIndex: (index: number) => boolean;

                                                                                                                                                                          property isTabActiveAtIndex

                                                                                                                                                                          isTabActiveAtIndex: (index: number) => boolean;

                                                                                                                                                                            property measureTabAtIndex

                                                                                                                                                                            measureTabAtIndex: (index: number) => void;

                                                                                                                                                                              property notifyChange

                                                                                                                                                                              notifyChange: (evtData: MDCTabBarChangeEventDetail) => void;

                                                                                                                                                                                property registerResizeHandler

                                                                                                                                                                                registerResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                  property removeClass

                                                                                                                                                                                  removeClass: (className: string) => void;

                                                                                                                                                                                    property setPreventDefaultOnClickForTabAtIndex

                                                                                                                                                                                    setPreventDefaultOnClickForTabAtIndex: (
                                                                                                                                                                                        index: number,
                                                                                                                                                                                        preventDefaultOnClick: boolean
                                                                                                                                                                                    ) => void;

                                                                                                                                                                                      property setStyleForIndicator

                                                                                                                                                                                      setStyleForIndicator: (propertyName: string, value: string) => void;

                                                                                                                                                                                        property setTabActiveAtIndex

                                                                                                                                                                                        setTabActiveAtIndex: (index: number, isActive: boolean) => void;

                                                                                                                                                                                          property unbindOnMDCTabSelectedEvent

                                                                                                                                                                                          unbindOnMDCTabSelectedEvent: () => void;

                                                                                                                                                                                            interface MDCTabBarChangeEvent

                                                                                                                                                                                            interface MDCTabBarChangeEvent extends Event {}

                                                                                                                                                                                              property detail

                                                                                                                                                                                              readonly detail: MDCTabBarChangeEventDetail;

                                                                                                                                                                                                interface MDCTabBarChangeEventDetail

                                                                                                                                                                                                interface MDCTabBarChangeEventDetail {}

                                                                                                                                                                                                • Copyright 2019 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.

                                                                                                                                                                                                property activeTabIndex

                                                                                                                                                                                                activeTabIndex: number;

                                                                                                                                                                                                  interface MDCTabBarScrollerAdapter

                                                                                                                                                                                                  interface MDCTabBarScrollerAdapter {}

                                                                                                                                                                                                    property addClass

                                                                                                                                                                                                    addClass: (className: string) => void;

                                                                                                                                                                                                      property addClassToBackIndicator

                                                                                                                                                                                                      addClassToBackIndicator: (className: string) => void;

                                                                                                                                                                                                        property addClassToForwardIndicator

                                                                                                                                                                                                        addClassToForwardIndicator: (className: string) => void;

                                                                                                                                                                                                          property deregisterBackIndicatorClickHandler

                                                                                                                                                                                                          deregisterBackIndicatorClickHandler: (
                                                                                                                                                                                                              handler: SpecificEventListener<'click'>
                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                            property deregisterCapturedInteractionHandler

                                                                                                                                                                                                            deregisterCapturedInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                evt: K,
                                                                                                                                                                                                                handler: SpecificEventListener<K>
                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                              property deregisterForwardIndicatorClickHandler

                                                                                                                                                                                                              deregisterForwardIndicatorClickHandler: (
                                                                                                                                                                                                                  handler: SpecificEventListener<'click'>
                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                property deregisterWindowResizeHandler

                                                                                                                                                                                                                deregisterWindowResizeHandler: (
                                                                                                                                                                                                                    handler: SpecificEventListener<'resize'>
                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                  property eventTargetHasClass

                                                                                                                                                                                                                  eventTargetHasClass: (target: Element, className: string) => boolean;

                                                                                                                                                                                                                    property getComputedLeftForTabAtIndex

                                                                                                                                                                                                                    getComputedLeftForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                      property getComputedWidthForTabAtIndex

                                                                                                                                                                                                                      getComputedWidthForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                        property getNumberOfTabs

                                                                                                                                                                                                                        getNumberOfTabs: () => number;

                                                                                                                                                                                                                          property getOffsetLeftForEventTarget

                                                                                                                                                                                                                          getOffsetLeftForEventTarget: (target: HTMLElement) => number;

                                                                                                                                                                                                                            property getOffsetWidthForEventTarget

                                                                                                                                                                                                                            getOffsetWidthForEventTarget: (target: HTMLElement) => number;

                                                                                                                                                                                                                              property getOffsetWidthForScrollFrame

                                                                                                                                                                                                                              getOffsetWidthForScrollFrame: () => number;

                                                                                                                                                                                                                                property getOffsetWidthForTabBar

                                                                                                                                                                                                                                getOffsetWidthForTabBar: () => number;

                                                                                                                                                                                                                                  property getScrollLeftForScrollFrame

                                                                                                                                                                                                                                  getScrollLeftForScrollFrame: () => number;

                                                                                                                                                                                                                                    property isRTL

                                                                                                                                                                                                                                    isRTL: () => boolean;

                                                                                                                                                                                                                                      property registerBackIndicatorClickHandler

                                                                                                                                                                                                                                      registerBackIndicatorClickHandler: (
                                                                                                                                                                                                                                          handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                        property registerCapturedInteractionHandler

                                                                                                                                                                                                                                        registerCapturedInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                            evt: K,
                                                                                                                                                                                                                                            handler: SpecificEventListener<K>
                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                          property registerForwardIndicatorClickHandler

                                                                                                                                                                                                                                          registerForwardIndicatorClickHandler: (
                                                                                                                                                                                                                                              handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                            property registerWindowResizeHandler

                                                                                                                                                                                                                                            registerWindowResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                              property removeClass

                                                                                                                                                                                                                                              removeClass: (className: string) => void;

                                                                                                                                                                                                                                                property removeClassFromBackIndicator

                                                                                                                                                                                                                                                removeClassFromBackIndicator: (className: string) => void;

                                                                                                                                                                                                                                                  property removeClassFromForwardIndicator

                                                                                                                                                                                                                                                  removeClassFromForwardIndicator: (className: string) => void;

                                                                                                                                                                                                                                                    property setScrollLeftForScrollFrame

                                                                                                                                                                                                                                                    setScrollLeftForScrollFrame: (scrollLeftAmount: number) => void;

                                                                                                                                                                                                                                                      property setTransformStyleForTabBar

                                                                                                                                                                                                                                                      setTransformStyleForTabBar: (value: string) => void;

                                                                                                                                                                                                                                                        interface MDCTabSelectedEvent

                                                                                                                                                                                                                                                        interface MDCTabSelectedEvent extends Event {}

                                                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                                                          readonly detail: MDCTabSelectedEventDetail;

                                                                                                                                                                                                                                                            interface MDCTabSelectedEventDetail

                                                                                                                                                                                                                                                            interface MDCTabSelectedEventDetail {}

                                                                                                                                                                                                                                                              property tab

                                                                                                                                                                                                                                                              tab: MDCTab;

                                                                                                                                                                                                                                                                type MDCTabBarFactory

                                                                                                                                                                                                                                                                type MDCTabBarFactory = (el: Element, foundation?: MDCTabBarFoundation) => MDCTabBar;

                                                                                                                                                                                                                                                                  type MDCTabFactory

                                                                                                                                                                                                                                                                  type MDCTabFactory = (el: Element, foundation?: MDCTabFoundation) => MDCTab;

                                                                                                                                                                                                                                                                    namespace @material/tabs/tab-bar-scroller/adapter

                                                                                                                                                                                                                                                                    module '@material/tabs/tab-bar-scroller/adapter' {}

                                                                                                                                                                                                                                                                      interface MDCTabBarScrollerAdapter

                                                                                                                                                                                                                                                                      interface MDCTabBarScrollerAdapter {}

                                                                                                                                                                                                                                                                        property addClass

                                                                                                                                                                                                                                                                        addClass: (className: string) => void;

                                                                                                                                                                                                                                                                          property addClassToBackIndicator

                                                                                                                                                                                                                                                                          addClassToBackIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                            property addClassToForwardIndicator

                                                                                                                                                                                                                                                                            addClassToForwardIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                              property deregisterBackIndicatorClickHandler

                                                                                                                                                                                                                                                                              deregisterBackIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                  handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                property deregisterCapturedInteractionHandler

                                                                                                                                                                                                                                                                                deregisterCapturedInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                    evt: K,
                                                                                                                                                                                                                                                                                    handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                  property deregisterForwardIndicatorClickHandler

                                                                                                                                                                                                                                                                                  deregisterForwardIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                      handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                    property deregisterWindowResizeHandler

                                                                                                                                                                                                                                                                                    deregisterWindowResizeHandler: (
                                                                                                                                                                                                                                                                                        handler: SpecificEventListener<'resize'>
                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                      property eventTargetHasClass

                                                                                                                                                                                                                                                                                      eventTargetHasClass: (target: Element, className: string) => boolean;

                                                                                                                                                                                                                                                                                        property getComputedLeftForTabAtIndex

                                                                                                                                                                                                                                                                                        getComputedLeftForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                          property getComputedWidthForTabAtIndex

                                                                                                                                                                                                                                                                                          getComputedWidthForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                            property getNumberOfTabs

                                                                                                                                                                                                                                                                                            getNumberOfTabs: () => number;

                                                                                                                                                                                                                                                                                              property getOffsetLeftForEventTarget

                                                                                                                                                                                                                                                                                              getOffsetLeftForEventTarget: (target: HTMLElement) => number;

                                                                                                                                                                                                                                                                                                property getOffsetWidthForEventTarget

                                                                                                                                                                                                                                                                                                getOffsetWidthForEventTarget: (target: HTMLElement) => number;

                                                                                                                                                                                                                                                                                                  property getOffsetWidthForScrollFrame

                                                                                                                                                                                                                                                                                                  getOffsetWidthForScrollFrame: () => number;

                                                                                                                                                                                                                                                                                                    property getOffsetWidthForTabBar

                                                                                                                                                                                                                                                                                                    getOffsetWidthForTabBar: () => number;

                                                                                                                                                                                                                                                                                                      property getScrollLeftForScrollFrame

                                                                                                                                                                                                                                                                                                      getScrollLeftForScrollFrame: () => number;

                                                                                                                                                                                                                                                                                                        property isRTL

                                                                                                                                                                                                                                                                                                        isRTL: () => boolean;

                                                                                                                                                                                                                                                                                                          property registerBackIndicatorClickHandler

                                                                                                                                                                                                                                                                                                          registerBackIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                                              handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                            property registerCapturedInteractionHandler

                                                                                                                                                                                                                                                                                                            registerCapturedInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                evt: K,
                                                                                                                                                                                                                                                                                                                handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                              property registerForwardIndicatorClickHandler

                                                                                                                                                                                                                                                                                                              registerForwardIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                                                  handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                property registerWindowResizeHandler

                                                                                                                                                                                                                                                                                                                registerWindowResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                                                                                                  property removeClass

                                                                                                                                                                                                                                                                                                                  removeClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                    property removeClassFromBackIndicator

                                                                                                                                                                                                                                                                                                                    removeClassFromBackIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                                                                      property removeClassFromForwardIndicator

                                                                                                                                                                                                                                                                                                                      removeClassFromForwardIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                                                                        property setScrollLeftForScrollFrame

                                                                                                                                                                                                                                                                                                                        setScrollLeftForScrollFrame: (scrollLeftAmount: number) => void;

                                                                                                                                                                                                                                                                                                                          property setTransformStyleForTabBar

                                                                                                                                                                                                                                                                                                                          setTransformStyleForTabBar: (value: string) => void;

                                                                                                                                                                                                                                                                                                                            namespace @material/tabs/tab-bar-scroller/component

                                                                                                                                                                                                                                                                                                                            module '@material/tabs/tab-bar-scroller/component' {}

                                                                                                                                                                                                                                                                                                                              class MDCTabBarScroller

                                                                                                                                                                                                                                                                                                                              class MDCTabBarScroller extends MDCComponent<MDCTabBarScrollerFoundation> {}

                                                                                                                                                                                                                                                                                                                                property root_

                                                                                                                                                                                                                                                                                                                                protected root_: HTMLElement;

                                                                                                                                                                                                                                                                                                                                  property tabBar

                                                                                                                                                                                                                                                                                                                                  readonly tabBar: MDCTabBar;

                                                                                                                                                                                                                                                                                                                                    method attachTo

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

                                                                                                                                                                                                                                                                                                                                      method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                      getDefaultFoundation: () => MDCTabBarScrollerFoundation;

                                                                                                                                                                                                                                                                                                                                        method initialize

                                                                                                                                                                                                                                                                                                                                        initialize: (tabBarFactory?: MDCTabBarFactory) => void;

                                                                                                                                                                                                                                                                                                                                          method layout

                                                                                                                                                                                                                                                                                                                                          layout: () => void;

                                                                                                                                                                                                                                                                                                                                            namespace @material/tabs/tab-bar-scroller/constants

                                                                                                                                                                                                                                                                                                                                            module '@material/tabs/tab-bar-scroller/constants' {}

                                                                                                                                                                                                                                                                                                                                              variable cssClasses

                                                                                                                                                                                                                                                                                                                                              const cssClasses: {
                                                                                                                                                                                                                                                                                                                                                  INDICATOR_BACK: string;
                                                                                                                                                                                                                                                                                                                                                  INDICATOR_ENABLED: string;
                                                                                                                                                                                                                                                                                                                                                  INDICATOR_FORWARD: string;
                                                                                                                                                                                                                                                                                                                                                  TAB: string;
                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                              • Copyright 2017 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 strings

                                                                                                                                                                                                                                                                                                                                              const strings: {
                                                                                                                                                                                                                                                                                                                                                  FRAME_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                  INDICATOR_BACK_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                  INDICATOR_FORWARD_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                  TABS_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                  TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                namespace @material/tabs/tab-bar-scroller/foundation

                                                                                                                                                                                                                                                                                                                                                module '@material/tabs/tab-bar-scroller/foundation' {}

                                                                                                                                                                                                                                                                                                                                                  class MDCTabBarScrollerFoundation

                                                                                                                                                                                                                                                                                                                                                  class MDCTabBarScrollerFoundation extends MDCFoundation<MDCTabBarScrollerAdapter> {}

                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                    constructor(adapter?: Partial<MDCTabBarScrollerAdapter>);

                                                                                                                                                                                                                                                                                                                                                      property cssClasses

                                                                                                                                                                                                                                                                                                                                                      static readonly cssClasses: {
                                                                                                                                                                                                                                                                                                                                                          INDICATOR_BACK: string;
                                                                                                                                                                                                                                                                                                                                                          INDICATOR_ENABLED: string;
                                                                                                                                                                                                                                                                                                                                                          INDICATOR_FORWARD: string;
                                                                                                                                                                                                                                                                                                                                                          TAB: string;
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                        static readonly defaultAdapter: MDCTabBarScrollerAdapter;

                                                                                                                                                                                                                                                                                                                                                          property strings

                                                                                                                                                                                                                                                                                                                                                          static readonly strings: {
                                                                                                                                                                                                                                                                                                                                                              FRAME_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                              INDICATOR_BACK_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                              INDICATOR_FORWARD_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                              TABS_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                              TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                            method destroy

                                                                                                                                                                                                                                                                                                                                                            destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                              method init

                                                                                                                                                                                                                                                                                                                                                              init: () => void;

                                                                                                                                                                                                                                                                                                                                                                method layout

                                                                                                                                                                                                                                                                                                                                                                layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                  method scrollBack

                                                                                                                                                                                                                                                                                                                                                                  scrollBack: (evt?: MouseEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                    method scrollForward

                                                                                                                                                                                                                                                                                                                                                                    scrollForward: (evt?: MouseEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                      method scrollToTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                      scrollToTabAtIndex: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                        namespace @material/tabs/tab-bar-scroller/index

                                                                                                                                                                                                                                                                                                                                                                        module '@material/tabs/tab-bar-scroller/index' {}

                                                                                                                                                                                                                                                                                                                                                                          variable tabBarScrollerCssClasses

                                                                                                                                                                                                                                                                                                                                                                          const tabBarScrollerCssClasses: {
                                                                                                                                                                                                                                                                                                                                                                              INDICATOR_BACK: string;
                                                                                                                                                                                                                                                                                                                                                                              INDICATOR_ENABLED: string;
                                                                                                                                                                                                                                                                                                                                                                              INDICATOR_FORWARD: string;
                                                                                                                                                                                                                                                                                                                                                                              TAB: string;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                          • Copyright 2017 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 tabBarScrollerStrings

                                                                                                                                                                                                                                                                                                                                                                          const tabBarScrollerStrings: {
                                                                                                                                                                                                                                                                                                                                                                              FRAME_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                              INDICATOR_BACK_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                              INDICATOR_FORWARD_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                              TABS_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                              TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                            class MDCTabBarScroller

                                                                                                                                                                                                                                                                                                                                                                            class MDCTabBarScroller extends MDCComponent<MDCTabBarScrollerFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                              property root_

                                                                                                                                                                                                                                                                                                                                                                              protected root_: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                property tabBar

                                                                                                                                                                                                                                                                                                                                                                                readonly tabBar: MDCTabBar;

                                                                                                                                                                                                                                                                                                                                                                                  method attachTo

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

                                                                                                                                                                                                                                                                                                                                                                                    method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                    getDefaultFoundation: () => MDCTabBarScrollerFoundation;

                                                                                                                                                                                                                                                                                                                                                                                      method initialize

                                                                                                                                                                                                                                                                                                                                                                                      initialize: (tabBarFactory?: MDCTabBarFactory) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method layout

                                                                                                                                                                                                                                                                                                                                                                                        layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                                          class MDCTabBarScrollerFoundation

                                                                                                                                                                                                                                                                                                                                                                                          class MDCTabBarScrollerFoundation extends MDCFoundation<MDCTabBarScrollerAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                            constructor(adapter?: Partial<MDCTabBarScrollerAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                              property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                              static readonly cssClasses: {
                                                                                                                                                                                                                                                                                                                                                                                                  INDICATOR_BACK: string;
                                                                                                                                                                                                                                                                                                                                                                                                  INDICATOR_ENABLED: string;
                                                                                                                                                                                                                                                                                                                                                                                                  INDICATOR_FORWARD: string;
                                                                                                                                                                                                                                                                                                                                                                                                  TAB: string;
                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                static readonly defaultAdapter: MDCTabBarScrollerAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                  property strings

                                                                                                                                                                                                                                                                                                                                                                                                  static readonly strings: {
                                                                                                                                                                                                                                                                                                                                                                                                      FRAME_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                      INDICATOR_BACK_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                      INDICATOR_FORWARD_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                      TABS_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                      TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                    method destroy

                                                                                                                                                                                                                                                                                                                                                                                                    destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method init

                                                                                                                                                                                                                                                                                                                                                                                                      init: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method layout

                                                                                                                                                                                                                                                                                                                                                                                                        layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method scrollBack

                                                                                                                                                                                                                                                                                                                                                                                                          scrollBack: (evt?: MouseEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method scrollForward

                                                                                                                                                                                                                                                                                                                                                                                                            scrollForward: (evt?: MouseEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              method scrollToTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                              scrollToTabAtIndex: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCTabBarScrollerAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCTabBarScrollerAdapter {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property addClass

                                                                                                                                                                                                                                                                                                                                                                                                                  addClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    property addClassToBackIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                    addClassToBackIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      property addClassToForwardIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                      addClassToForwardIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        property deregisterBackIndicatorClickHandler

                                                                                                                                                                                                                                                                                                                                                                                                                        deregisterBackIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                            handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          property deregisterCapturedInteractionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                          deregisterCapturedInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                                                                                                                              evt: K,
                                                                                                                                                                                                                                                                                                                                                                                                                              handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            property deregisterForwardIndicatorClickHandler

                                                                                                                                                                                                                                                                                                                                                                                                                            deregisterForwardIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              property deregisterWindowResizeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                              deregisterWindowResizeHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  handler: SpecificEventListener<'resize'>
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                property eventTargetHasClass

                                                                                                                                                                                                                                                                                                                                                                                                                                eventTargetHasClass: (target: Element, className: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property getComputedLeftForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                  getComputedLeftForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property getComputedWidthForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                    getComputedWidthForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property getNumberOfTabs

                                                                                                                                                                                                                                                                                                                                                                                                                                      getNumberOfTabs: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property getOffsetLeftForEventTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                        getOffsetLeftForEventTarget: (target: HTMLElement) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property getOffsetWidthForEventTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                          getOffsetWidthForEventTarget: (target: HTMLElement) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property getOffsetWidthForScrollFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                            getOffsetWidthForScrollFrame: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property getOffsetWidthForTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                              getOffsetWidthForTabBar: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property getScrollLeftForScrollFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                getScrollLeftForScrollFrame: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isRTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                  isRTL: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property registerBackIndicatorClickHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                    registerBackIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property registerCapturedInteractionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                      registerCapturedInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                          evt: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property registerForwardIndicatorClickHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                        registerForwardIndicatorClickHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler: SpecificEventListener<'click'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property registerWindowResizeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                          registerWindowResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                            removeClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property removeClassFromBackIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeClassFromBackIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property removeClassFromForwardIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeClassFromForwardIndicator: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property setScrollLeftForScrollFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setScrollLeftForScrollFrame: (scrollLeftAmount: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property setTransformStyleForTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setTransformStyleForTabBar: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/tabs/tab-bar/adapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/tabs/tab-bar/adapter' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabBarAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabBarAdapter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bindOnMDCTabSelectedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bindOnMDCTabSelectedEvent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property deregisterResizeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deregisterResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getComputedLeftForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getComputedLeftForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getComputedWidthForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getComputedWidthForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property getNumberOfTabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getNumberOfTabs: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getOffsetWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getOffsetWidth: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getOffsetWidthForIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getOffsetWidthForIndicator: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isDefaultPreventedOnClickForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDefaultPreventedOnClickForTabAtIndex: (index: number) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isTabActiveAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTabActiveAtIndex: (index: number) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property measureTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              measureTabAtIndex: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property notifyChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notifyChange: (evtData: MDCTabBarChangeEventDetail) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property registerResizeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  registerResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property setPreventDefaultOnClickForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setPreventDefaultOnClickForTabAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          preventDefaultOnClick: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property setStyleForIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setStyleForIndicator: (propertyName: string, value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property setTabActiveAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setTabActiveAtIndex: (index: number, isActive: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property unbindOnMDCTabSelectedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unbindOnMDCTabSelectedEvent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace @material/tabs/tab-bar/component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module '@material/tabs/tab-bar/component' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class MDCTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property activeTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  activeTab: MDCTab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property activeTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    activeTabIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property root_

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected root_: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly tabs: MDCTab[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method attachTo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDefaultFoundation: () => MDCTabBarFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialize: (tabFactory?: MDCTabFactory) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MDCTabBarFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MDCTabBarFactory = (el: Element, foundation?: MDCTabBarFoundation) => MDCTabBar;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace @material/tabs/tab-bar/constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module '@material/tabs/tab-bar/constants' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const cssClasses: { UPGRADED: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Copyright 2017 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 strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const strings: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CHANGE_EVENT: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          INDICATOR_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace @material/tabs/tab-bar/foundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module '@material/tabs/tab-bar/foundation' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCTabBarFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(adapter?: Partial<MDCTabBarAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly cssClasses: { UPGRADED: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly defaultAdapter: MDCTabBarAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly strings: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CHANGE_EVENT: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      INDICATOR_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getActiveTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getActiveTabIndex: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        init: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method switchToTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            switchToTabAtIndex: (index: number, shouldNotify: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace @material/tabs/tab-bar/index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module '@material/tabs/tab-bar/index' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable tabBarCssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const tabBarCssClasses: { UPGRADED: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Copyright 2017 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 tabBarStrings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const tabBarStrings: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CHANGE_EVENT: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INDICATOR_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MDCTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property activeTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    activeTab: MDCTab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activeTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activeTabIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property root_

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected root_: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly tabs: MDCTab[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method attachTo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDefaultFoundation: () => MDCTabBarFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                initialize: (tabFactory?: MDCTabFactory) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class MDCTabBarFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(adapter?: Partial<MDCTabBarAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly cssClasses: { UPGRADED: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly defaultAdapter: MDCTabBarAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly strings: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CHANGE_EVENT: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                INDICATOR_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TAB_SELECTOR: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getActiveTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getActiveTabIndex: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  init: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    layout: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method switchToTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      switchToTabAtIndex: (index: number, shouldNotify: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabBarAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabBarAdapter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bindOnMDCTabSelectedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bindOnMDCTabSelectedEvent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property deregisterResizeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deregisterResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getComputedLeftForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getComputedLeftForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getComputedWidthForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getComputedWidthForTabAtIndex: (index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property getNumberOfTabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getNumberOfTabs: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getOffsetWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getOffsetWidth: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getOffsetWidthForIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getOffsetWidthForIndicator: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isDefaultPreventedOnClickForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDefaultPreventedOnClickForTabAtIndex: (index: number) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isTabActiveAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTabActiveAtIndex: (index: number) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property measureTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              measureTabAtIndex: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property notifyChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notifyChange: (evtData: MDCTabBarChangeEventDetail) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property registerResizeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  registerResizeHandler: (handler: SpecificEventListener<'resize'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property setPreventDefaultOnClickForTabAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setPreventDefaultOnClickForTabAtIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          preventDefaultOnClick: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property setStyleForIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setStyleForIndicator: (propertyName: string, value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property setTabActiveAtIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setTabActiveAtIndex: (index: number, isActive: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property unbindOnMDCTabSelectedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unbindOnMDCTabSelectedEvent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCTabBarChangeEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCTabBarChangeEvent extends Event {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly detail: MDCTabBarChangeEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MDCTabBarChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MDCTabBarChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Copyright 2019 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property activeTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  activeTabIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MDCTabBarFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MDCTabBarFactory = (el: Element, foundation?: MDCTabBarFoundation) => MDCTabBar;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/tabs/tab-bar/types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/tabs/tab-bar/types' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabBarChangeEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabBarChangeEvent extends Event {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly detail: MDCTabBarChangeEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MDCTabBarChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MDCTabBarChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Copyright 2019 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property activeTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            activeTabIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace @material/tabs/tab/adapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module '@material/tabs/tab/adapter' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCTabAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MDCTabAdapter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property deregisterInteractionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deregisterInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getOffsetLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getOffsetLeft: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getOffsetWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getOffsetWidth: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property notifySelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          notifySelected: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property registerInteractionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            registerInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace @material/tabs/tab/component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module '@material/tabs/tab/component' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MDCTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MDCTab extends MDCComponent<MDCTabFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property computedLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly computedLeft: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property computedWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly computedWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isActive: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property preventDefaultOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          preventDefaultOnClick: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property root_

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected root_: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method attachTo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDefaultFoundation: () => MDCTabFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method measureSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      measureSelf: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabSelectedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MDCTabSelectedEvent extends Event {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly detail: MDCTabSelectedEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MDCTabSelectedEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MDCTabSelectedEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tab: MDCTab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MDCTabFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MDCTabFactory = (el: Element, foundation?: MDCTabFoundation) => MDCTab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace @material/tabs/tab/constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module '@material/tabs/tab/constants' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const cssClasses: { ACTIVE: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copyright 2017 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 strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const strings: { SELECTED_EVENT: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @material/tabs/tab/foundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@material/tabs/tab/foundation' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MDCTabFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(adapter?: Partial<MDCTabAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly cssClasses: { ACTIVE: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly defaultAdapter: MDCTabAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly strings: { SELECTED_EVENT: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getComputedLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getComputedLeft: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getComputedWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getComputedWidth: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        init: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isActive: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method measureSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            measureSelf: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method preventsDefaultOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preventsDefaultOnClick: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setActive: (isActive: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setPreventDefaultOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setPreventDefaultOnClick: (preventDefaultOnClick: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace @material/tabs/tab/index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module '@material/tabs/tab/index' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable tabCssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const tabCssClasses: { ACTIVE: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Copyright 2017 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 tabStrings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const tabStrings: { SELECTED_EVENT: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MDCTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MDCTab extends MDCComponent<MDCTabFoundation> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property computedLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly computedLeft: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property computedWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly computedWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isActive: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property preventDefaultOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                preventDefaultOnClick: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property root_

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected root_: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method attachTo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDefaultFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDefaultFoundation: () => MDCTabFoundation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method initialSyncWithDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialSyncWithDOM: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method measureSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            measureSelf: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class MDCTabFoundation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(adapter?: Partial<MDCTabAdapter>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cssClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly cssClasses: { ACTIVE: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly defaultAdapter: MDCTabAdapter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly strings: { SELECTED_EVENT: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getComputedLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getComputedLeft: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getComputedWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getComputedWidth: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              init: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isActive: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method measureSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  measureSelf: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method preventsDefaultOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preventsDefaultOnClick: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setActive: (isActive: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setPreventDefaultOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setPreventDefaultOnClick: (preventDefaultOnClick: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MDCTabAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MDCTabAdapter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property deregisterInteractionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deregisterInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getOffsetLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getOffsetLeft: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getOffsetWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getOffsetWidth: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property notifySelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    notifySelected: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property registerInteractionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      registerInteractionHandler: <K extends EventType>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          handler: SpecificEventListener<K>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeClass: (className: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MDCTabSelectedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MDCTabSelectedEvent extends Event {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly detail: MDCTabSelectedEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCTabSelectedEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MDCTabSelectedEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tab: MDCTab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MDCTabFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MDCTabFactory = (el: Element, foundation?: MDCTabFoundation) => MDCTab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (7)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@material/tabs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@material/tabs)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <a href="https://www.jsdocs.io/package/@material/tabs"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>