@momentum-ui/web-components 2.5.7 → 2.6.0

package/dist/types/components/table-advanced/TableAdvanced.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import "@/components/menu-overlay/MenuOverlay";
+import { LitElement, PropertyValues } from "lit-element";
+import { TemplateResult } from "lit-html";
+import { Evt, TemplateCallback, TemplateInfo } from "./src/decorators";
+import { Filter } from "./src/filter";
+export declare namespace TableAdvanced {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusTrapMixin").AnyConstructor<import("../../mixins/FocusTrapMixin").FocusTrapClass & import("../../mixins/FocusTrapMixin").FocusTrapInterface & import("../../mixins/FocusMixin").FocusClass>;
+    /**
+     * @element md-table-advanced
+     * @fires md-table-advanced-change
+     */
+    export class ELEMENT extends ELEMENT_base {
+        config: Config | string;
+        data: Data | string;
+        "md-table-advanced-change": Evt<ChangeEvent>;
+        tableConfig: Config;
+        tableData: Data;
+        private error;
+        private COLS;
+        private ROWS;
+        private updCols;
+        private updRows;
+        private dragRow;
+        private dropRow;
+        private drops;
+        private dragRowElem;
+        private dragCol;
+        private dropCol;
+        private isResizing;
+        private isSelectable;
+        private selected;
+        private expandedRowIdx;
+        private dragover;
+        tableRaws?: HTMLTableRowElement[];
+        disconnectedCallback(): void;
+        connectedCallback(): void;
+        protected update(changedProperties: PropertyValues): void;
+        private updateTableData;
+        private updateTableConfig;
+        private populateColumns;
+        private populateData;
+        private validateData;
+        private populateTemplate;
+        private setDefaultFilterAndSort;
+        private populateTable;
+        private updateDataInTable;
+        private onDropRow;
+        private onDropCol;
+        private sort;
+        private filter;
+        private selectRow;
+        private clearSelection;
+        private collapseToggle;
+        private eX;
+        private onResize;
+        render(): TemplateResult;
+        private renderHead;
+        private renderCol;
+        private renderColDrag;
+        private renderColResize;
+        private renderBody;
+        private renderRow;
+        static get styles(): import("lit-element").CSSResult[];
+    }
+    type ColId = string;
+    export type Data = {
+        csv: string;
+    } | {
+        list: string[];
+    } | {
+        list2d: string[][];
+    };
+    export type Config = {
+        isStickyHeader?: boolean;
+        isInfiniteScroll?: boolean;
+        cols: {
+            define: (ColOptions | ColOptionsGroup)[];
+            isDraggable?: boolean;
+            isResizable?: boolean;
+            collapse?: ColId;
+        };
+        rows?: {
+            isDraggable?: boolean;
+            selectable?: "none" | "single" | "multiple";
+        };
+        cellTemplates?: Record<string, CellTemplate>;
+        default?: {
+            col?: Pick<ColOptions, "filters" | "sorter">;
+            sort?: {
+                colId: ColId;
+                order: SortOrder;
+            };
+            filter?: {
+                colId: ColId;
+                input: string;
+                selectedIndex: number;
+            };
+        };
+        head?: {
+            caption?: string;
+            summary?: string;
+        };
+    };
+    type ColOptions = {
+        id: string;
+        title: string;
+        width?: string;
+        sorter?: "byString" | "byNumber" | SortComparator;
+        filters?: "forString" | "forNumber" | Filter.Options[];
+        isHeader?: boolean;
+    };
+    type ColOptionsGroup = {
+        groupName: string;
+        children: ColOptions[];
+    };
+    type SortOrder = "default" | "ascending" | "descending";
+    type SortComparator = (a: string, b: string, direction: 1 | -1) => number;
+    type CellTemplate = {
+        templateName: string;
+        contentUse?: "insert" | "replace";
+        contentCb?: CellContentCallback;
+        templateCb?: TemplateCallback;
+    };
+    type CellContentCallback = (p: TemplateInfo) => string;
+    export type ChangeEvent = {
+        detail: {
+            type: "filter-on";
+            filter: Filter.Options;
+            input: string;
+        } | {
+            type: "filter-off";
+            filter: Filter.Options;
+        } | {
+            type: "sort";
+            order: SortOrder;
+        } | {
+            type: "select";
+            index: number;
+        } | {
+            type: "multi-select";
+            rows: number[];
+        } | {
+            type: "expand";
+            row: number;
+        } | {
+            type: "collapse";
+            row: number;
+        };
+    };
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-table-advanced": TableAdvanced.ELEMENT;
+    }
+}

package/dist/types/components/table-advanced/src/decorators.d.ts

@@ -0,0 +1,32 @@
+export declare function debounce(ms?: number): (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function evt(): (protoOrDescriptor: any, name: string) => any;
+declare type Detail<T> = {
+    detail: T;
+};
+export declare class Evt<T extends Detail<V>, V = any> {
+    private target;
+    private eventName;
+    constructor(target: HTMLElement, eventName: string);
+    emit(value: T extends Detail<infer U> ? U : never, options?: {
+        bubbles?: boolean;
+        composed?: boolean;
+        cancelable?: boolean;
+    }): void;
+}
+import { Part } from "lit-html";
+export declare type TemplateInfo = {
+    content: string;
+    insertIndex: number;
+    col: number;
+    row: number;
+};
+declare type TCallback = TemplateInfo & {
+    fragment: DocumentFragment;
+};
+declare type TPayload = TemplateInfo & {
+    template: HTMLTemplateElement;
+    cb: TemplateCallback;
+};
+export declare type TemplateCallback = (p: TCallback) => void;
+export declare const templateCallback: (p: TPayload) => (part: Part) => void;
+export {};

package/dist/types/components/table-advanced/src/filter.d.ts

@@ -0,0 +1,25 @@
+export declare namespace Filter {
+    type Options = {
+        label: string;
+        input: {
+            placeholder: string;
+            maxlength?: number;
+            pattern?: string;
+        };
+        predicate: (data: string, input: string) => boolean;
+    };
+    const OPTIONS: {
+        equals: Options;
+        notEqual: Options;
+        contains: Options;
+        notContains: Options;
+        startsWith: Options;
+        endsWith: Options;
+        lessThan: Options;
+        lessThanOrEquals: Options;
+        greaterThan: Options;
+        greaterThanOrEquals: Options;
+    };
+    const optionsString: Options[];
+    const optionsNumber: Options[];
+}

package/dist/types/components/tabs/Tab.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+export declare const TAB_CROSS_WIDTH = 22;
+export declare type TabClickEvent = {
+    id: string;
+};
+export declare type TabCloseClickEvent = {
+    id: string;
+    name: string;
+};
+export declare type TabKeyDownEvent = {
+    id: string;
+    key: string;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    srcEvent: KeyboardEvent;
+};
+export declare namespace Tab {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        tabIndex: number;
+        ariaLabel: string;
+        closable: "auto" | "custom" | "";
+        name: string;
+        isCrossVisible: boolean;
+        private _disabled;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        private _selected;
+        get selected(): boolean;
+        set selected(value: boolean);
+        vertical: boolean;
+        viewportHidden: boolean;
+        static get styles(): import("lit-element").CSSResult[];
+        handleClick(event: MouseEvent): void;
+        handleCrossKeydown(event: KeyboardEvent): void;
+        handleCrossClick(event: MouseEvent | KeyboardEvent): void;
+        private handleCrossEventDispatch;
+        private notifySelectedTab;
+        protected update(changedProperties: PropertyValues): void;
+        connectedCallback(): void;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-tab": Tab.ELEMENT;
+    }
+}

package/dist/types/components/tabs/TabPanel.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace TabPanel {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        selected: boolean;
+        name: string;
+        focusablePanel: boolean;
+        static get styles(): import("lit-element").CSSResult[];
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-tab-panel": TabPanel.ELEMENT;
+    }
+}

package/dist/types/components/tabs/Tabs.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import "@/components/icon/Icon";
+import "@/components/menu-overlay/MenuOverlay";
+import { LitElement, PropertyValues } from "lit-element";
+import Sortable from "sortablejs";
+import { MenuOverlay } from "../menu-overlay/MenuOverlay";
+import { Tab, TabClickEvent } from "./Tab";
+export declare const MORE_MENU_TAB_COPY_ID_PREFIX = "more-menu-copy-";
+export declare namespace Tabs {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/SlottedMixin").AnyConstructor<import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/SlottedMixin").SlotableInterface> & import("../../mixins/RovingTabIndexMixin").AnyConstructor<import("../../mixins/RovingTabIndexMixin").RovingTabIndexInterface & import("../../mixins/SlottedMixin").SlotableInterface & import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/RovingTabIndexMixin").RovingTabIndexClass> & import("../../mixins/ResizeMixin").AnyConstructor<import("../../mixins/ResizeMixin").ResizeClass>;
+    export class ELEMENT extends ELEMENT_base {
+        justified: boolean;
+        overlowLabel: string;
+        draggable: boolean;
+        direction: "horizontal" | "vertical";
+        moreItemsScrollLimit: number;
+        delay: number;
+        animation: number;
+        ghostClass: string;
+        chosenClass: string;
+        forceFallback: boolean;
+        fallbackClass: string;
+        tabsId: string;
+        persistSelection: boolean;
+        compUniqueId: string;
+        private isMoreTabMenuVisible;
+        private isMoreTabMenuMeasured;
+        private isMoreTabMenuOpen;
+        private isMoreTabMenuSelected;
+        private isMoreTabMenuScrollable;
+        private moreTabMenuOffsetWidth;
+        private moreTabMenuMaxHeight;
+        private tabsViewportDataList;
+        private tabsFilteredAsVisibleList;
+        private tabsFilteredAsHiddenList;
+        private noTabsVisible;
+        private defaultTabsOrderArray;
+        private tabsOrderPrefsArray;
+        tabSlotElement: HTMLSlotElement;
+        panelSlotElement?: HTMLSlotElement;
+        tabsListElement?: HTMLDivElement;
+        tabsSettingsElement?: HTMLElement;
+        moreTabMenuElement?: Tab.ELEMENT;
+        menuOverlayElement?: MenuOverlay.ELEMENT;
+        tabsMoreListElement?: HTMLDivElement;
+        tabsCopyHiddenListElements?: NodeListOf<Tab.ELEMENT>;
+        visibleTabsContainerElement?: HTMLElement;
+        hiddenTabsContainerElement?: HTMLElement;
+        private generateOptions;
+        private tabs;
+        private panels;
+        private tabsCopy;
+        private tabsHash;
+        private tabsCopyHash;
+        private tabsIdxHash;
+        private tabsVisibleIdxHash;
+        private tabsHiddenIdxHash;
+        private tabHiddenIdPositiveTabIndex?;
+        private visibleTabsSortableInstance;
+        private hiddenTabsSortableInstance;
+        private getCopyTabId;
+        private getNormalizedTabId;
+        static get styles(): import("lit-element").CSSResult[];
+        private ensureTabsUpdateComplete;
+        private measureTabsOffsetWidth;
+        private measureHiddenTabsCopiesOffsetHeight;
+        private manageOverflow;
+        private updateIsMoreTabMenuSelected;
+        private updateHiddenIdPositiveTabIndex;
+        private sortTabsAndPanes;
+        private linkPanelsAndTabs;
+        get slotItem(): HTMLSlotElement;
+        protected filterSlotted(): HTMLElement[];
+        protected handleResize(contentRect: DOMRect): Promise<void>;
+        private getDragDirection;
+        handleOnDragEnd: (event: Sortable.SortableEvent) => Promise<void>;
+        private makeTabCopyFocus;
+        handleTabClick(event: CustomEvent<TabClickEvent>): void;
+        handleNewSelectedTab(id: string): void;
+        handleTabCrossClick(event: CustomEvent<TabClickEvent>): void;
+        handleUpdatedSeletedTabAfterCross(crossTabIndex: number): void;
+        private updateSelectedTab;
+        private dispatchSelectedChangedEvent;
+        private changeSelectedTabIdx;
+        storeSelectedTabIndex(index: number): void;
+        handleOverlayClose(): void;
+        dispatchKeydownEvent(event: KeyboardEvent, tabId: string): void;
+        handleTabKeydown(event: any): void;
+        private setupTabsEvents;
+        private teardownTabsEvents;
+        private clearTabOrderPrefs;
+        private setupPanelsAndTabs;
+        private setupMoreTab;
+        private initializeSortable;
+        private initializeTabs;
+        connectedCallback(): void;
+        private selectTabFromStorage;
+        disconnectedCallback(): void;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        protected updated(changedProperties: PropertyValues): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-tabs": Tabs.ELEMENT;
+    }
+}

package/dist/types/components/taskitem/TaskItem.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import "@/components/badge/Badge";
+import "@/components/icon/Icon";
+import { LitElement } from "lit-element";
+export declare namespace TaskItem {
+    class ELEMENT extends LitElement {
+        mediaType: string;
+        status: string;
+        popovertitle: string;
+        title: string;
+        queue: string;
+        accepted: boolean;
+        quantity: number;
+        lastmessage: string;
+        selected: boolean;
+        customAriaLabel: string;
+        renderTaskType: () => import("lit-element").TemplateResult;
+        renderStatus: () => import("lit-element").TemplateResult;
+        handleClick(event: MouseEvent): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        renderChatCount(): {};
+        getAriaLabel(): string;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-task-item": TaskItem.ELEMENT;
+    }
+}

package/dist/types/components/theme/Theme.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { TooltipEvent } from "../tooltip/Tooltip";
+import { LitElement, PropertyValues } from "lit-element";
+declare global {
+    interface Window {
+        ShadyCSS: {
+            nativeShadow: boolean;
+            prepareTemplate(template: HTMLTemplateElement, elementName: string, typeExtension?: string): void;
+            styleElement(host: HTMLElement): void;
+            ScopingShim: {
+                prepareAdoptedCssText(cssTextArray: string[], elementName: string): void;
+            };
+        };
+    }
+    interface ShadowRoot {
+        adoptedStyleSheets?: CSSStyleSheet[];
+    }
+    interface CSSStyleSheet {
+        replaceSync: Function;
+    }
+}
+export declare namespace Theme {
+    type Attributes = {
+        darkTheme: boolean;
+        mdTheme: boolean;
+    };
+    /**
+     * Popper.js can't position overlay content correct in
+     * case when element inside container with overflow: hidden.
+     * https://github.com/popperjs/popper-core/issues/112.
+     * To make possible to position such element correctly, we need
+     * move creating popper instance in parent container that guarantee
+     * will not contain overflow property with hidden value;
+     */
+    class ELEMENT extends LitElement {
+        darkTheme: boolean;
+        lumos: boolean;
+        private activeTheme;
+        virtualWrapper: HTMLDivElement;
+        virtualReference: HTMLDivElement;
+        private placement;
+        private popperInstance;
+        private setTheme;
+        private applyStyle;
+        private removeChildFromVirtualPopper;
+        private setInitStyleToVirtualReference;
+        private setStyleToVirtualReference;
+        private setVirtualReferencePosition;
+        private initVirtualElements;
+        private setVirtualSlotContent;
+        protected updated(changedProperties: PropertyValues): void;
+        handleVirtualTooltipCreate(event: CustomEvent<TooltipEvent>): void;
+        handleVirtualTooltipDestroy(event: CustomEvent<TooltipEvent>): void;
+        handleVirtualTooltipChangeMessage(event: CustomEvent<TooltipEvent>): void;
+        handleVirtualTooltipSlotChange(event: CustomEvent<TooltipEvent>): void;
+        handleTooltipRemoved: () => void;
+        private destroyPopperInstance;
+        private createPopperInstance;
+        private get virtualPopper();
+        private get virtualArrow();
+        private get virtualTooltipContent();
+        private showVirtualTooltip;
+        private hideVirtualTooltip;
+        private setupEvents;
+        private teardownEvents;
+        disconnectedCallback(): void;
+        protected firstUpdated(changedProperties: PropertyValues): Promise<void>;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-theme": Theme.ELEMENT;
+    }
+}

package/dist/types/components/theme/index.d.ts

@@ -0,0 +1,5 @@
+import lumosDark from "@/wc_scss/themes/vars/lmDark.scss";
+import lumosLight from "@/wc_scss/themes/vars/lmLight.scss";
+import momentumDark from "@/wc_scss/themes/vars/mdDark.scss";
+import momentumLight from "@/wc_scss/themes/vars/mdLight.scss";
+export { lumosDark, lumosLight, momentumDark, momentumLight };

package/dist/types/components/timepicker/TimePicker.d.ts

@@ -0,0 +1,49 @@
+import { LitElement, PropertyValues } from "lit-element";
+import "@/components/input/Input";
+import { TIME_UNIT } from "../../constants";
+import { DateTime } from "luxon";
+export declare const timeUnits: readonly [TIME_UNIT.HOUR, TIME_UNIT.MINUTE, TIME_UNIT.SECOND, TIME_UNIT.AM_PM];
+export declare const timeSpecificity: TIME_UNIT[];
+export declare namespace TimePicker {
+    type TimeUnit = typeof timeUnits[number];
+    type TimeSpecificity = typeof timeSpecificity[number];
+    class ELEMENT extends LitElement {
+        twoDigitAutoTab: boolean;
+        twentyFourHourFormat: boolean;
+        timeSpecificity: TimePicker.TimeSpecificity;
+        locale: string;
+        value: string;
+        private localeTwentyFourFormat;
+        private finalTwentyFourFormat;
+        private timeObject;
+        private tabNext;
+        private timeValue;
+        private timeValidity;
+        get timePickerClassMap(): {
+            "twenty-four-hour-format": boolean;
+        };
+        protected updated(changedProperties: PropertyValues): void;
+        addLeadingZeros: (value: string | undefined) => string | undefined;
+        formatAndValidate: (timeUnitString: string | undefined, unit: TIME_UNIT) => string | undefined;
+        getLocaleTimeFormat: (aTimeObject: DateTime) => boolean;
+        updateTimeValues: () => void;
+        updateValidity: (input: string, unit: TimePicker.TimeUnit) => void;
+        to12HourFormat: (amPm: string, hour: string) => number | undefined;
+        isEntireTimeValid: () => boolean;
+        updateTimeUnit: (unit: TIME_UNIT) => void;
+        handleTimeChange(event: CustomEvent, unit: TimePicker.TimeUnit): void;
+        handleTimeKeyDown(event: CustomEvent, unit: TimePicker.TimeUnit): void;
+        handleTimeBlur(event: CustomEvent, unit: TimePicker.TimeUnit): void;
+        static get styles(): import("lit-element").CSSResult[];
+        formatTimeUnit: (unit: TimePicker.TimeUnit) => void;
+        messageType: (isValid: boolean) => "error" | "";
+        generateTimeBox: (unit: TimePicker.TimeUnit) => import("lit-element").TemplateResult;
+        generateAmPmComboBox: () => import("lit-element").TemplateResult;
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-timepicker": TimePicker.ELEMENT;
+    }
+}

package/dist/types/components/toggle-switch/ToggleSwitch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import "@/components/label/Label";
+import { LitElement } from "lit-element";
+export declare namespace ToggleSwitch {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        htmlId: string;
+        label: string;
+        checked: boolean;
+        disabled: boolean;
+        small: boolean;
+        smaller: boolean;
+        autofocus: boolean;
+        handleClick(): void;
+        get toggleSwitchClassMap(): {
+            "md-toggle-switch--small": boolean;
+            "md-toggle-switch--smaller": boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+        static get styles(): import("lit-element").CSSResult[];
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-toggle-switch": ToggleSwitch.ELEMENT;
+    }
+}

package/dist/types/components/tooltip/Tooltip.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { LitElement, PropertyValues } from "lit-element";
+export declare const tooltipPlacement: readonly ["auto", "auto-start", "auto-end", "left-start", "left", "left-end", "right-start", "right", "right-end", "top-start", "top", "top-end", "bottom-start", "bottom", "bottom-end"];
+export declare const tooltipStrategy: readonly ["fixed", "absolute"];
+export declare type TooltipEvent = {
+    placement: Tooltip.Placement;
+    reference: HTMLElement;
+    popper: HTMLElement;
+    slotContent?: Element[] | undefined | null;
+};
+export declare namespace Tooltip {
+    export type Placement = typeof tooltipPlacement[number];
+    export type Strategy = typeof tooltipStrategy[number];
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass>;
+    export class ELEMENT extends ELEMENT_base {
+        message: string;
+        placement: Tooltip.Placement;
+        disabled: boolean;
+        opened: boolean;
+        popper: HTMLDivElement;
+        reference: HTMLDivElement;
+        private slotContent;
+        protected handleFocusIn(event: Event): void;
+        protected handleFocusOut(event: Event): void;
+        private openTooltip;
+        private closeTooltip;
+        private changeMessage;
+        private changeSlotContent;
+        notifyTooltipCreate(): void;
+        notifyTooltipDestroy(): void;
+        handleSlotContentChange(event: Event): void;
+        protected updated(changedProperties: PropertyValues): void;
+        private get tooltipClassMap();
+        render(): import("lit-element").TemplateResult;
+        static get styles(): import("lit-element").CSSResult[];
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-tooltip": Tooltip.ELEMENT;
+    }
+}