@momentum-ui/web-components 2.16.3 → 2.16.4

package/dist/types/components/alert/Alert.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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 { buttonColor, buttonVariant } from "@/components/button/Button";
+import "@/components/icon/Icon";
+import "@/components/link/Link";
+import { LitElement, TemplateResult } from "lit-element";
+export declare namespace Alert {
+    type buttonVariant = (typeof buttonVariant)[number];
+    type buttonColor = (typeof buttonColor)[number];
+    class ELEMENT extends LitElement {
+        closable: boolean;
+        message: string;
+        show: boolean;
+        internalClose: boolean;
+        title: string;
+        btnlabel: string;
+        type: string;
+        inline: boolean;
+        newMomentum: boolean;
+        primaryButton: string;
+        primaryButtonVariant: Alert.buttonVariant;
+        primaryButtonColor: Alert.buttonColor;
+        primaryButtonClickFunction?: () => void;
+        secondaryButton: string;
+        secondaryButtonClickFunction?: () => void;
+        link: boolean;
+        showMore: boolean;
+        href: string;
+        private readonly alertFooterSlot;
+        private hasFooterSlotContent;
+        connectedCallback(): void;
+        close(): void;
+        static get styles(): import("lit-element").CSSResult[];
+        renderIconTemplate: () => TemplateResult;
+        get alertClassMap(): {
+            [x: string]: boolean;
+            "md-alert__inline": boolean;
+        };
+        private get slottedFooterClassMap();
+        legacyRender(): TemplateResult;
+        renderNewAlertDefaultFooter(): TemplateResult;
+        handleSlotContentChange(_event: Event): void;
+        private updateFooterSlotInUse;
+        renderSlottedFooter(): TemplateResult;
+        newRender(): TemplateResult;
+        get alertRender(): TemplateResult;
+        render(): TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-alert": Alert.ELEMENT;
+    }
+}

package/dist/types/components/alert-banner/AlertBanner.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { CSSResultArray, LitElement } from "lit-element";
+export declare namespace AlertBanner {
+    class ELEMENT extends LitElement {
+        type: string;
+        message: string;
+        closable: boolean;
+        show: boolean;
+        closeAriaLabel: string;
+        connectedCallback(): void;
+        onHide(): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        static get styles(): CSSResultArray;
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-alert-banner": AlertBanner.ELEMENT;
+    }
+}

package/dist/types/components/audio-player/AudioPlayer.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) Cisco Systems, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE src in the root directory of this source tree.
+ *
+ */
+import "@/components/button/Button";
+import "@/components/icon/Icon";
+import "@/components/tooltip/Tooltip";
+import { LitElement, PropertyValues } from "lit-element";
+export type AudioEvent = {
+    name: string;
+    onEvent: EventListener;
+};
+export declare const playbackSpeeds: {
+    value: number;
+    label: string;
+}[];
+export type Label = {
+    ariaLabel: string;
+    tooltipText: string;
+};
+export type LabelMap = {
+    playBtn: Label;
+    pauseBtn: Label;
+    duration: Label;
+    timeline: Label;
+    volumeBtn: Label;
+    volumeSlider: Label;
+    playbackSpeedBtn: Label;
+};
+export declare const defaultLabelMap: {
+    playBtn: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+    pauseBtn: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+    duration: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+    timeline: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+    volumeBtn: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+    volumeSlider: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+    playbackSpeedBtn: {
+        ariaLabel: string;
+        tooltipText: string;
+    };
+};
+export declare namespace AudioPlayer {
+    class ELEMENT extends LitElement {
+        src: string;
+        labelMap: LabelMap;
+        events: AudioEvent[];
+        audio: HTMLAudioElement;
+        volumeElement: HTMLElement;
+        isPlaying: boolean;
+        isMuted: boolean;
+        duration: number;
+        volume: number;
+        currentTime: number;
+        showSpeedPopup: boolean;
+        playbackSpeed: number;
+        volumeExpanded: boolean;
+        bufferedRange: number;
+        selectedPlaybackSpeed: number;
+        currentlySelectingPlaybackSpeed: boolean;
+        constructor();
+        firstUpdated(changedProperties: PropertyValues): void;
+        updated(changedProperties: PropertyValues): void;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        setAudioEventListeners(): void;
+        togglePlay(): void;
+        toTimecode(time: number): string;
+        setTime(e: MouseEvent): void;
+        setVolumeElement(e: MouseEvent): void;
+        handleVolumeChange(e: MouseEvent): void;
+        getVolumeFromSlider(e: MouseEvent): number;
+        setVolume(e: MouseEvent): void;
+        getBarPercentage(e: MouseEvent, className: string): number;
+        toggleSoundMute(): void;
+        toggleSpeedPopup(): void;
+        onOutsideClick: (e: MouseEvent) => void;
+        setTimeKeydown(value: number): void;
+        setVolumeKeydown(value: number): void;
+        handleKeyDown: (event: KeyboardEvent) => void;
+        private get popupClassMap();
+        setPlaybackSpeed(speed: number): void;
+        toggleVolumeExpand(show: boolean): void;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-audio-player": AudioPlayer.ELEMENT;
+    }
+}

package/dist/types/components/avatar/Avatar.constants.d.ts

@@ -0,0 +1,4 @@
+import "@/components/icon/Icon";
+declare const AvatarType: readonly ["active", "away", "away-calling", "busy", "bot", "call", "dnd", "group", "inactive", "meeting", "ooo", "on-mobile", "on-device", "on-hold", "presenting", "self", "schedule", "typing", "engaged", "idle", "rona", "quiet-hours", ""];
+declare const AvatarSize: number[];
+export { AvatarSize, AvatarType };

package/dist/types/components/avatar/Avatar.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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/avatar/Presence";
+import "@/components/icon/Icon";
+import "@/components/loading/Loading";
+import { LitElement, PropertyValues } from "lit-element";
+import { AvatarSize, AvatarType } from "./Avatar.constants";
+export declare namespace Avatar {
+    type Type = (typeof AvatarType)[number];
+    type Size = (typeof AvatarSize)[number];
+    type Role = "img" | "button";
+    class ELEMENT extends LitElement {
+        private _tabIndex;
+        get tabIndex(): number;
+        set tabIndex(newValue: number);
+        alt: string;
+        src: string;
+        label: string;
+        title: string;
+        color: string;
+        decrypting: boolean;
+        role: Avatar.Role;
+        iconName: string;
+        failurePresence: boolean;
+        type: Type;
+        newMomentum: boolean;
+        typing: boolean;
+        size: Size;
+        hasNotification: boolean;
+        clickable: boolean;
+        clickFunction?: () => void;
+        private imageLoaded;
+        private imageErrored;
+        private presenceColor;
+        private presenceIcon;
+        static get styles(): import("lit-element").CSSResult[];
+        firstUpdated(): void;
+        updated(changedProperties: PropertyValues): void;
+        private get avatarClassMap();
+        private get avatarLetterClassMap();
+        private get avatarStyleMap();
+        private get pretifyTitle();
+        private get chatIconName();
+        private get chatIconSize();
+        private get iconSize();
+        get renderIsTyping(): {};
+        private get avatarLetter();
+        private get avatarIcon();
+        private get avatarImage();
+        private loadImage;
+        private handleImageLoad;
+        private handleImageError;
+        handleKeyDown(event: KeyboardEvent): void;
+        handleClick(event: MouseEvent): void;
+        get avatarContent(): {};
+        renderPresence(): {};
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-avatar": Avatar.ELEMENT;
+    }
+}

package/dist/types/components/avatar/CompositeAvatar.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 } from "lit-element";
+import { AvatarSize } from "./Avatar.constants";
+export declare namespace CompositeAvatar {
+    type Size = (typeof AvatarSize)[number];
+    class ELEMENT extends LitElement {
+        size: Size;
+        static get styles(): import("lit-element").CSSResult[];
+        get avatarClassMap(): {
+            [x: string]: boolean;
+        };
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-composite-avatar": CompositeAvatar.ELEMENT;
+    }
+}

package/dist/types/components/avatar/Presence.d.ts

@@ -0,0 +1,19 @@
+import "@/components/icon/Icon";
+import { LitElement } from "lit-element";
+import { AvatarSize } from "./Avatar.constants";
+export declare namespace Presence {
+    type Size = typeof AvatarSize[number];
+    class ELEMENT extends LitElement {
+        name: string;
+        size: Size;
+        title: string;
+        color: string;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-presence": Presence.ELEMENT;
+    }
+}

package/dist/types/components/avatar/Presence.utils.d.ts

@@ -0,0 +1,7 @@
+type ReturnType = {
+    presenceIcon: string | undefined;
+    presenceColor: string | undefined;
+};
+export declare const getPresenceIconColor: (presenceType: string, failureBadge: boolean, isMomentumDesign?: boolean) => ReturnType;
+export declare function getPresenceSize(size: number): number;
+export {};

package/dist/types/components/badge/Badge.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 } from "lit-element";
+export declare namespace Badge {
+    class ELEMENT extends LitElement {
+        ariaLabel: string;
+        color: string;
+        bgColor: string;
+        textColor: string;
+        height: string;
+        width: string;
+        outlined: boolean;
+        compact: boolean;
+        circle: boolean;
+        small: boolean;
+        split: boolean;
+        disabled: boolean;
+        tabIndexing: string;
+        ariaHiddenSplits: string;
+        renderBgColor: () => {};
+        renderTextColor: () => {};
+        renderHeight: () => {};
+        renderWidth: () => {};
+        getStyles: () => {};
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-badge": Badge.ELEMENT;
+    }
+}

package/dist/types/components/breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,24 @@
+import { LitElement, PropertyValues } from "lit-element";
+export declare namespace Breadcrumb {
+    type NavCrumb = {
+        link: string;
+        label: string;
+    };
+    export class ELEMENT extends LitElement {
+        label: string;
+        navCrumbs: NavCrumb[];
+        anchors?: HTMLAnchorElement[];
+        static get styles(): import("lit-element").CSSResult[];
+        private setLastAnchorCurrent;
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        protected update(changedProperties: PropertyValues): void;
+        handleClick(event: MouseEvent): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-breadcrumb": Breadcrumb.ELEMENT;
+    }
+}

package/dist/types/components/button/Button.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/spinner/Spinner";
+import { LitElement } from "lit-element";
+export declare const buttonSize: readonly ["20", "24", "28", "32", "36", "40", "44", "52", "56", "72", "68", "84", "size-none", 20, 24, 28, 32, 36, 40, 44, 52, 56, 68, 72, 68, 84];
+export declare const buttonTag: readonly ["button", "input", "a"];
+export declare const buttonType: readonly ["button", "reset", "submit"];
+export declare const buttonRoles: readonly ["button", "checkbox", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "switch", "tab"];
+export declare const buttonVariant: readonly ["primary", "secondary", "red", "green", "ghost", "white", "darkGrey", "promotional", "tab", "available", "unavailable", "engaged", "idle", "inverted-primary", "inverted-secondary", "dropdown"];
+export declare const buttonColor: readonly ["blue", "red", "green", "orange", "yellow", "mint", "purple", "pink", "cyan", "white", "dark-gray", "duck-egg", "violet", "color-none", ""];
+export declare const buttonAriaLive: readonly ["", "off", "polite", "assertive"];
+export declare namespace Button {
+    type Tag = (typeof buttonTag)[number];
+    type Type = (typeof buttonType)[number];
+    type Role = (typeof buttonRoles)[number];
+    type variant = (typeof buttonVariant)[number];
+    type color = (typeof buttonColor)[number];
+    type ariaLive = (typeof buttonAriaLive)[number];
+    type Attributes = {
+        id?: string;
+        disabled: boolean;
+        alt?: string;
+        href?: string;
+        type: Type;
+        ariaLabel?: string;
+        ariaLabelledBy?: string;
+        ariaLive?: string;
+        ariaExpanded?: boolean;
+        ariaHaspopup?: boolean;
+        ariaPressed?: string;
+        ariaCurrent?: boolean;
+        tag: Tag;
+        loading: boolean;
+        role?: string;
+        value: string;
+    };
+    type Size = (typeof buttonSize)[number];
+    class ELEMENT extends LitElement {
+        _active: boolean;
+        get active(): boolean;
+        set active(value: boolean);
+        private _tabIndex;
+        get tabIndex(): number;
+        set tabIndex(newValue: number);
+        ariaLabel: string;
+        ariaLabelledBy: string;
+        ariaLive: Button.ariaLive;
+        ariaExpanded: string;
+        ariaHaspopup: string;
+        ariaPressed: string;
+        circle: boolean;
+        rounded: boolean;
+        color: Button.color;
+        containerLarge: boolean;
+        disabled: boolean;
+        href: string;
+        id: string;
+        value: string;
+        keyboardKey: string;
+        label: string;
+        loading: boolean;
+        outline: boolean;
+        hasRemoveStyle: boolean;
+        size: Button.Size;
+        tag: Button.Tag;
+        type: Button.Type;
+        role: Button.Role;
+        variant: Button.variant;
+        width: string;
+        maxWidth: string;
+        activityType: string;
+        iconActive: boolean;
+        isActive: boolean;
+        clickFunction?: () => void;
+        isPlaceholderText?: boolean;
+        button: HTMLButtonElement;
+        renderWidth: () => {};
+        renderMaxWidth: () => {};
+        getStyles: () => import("lit-element").TemplateResult | undefined;
+        handleKeyDown(event: KeyboardEvent): void;
+        handleClick(event: MouseEvent): void;
+        static get styles(): import("lit-element").CSSResult[];
+        get buttonClassMap(): {
+            [x: string]: boolean;
+            "md-button--circle": boolean;
+            "md-button--rounded": boolean;
+            "md-button--none": boolean;
+            "md-button--outline": boolean;
+            active: boolean;
+            disabled: boolean;
+            isActive: boolean;
+            "md-activity": boolean;
+            "md-button--icon": boolean;
+            "md-button--onlyicon": boolean;
+            "md-button--placeholder-text": boolean;
+        };
+        get slottedText(): string | null | undefined;
+        get hasIcon(): boolean;
+        iconTemplate: () => import("lit-element").TemplateResult;
+        textTemplate: () => {};
+        childrenTemplate(): import("lit-element").TemplateResult;
+        buttonTemplate(tag: Button.Tag): {};
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-button": Button.ELEMENT;
+    }
+}

package/dist/types/components/button-group/ButtonGroup.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 ButtonGroup {
+    const ELEMENT_base: typeof LitElement & import("../../mixins/FocusMixin").AnyConstructor<import("../../mixins/FocusMixin").FocusClass> & import("../../mixins/SlottedMixin").AnyConstructor<import("../../mixins/SlottedMixin").SlotableClass & import("../../mixins/SlottedMixin").SlotableInterface>;
+    export class ELEMENT extends ELEMENT_base {
+        active: number;
+        tabIndex: number;
+        buttonSlot?: HTMLSlotElement;
+        private _disabled;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        get slotElement(): HTMLSlotElement | undefined;
+        static get styles(): import("lit-element").CSSResult[];
+        protected firstUpdated(changedProperties: PropertyValues): void;
+        private setButtonTabIndex;
+        protected updated(changedProperties: PropertyValues): void;
+        get selectedBtnValue(): string;
+        private notifySelectedChange;
+        private setSelected;
+        private setFirstActive;
+        private findBtnIndex;
+        private findSelectedBtnIndex;
+        private isBtnDisabled;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        private switchBtnOnArrowPress;
+        private getAvailableSelectedIndex;
+        private isFocusable;
+        handleClick(event: MouseEvent): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        render(): import("lit-element").TemplateResult;
+    }
+    export {};
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-button-group": ButtonGroup.ELEMENT;
+    }
+}

package/dist/types/components/card/Card.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/button/Button";
+import "@/components/favorite/Favorite";
+import "@/components/icon/Icon";
+import "@/components/list/List";
+import "@/components/list/ListItem";
+import "@/components/menu-overlay/MenuOverlay";
+import "@/components/tooltip/Tooltip";
+import { LitElement } from "lit-element";
+export declare namespace Card {
+    class ELEMENT extends LitElement {
+        title: string;
+        subtitle: string;
+        id: string;
+        info: string;
+        infoAriaLabel: string;
+        menuAriaLabel: string;
+        menuOptions: (string | any)[];
+        static get styles(): import("lit-element").CSSResult[];
+        handleCardClick(): void;
+        handleCardKeyDown(e: KeyboardEvent): void;
+        handleCardMenuEvent(event: MouseEvent, label: string): void;
+        handleCardMenuKeyDown(event: KeyboardEvent, label: string): void;
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-card": Card.ELEMENT;
+    }
+}

package/dist/types/components/card-ai/CardAi.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { LitElement } from "lit-element";
+export declare enum CardAiVariant {
+    USER_QUERY = "user_query",
+    RESPONSE = "response"
+}
+export declare namespace CardAi {
+    class ELEMENT extends LitElement {
+        id: string;
+        title: string;
+        cardText: string;
+        timestamp: string;
+        summariseMoreVisible: boolean;
+        variant: CardAiVariant;
+        private copyChecked;
+        private thumbsUpChecked;
+        private thumbsDownChecked;
+        static get styles(): import("lit-element").CSSResult[];
+        thumbsUpToggled(): void;
+        thumbsDownToggled(): void;
+        summariseMoreToggled(): void;
+        private copyToggled;
+        private renderHeader;
+        private renderCardText;
+        private renderThumbsUpButton;
+        private renderThumbsDownButton;
+        private renderCopyButton;
+        private renderResponseCard;
+        private renderFooter;
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-card-ai": CardAi.ELEMENT;
+    }
+}

package/dist/types/components/chat-message/ChatMessage.d.ts

@@ -0,0 +1,18 @@
+import { LitElement } from "lit-element";
+import "@/components/avatar/Avatar";
+export declare namespace ChatMessage {
+    class ELEMENT extends LitElement {
+        title: string;
+        src: string;
+        time: string;
+        label: string;
+        self: boolean;
+        static get styles(): import("lit-element").CSSResult[];
+        render(): import("lit-element").TemplateResult;
+    }
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "md-chat-message": ChatMessage.ELEMENT;
+    }
+}