@devtron-labs/devtron-fe-common-lib 4.0.2-beta-1 → 4.0.3

package/dist/Shared/Components/ActionMenu/ActionMenuItem.d.ts

@@ -0,0 +1,2 @@
+import { ActionMenuItemProps } from './types';
+export declare const ActionMenuItem: <T extends string | number>({ item, itemRef, isFocused, onClick, onMouseEnter, disableDescriptionEllipsis, }: ActionMenuItemProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Components/ActionMenu/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ActionMenu.component';
+export type { ActionMenuItemType, ActionMenuOptionType, ActionMenuProps } from './types';

package/dist/Shared/Components/ActionMenu/types.d.ts

@@ -0,0 +1,95 @@
+import { LegacyRef, MouseEvent, Ref } from 'react';
+import { LinkProps } from 'react-router-dom';
+import { PopoverProps, UsePopoverProps } from '../Popover';
+import { SelectPickerOptionType, SelectPickerProps } from '../SelectPicker';
+import { ActionMenuItemIconType, TrailingItemType } from '../TrailingItem';
+type ConditionalActionMenuComponentType = {
+    /**
+     * @default 'button'
+     */
+    componentType?: 'button';
+    href?: never;
+    to?: never;
+} | {
+    componentType?: 'anchor';
+    /** Specifies the URL for the `<a>` tag. */
+    href: string;
+    to?: never;
+} | {
+    componentType?: 'link';
+    /** Specifies the `to` property for react-router `Link` */
+    to: LinkProps['to'];
+    href?: never;
+};
+export type ActionMenuItemType<T extends string | number = string | number> = Omit<SelectPickerOptionType, 'label' | 'value' | 'endIcon' | 'startIcon'> & {
+    /** A unique identifier for the action menu item. */
+    id: T;
+    /** The text label for the menu item. */
+    label: string;
+    /** Indicates whether the menu item is disabled. */
+    isDisabled?: boolean;
+    /**
+     * Specifies the type of the menu item.
+     * @default 'neutral'
+     */
+    type?: 'neutral' | 'negative';
+    /** Defines the icon to be displayed at the start of the menu item. */
+    startIcon?: ActionMenuItemIconType;
+    /** Defines the item to be displayed at the end of the menu item. */
+    trailingItem?: TrailingItemType;
+    /** Prevents the menu from closing when the item is clicked. */
+    doNotCloseMenuOnClick?: boolean;
+    dataAttributesId?: number;
+} & ConditionalActionMenuComponentType;
+export type ActionMenuOptionType<T extends string | number> = {
+    /**
+     * The label for the group of menu items. \
+     * This is optional and can be used to categorize items under a specific group.
+     */
+    groupLabel?: string;
+    /**
+     * The list of items belonging to this group.
+     */
+    items: ActionMenuItemType<T>[];
+};
+export type UseActionMenuProps<T extends string | number> = Omit<UsePopoverProps, 'onPopoverKeyDown' | 'onTriggerKeyDown'> & {
+    /**
+     * The options to display in the action menu.
+     */
+    options: ActionMenuOptionType<T>[];
+    /**
+     * Determines whether the action menu is searchable.
+     */
+    isSearchable?: boolean;
+};
+export type ActionMenuProps<T extends string | number = string | number> = UseActionMenuProps<T> & Pick<SelectPickerProps, 'disableDescriptionEllipsis'> & {
+    /**
+     * Callback function triggered when an item is clicked.
+     * @param item - The selected item.
+     */
+    onClick: (item: ActionMenuItemType<T>, e: MouseEvent<HTMLAnchorElement> | MouseEvent<HTMLButtonElement>) => void;
+    /**
+     * Config for the footer at the bottom of action menu list. It is sticky by default
+     */
+    footerConfig?: SelectPickerProps['menuListFooterConfig'];
+} & ({
+    /**
+     * The React element to which the ActionMenu is attached.
+     * @note only use when children is not `Button` component otherwise use `buttonProps`.
+     */
+    children: NonNullable<PopoverProps['triggerElement']>;
+    buttonProps?: never;
+} | {
+    children?: never;
+    /**
+     * Properties for the button to which the Popover is attached.
+     */
+    buttonProps: NonNullable<PopoverProps['buttonProps']>;
+});
+export type ActionMenuItemProps<T extends string | number> = Pick<ActionMenuProps<T>, 'onClick' | 'disableDescriptionEllipsis'> & {
+    item: ActionMenuItemType<T>;
+    itemRef: Ref<HTMLAnchorElement> | LegacyRef<HTMLAnchorElement | HTMLButtonElement>;
+    isFocused?: boolean;
+    onMouseEnter?: () => void;
+};
+export {};

package/dist/Shared/Components/ActionMenu/useActionMenu.hook.d.ts

@@ -0,0 +1,302 @@
+import { ChangeEvent, RefObject } from 'react';
+import { UseActionMenuProps } from './types';
+export declare const useActionMenu: <T extends string | number>({ id, position, alignment, width, options, isSearchable, onOpen, }: UseActionMenuProps<T>) => {
+    open: boolean;
+    flatOptions: {
+        option: import('./types').ActionMenuItemType<T>;
+        itemIndex: number;
+        sectionIndex: number;
+    }[];
+    filteredOptions: import('./types').ActionMenuOptionType<T>[];
+    focusedIndex: number;
+    itemsRef: RefObject<RefObject<HTMLButtonElement | HTMLAnchorElement>[]>;
+    triggerProps: import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+        bounds: Pick<DOMRect, "left" | "top" | "height" | "width">;
+    };
+    overlayProps: Omit<import('..').BackdropProps, "children">;
+    popoverProps: {
+        ref?: import('react').Ref<HTMLDivElement>;
+        className?: string;
+        defaultValue?: string | number | readonly string[];
+        id?: string;
+        content?: string;
+        role?: import('react').AriaRole;
+        color?: string;
+        key?: import('react').Key;
+        title?: string;
+        about?: string;
+        is?: string;
+        security?: string;
+        hidden?: boolean;
+        part?: string;
+        prefix?: string;
+        slot?: string;
+        resource?: string;
+        draggable?: boolean | "true" | "false";
+        onClick?: import('react').MouseEventHandler<HTMLDivElement>;
+        defaultChecked?: boolean;
+        suppressContentEditableWarning?: boolean;
+        suppressHydrationWarning?: boolean;
+        accessKey?: string;
+        autoCapitalize?: "none" | (string & {}) | "off" | "on" | "sentences" | "words" | "characters";
+        autoFocus?: boolean;
+        contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only";
+        contextMenu?: string;
+        dir?: string;
+        enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+        lang?: string;
+        nonce?: string;
+        spellCheck?: boolean | "true" | "false";
+        tabIndex?: number;
+        translate?: "no" | "yes";
+        radioGroup?: string;
+        datatype?: string;
+        inlist?: any;
+        property?: string;
+        rel?: string;
+        rev?: string;
+        typeof?: string;
+        vocab?: string;
+        autoCorrect?: string;
+        autoSave?: string;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        itemID?: string;
+        itemRef?: string;
+        results?: number;
+        unselectable?: "off" | "on";
+        popover?: "" | "auto" | "manual" | "hint";
+        popoverTargetAction?: "toggle" | "show" | "hide";
+        popoverTarget?: string;
+        inert?: boolean;
+        inputMode?: "search" | "none" | "url" | "text" | "decimal" | "email" | "tel" | "numeric";
+        exportparts?: string;
+        "aria-activedescendant"?: string;
+        "aria-atomic"?: boolean | "true" | "false";
+        "aria-autocomplete"?: "none" | "list" | "inline" | "both";
+        "aria-braillelabel"?: string;
+        "aria-brailleroledescription"?: string;
+        "aria-busy"?: boolean | "true" | "false";
+        "aria-checked"?: boolean | "true" | "false" | "mixed";
+        "aria-colcount"?: number;
+        "aria-colindex"?: number;
+        "aria-colindextext"?: string;
+        "aria-colspan"?: number;
+        "aria-controls"?: string;
+        "aria-current"?: boolean | "time" | "true" | "false" | "page" | "step" | "location" | "date";
+        "aria-describedby"?: string;
+        "aria-description"?: string;
+        "aria-details"?: string;
+        "aria-disabled"?: boolean | "true" | "false";
+        "aria-dropeffect"?: "link" | "none" | "popup" | "copy" | "execute" | "move";
+        "aria-errormessage"?: string;
+        "aria-expanded"?: boolean | "true" | "false";
+        "aria-flowto"?: string;
+        "aria-grabbed"?: boolean | "true" | "false";
+        "aria-haspopup"?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
+        "aria-hidden"?: boolean | "true" | "false";
+        "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling";
+        "aria-keyshortcuts"?: string;
+        "aria-label"?: string;
+        "aria-labelledby"?: string;
+        "aria-level"?: number;
+        "aria-live"?: "off" | "assertive" | "polite";
+        "aria-modal"?: boolean | "true" | "false";
+        "aria-multiline"?: boolean | "true" | "false";
+        "aria-multiselectable"?: boolean | "true" | "false";
+        "aria-orientation"?: "horizontal" | "vertical";
+        "aria-owns"?: string;
+        "aria-placeholder"?: string;
+        "aria-posinset"?: number;
+        "aria-pressed"?: boolean | "true" | "false" | "mixed";
+        "aria-readonly"?: boolean | "true" | "false";
+        "aria-relevant"?: "all" | "text" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+        "aria-required"?: boolean | "true" | "false";
+        "aria-roledescription"?: string;
+        "aria-rowcount"?: number;
+        "aria-rowindex"?: number;
+        "aria-rowindextext"?: string;
+        "aria-rowspan"?: number;
+        "aria-selected"?: boolean | "true" | "false";
+        "aria-setsize"?: number;
+        "aria-sort"?: "other" | "none" | "ascending" | "descending";
+        "aria-valuemax"?: number;
+        "aria-valuemin"?: number;
+        "aria-valuenow"?: number;
+        "aria-valuetext"?: string;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        };
+        onCopy?: import('react').ClipboardEventHandler<HTMLDivElement>;
+        onCopyCapture?: import('react').ClipboardEventHandler<HTMLDivElement>;
+        onCut?: import('react').ClipboardEventHandler<HTMLDivElement>;
+        onCutCapture?: import('react').ClipboardEventHandler<HTMLDivElement>;
+        onPaste?: import('react').ClipboardEventHandler<HTMLDivElement>;
+        onPasteCapture?: import('react').ClipboardEventHandler<HTMLDivElement>;
+        onCompositionEnd?: import('react').CompositionEventHandler<HTMLDivElement>;
+        onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLDivElement>;
+        onCompositionStart?: import('react').CompositionEventHandler<HTMLDivElement>;
+        onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLDivElement>;
+        onCompositionUpdate?: import('react').CompositionEventHandler<HTMLDivElement>;
+        onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLDivElement>;
+        onFocus?: import('react').FocusEventHandler<HTMLDivElement>;
+        onFocusCapture?: import('react').FocusEventHandler<HTMLDivElement>;
+        onBlur?: import('react').FocusEventHandler<HTMLDivElement>;
+        onBlurCapture?: import('react').FocusEventHandler<HTMLDivElement>;
+        onChange?: import('react').ChangeEventHandler<HTMLDivElement, Element>;
+        onChangeCapture?: import('react').ChangeEventHandler<HTMLDivElement, Element>;
+        onBeforeInput?: import('react').InputEventHandler<HTMLDivElement>;
+        onBeforeInputCapture?: import('react').InputEventHandler<HTMLDivElement>;
+        onInput?: import('react').InputEventHandler<HTMLDivElement>;
+        onInputCapture?: import('react').InputEventHandler<HTMLDivElement>;
+        onReset?: import('react').ReactEventHandler<HTMLDivElement>;
+        onResetCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSubmit?: import('react').SubmitEventHandler<HTMLDivElement>;
+        onSubmitCapture?: import('react').SubmitEventHandler<HTMLDivElement>;
+        onInvalid?: import('react').ReactEventHandler<HTMLDivElement>;
+        onInvalidCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoad?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onError?: import('react').ReactEventHandler<HTMLDivElement>;
+        onErrorCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onKeyDown?: import('react').KeyboardEventHandler<HTMLDivElement>;
+        onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLDivElement>;
+        onKeyPress?: import('react').KeyboardEventHandler<HTMLDivElement>;
+        onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLDivElement>;
+        onKeyUp?: import('react').KeyboardEventHandler<HTMLDivElement>;
+        onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLDivElement>;
+        onAbort?: import('react').ReactEventHandler<HTMLDivElement>;
+        onAbortCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onCanPlay?: import('react').ReactEventHandler<HTMLDivElement>;
+        onCanPlayCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onCanPlayThrough?: import('react').ReactEventHandler<HTMLDivElement>;
+        onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onDurationChange?: import('react').ReactEventHandler<HTMLDivElement>;
+        onDurationChangeCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onEmptied?: import('react').ReactEventHandler<HTMLDivElement>;
+        onEmptiedCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onEncrypted?: import('react').ReactEventHandler<HTMLDivElement>;
+        onEncryptedCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onEnded?: import('react').ReactEventHandler<HTMLDivElement>;
+        onEndedCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadedData?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadedDataCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadedMetadata?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadStart?: import('react').ReactEventHandler<HTMLDivElement>;
+        onLoadStartCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onPause?: import('react').ReactEventHandler<HTMLDivElement>;
+        onPauseCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onPlay?: import('react').ReactEventHandler<HTMLDivElement>;
+        onPlayCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onPlaying?: import('react').ReactEventHandler<HTMLDivElement>;
+        onPlayingCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onProgress?: import('react').ReactEventHandler<HTMLDivElement>;
+        onProgressCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onRateChange?: import('react').ReactEventHandler<HTMLDivElement>;
+        onRateChangeCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSeeked?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSeekedCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSeeking?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSeekingCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onStalled?: import('react').ReactEventHandler<HTMLDivElement>;
+        onStalledCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSuspend?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSuspendCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onTimeUpdate?: import('react').ReactEventHandler<HTMLDivElement>;
+        onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onVolumeChange?: import('react').ReactEventHandler<HTMLDivElement>;
+        onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onWaiting?: import('react').ReactEventHandler<HTMLDivElement>;
+        onWaitingCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onAuxClick?: import('react').MouseEventHandler<HTMLDivElement>;
+        onAuxClickCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onClickCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onContextMenu?: import('react').MouseEventHandler<HTMLDivElement>;
+        onContextMenuCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onDoubleClick?: import('react').MouseEventHandler<HTMLDivElement>;
+        onDoubleClickCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onDragCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragEndCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragEnter?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragEnterCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragExit?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragExitCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragLeave?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragLeaveCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragOver?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragOverCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDragStartCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onDrop?: import('react').DragEventHandler<HTMLDivElement>;
+        onDropCapture?: import('react').DragEventHandler<HTMLDivElement>;
+        onMouseDown?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseDownCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseEnter?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseLeave?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseMove?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseMoveCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseOut?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseOutCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseOver?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseOverCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseUp?: import('react').MouseEventHandler<HTMLDivElement>;
+        onMouseUpCapture?: import('react').MouseEventHandler<HTMLDivElement>;
+        onSelect?: import('react').ReactEventHandler<HTMLDivElement>;
+        onSelectCapture?: import('react').ReactEventHandler<HTMLDivElement>;
+        onTouchCancel?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchCancelCapture?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchEnd?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchEndCapture?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchMove?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchMoveCapture?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchStart?: import('react').TouchEventHandler<HTMLDivElement>;
+        onTouchStartCapture?: import('react').TouchEventHandler<HTMLDivElement>;
+        onPointerDown?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerDownCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerMove?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerMoveCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerUp?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerUpCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerCancel?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerCancelCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerEnter?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerLeave?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerOver?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerOverCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerOut?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerOutCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onGotPointerCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onLostPointerCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onScroll?: import('react').UIEventHandler<HTMLDivElement>;
+        onScrollCapture?: import('react').UIEventHandler<HTMLDivElement>;
+        onScrollEnd?: import('react').UIEventHandler<HTMLDivElement>;
+        onScrollEndCapture?: import('react').UIEventHandler<HTMLDivElement>;
+        onWheel?: import('react').WheelEventHandler<HTMLDivElement>;
+        onWheelCapture?: import('react').WheelEventHandler<HTMLDivElement>;
+        onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLDivElement>;
+        onAnimationEnd?: import('react').AnimationEventHandler<HTMLDivElement>;
+        onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLDivElement>;
+        onAnimationIteration?: import('react').AnimationEventHandler<HTMLDivElement>;
+        onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLDivElement>;
+        onToggle?: import('react').ToggleEventHandler<HTMLDivElement>;
+        onBeforeToggle?: import('react').ToggleEventHandler<HTMLDivElement>;
+        onTransitionCancel?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionEnd?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionRun?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionStart?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLDivElement>;
+    } & import('framer-motion').MotionProps & {
+        ref: import('react').MutableRefObject<HTMLDivElement>;
+    };
+    setFocusedIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+    closePopover: () => void;
+    searchTerm: string;
+    handleSearch: (e: ChangeEvent<HTMLInputElement>) => void;
+    scrollableRef: import('react').MutableRefObject<any> | import('react').LegacyRef<any>;
+};

package/dist/Shared/Components/ActionMenu/utils.d.ts

@@ -0,0 +1,7 @@
+import { UseActionMenuProps } from './types';
+export declare const getActionMenuFlatOptions: <T extends string | number>(options: UseActionMenuProps<T>["options"]) => {
+    option: import('./types').ActionMenuItemType<T>;
+    itemIndex: number;
+    sectionIndex: number;
+}[];
+export declare const filterActionMenuOptions: <T extends string | number>(options: UseActionMenuProps<T>["options"], searchTerm: string) => import('./types').ActionMenuOptionType<T>[];

package/dist/Shared/Components/ActivityIndicator/ActivityIndicator.d.ts

@@ -1,3 +1,3 @@
 import { ActivityIndicatorProps } from './types';
-declare const ActivityIndicator: ({ rootClassName, backgroundColorClass, iconSizeClass, }: ActivityIndicatorProps) => JSX.Element;
+declare const ActivityIndicator: ({ rootClassName, backgroundColorClass, iconSizeClass, }: ActivityIndicatorProps) => import("react/jsx-runtime").JSX.Element;
 export default ActivityIndicator;

package/dist/Shared/Components/AnimatedDeployButton/AnimatedDeployButton.d.ts

@@ -0,0 +1,3 @@
+import { AnimatedDeployButtonProps } from './types';
+declare const AnimatedDeployButton: ({ text, style, disabled, isLoading, startIcon, endIcon, dataTestId, onButtonClick, tooltipContent, animateStartIcon, }: AnimatedDeployButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default AnimatedDeployButton;

package/dist/Shared/Components/AnimatedDeployButton/index.d.ts

@@ -0,0 +1 @@
+export { default as AnimatedDeployButton } from './AnimatedDeployButton';

package/dist/Shared/Components/AnimatedDeployButton/types.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from '../Button';
+export interface AnimatedDeployButtonProps extends Pick<ButtonProps, 'dataTestId' | 'text' | 'disabled' | 'isLoading' | 'startIcon' | 'endIcon' | 'style'> {
+    onButtonClick: (e?: any) => void;
+    tooltipContent?: string;
+    animateStartIcon?: boolean;
+}

package/dist/Shared/Components/AnimatedTimer/AnimatedTimer.component.d.ts

@@ -0,0 +1,3 @@
+import { AnimatedTimerProps } from './types';
+declare const AnimatedTimer: ({ duration, onComplete, size, tooltipContent }: AnimatedTimerProps) => import("react/jsx-runtime").JSX.Element;
+export default AnimatedTimer;

package/dist/Shared/Components/AnimatedTimer/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const CX = 12;
+export declare const CY = 12;
+export declare const RADIUS = 6;
+export declare const START_ANGLE = 0;
+export declare const END_ANGLE = 360;

package/dist/Shared/Components/AnimatedTimer/index.d.ts

@@ -0,0 +1 @@
+export { default as AnimatedTimer } from './AnimatedTimer.component';

package/dist/Shared/Components/AnimatedTimer/types.d.ts

@@ -0,0 +1,15 @@
+import { animate } from 'framer-motion';
+import { TooltipProps } from '../../../Common/Tooltip';
+import { IconBaseSizeType } from '../../index';
+export interface AnimatedTimerProps extends Pick<Parameters<typeof animate>[2], 'onComplete'> {
+    /**
+     * The time in seconds for the timer to animate.
+     */
+    duration: number;
+    onComplete?: () => void;
+    /**
+     * @default 24
+     */
+    size?: IconBaseSizeType;
+    tooltipContent?: TooltipProps['content'];
+}

package/dist/Shared/Components/AppStatusModal/AppStatusBody.d.ts

@@ -0,0 +1,2 @@
+import { AppStatusBodyProps } from './types';
+export declare const AppStatusBody: ({ appDetails, type, handleShowConfigDriftModal, deploymentStatusDetailsBreakdownData, selectedTab, debugWithAIButton: ExplainWithAIButton, handleClose, }: AppStatusBodyProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Components/AppStatusModal/AppStatusContent.d.ts

@@ -0,0 +1,3 @@
+import { AppStatusContentProps } from './types';
+declare const AppStatusContent: ({ appDetails, handleShowConfigDriftModal, filterHealthyNodes, isCardLayout, }: AppStatusContentProps) => import("react/jsx-runtime").JSX.Element;
+export default AppStatusContent;

package/dist/Shared/Components/AppStatusModal/AppStatusModal.component.d.ts

@@ -0,0 +1,3 @@
+import { AppStatusModalProps } from './types';
+declare const AppStatusModal: ({ titleSegments, handleClose, type, appDetails: appDetailsProp, processVirtualEnvironmentDeploymentData, updateDeploymentStatusDetailsBreakdownData, isConfigDriftEnabled, configDriftModal: ConfigDriftModal, appId, envId, initialTab, debugWithAIButton, }: AppStatusModalProps) => import("react/jsx-runtime").JSX.Element;
+export default AppStatusModal;

package/dist/Shared/Components/AppStatusModal/AppStatusModalTabList.d.ts

@@ -0,0 +1,3 @@
+import { AppStatusModalTabListProps } from './types';
+declare const AppStatusModalTabList: ({ handleSelectTab, appDetails, type, selectedTab, deploymentStatusDetailsBreakdownData, }: AppStatusModalTabListProps) => import("react/jsx-runtime").JSX.Element;
+export default AppStatusModalTabList;

package/dist/Shared/Components/AppStatusModal/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const APP_STATUS_CUSTOM_MESSAGES: {
+    HIBERNATED: string;
+    'PARTIALLY HIBERNATED': string;
+};

package/dist/Shared/Components/AppStatusModal/index.d.ts

@@ -0,0 +1,3 @@
+export { default as AppStatusContent } from './AppStatusContent';
+export { default as AppStatusModal } from './AppStatusModal.component';
+export { AppStatusModalTabType } from './types';

package/dist/Shared/Components/AppStatusModal/service.d.ts

@@ -0,0 +1,4 @@
+import { AppDetails, DeploymentStatusDetailsBreakdownDataType } from '../../types';
+import { GetAppDetailsParamsType, GetDeploymentStatusWithTimelineParamsType } from './types';
+export declare const getAppDetails: ({ appId, envId, abortControllerRef, }: GetAppDetailsParamsType) => Promise<AppDetails>;
+export declare const getDeploymentStatusWithTimeline: ({ abortControllerRef, appId, envId, showTimeline, virtualEnvironmentConfig, isHelmApp, deploymentAppType, }: GetDeploymentStatusWithTimelineParamsType) => Promise<DeploymentStatusDetailsBreakdownDataType>;

package/dist/Shared/Components/AppStatusModal/types.d.ts

@@ -0,0 +1,88 @@
+import { FunctionComponent, PropsWithChildren, ReactNode } from 'react';
+import { APIOptions, DeploymentAppTypes } from '../../../Common/Types';
+import { MainContext } from '../../Providers';
+import { AppDetails, ConfigDriftModalProps, DeploymentStatusDetailsBreakdownDataType, DeploymentStatusDetailsType, IntelligenceConfig } from '../../types';
+export declare enum AppStatusModalTabType {
+    APP_STATUS = "appStatus",
+    DEPLOYMENT_STATUS = "deploymentStatus"
+}
+export type AppStatusModalProps = {
+    titleSegments: string[];
+    handleClose: () => void;
+    isConfigDriftEnabled: boolean;
+    configDriftModal: FunctionComponent<ConfigDriftModalProps>;
+    processVirtualEnvironmentDeploymentData: (data?: DeploymentStatusDetailsType) => DeploymentStatusDetailsBreakdownDataType;
+    debugWithAIButton: FunctionComponent<{
+        intelligenceConfig: IntelligenceConfig;
+        debugAgentContext: MainContext['debugAgentContext'];
+        onClick?: () => void;
+    }>;
+} & ({
+    type: 'release';
+    appId: number;
+    envId: number;
+    appDetails?: never;
+    initialTab?: never;
+    updateDeploymentStatusDetailsBreakdownData?: never;
+} | {
+    type: 'devtron-app' | 'other-apps' | 'stack-manager';
+    appDetails: AppDetails;
+    initialTab: AppStatusModalTabType;
+    updateDeploymentStatusDetailsBreakdownData: (data: DeploymentStatusDetailsBreakdownDataType) => void;
+    appId?: never;
+    envId?: never;
+});
+export interface AppStatusBodyProps extends Required<Pick<AppStatusModalProps, 'appDetails' | 'type' | 'debugWithAIButton' | 'handleClose'>> {
+    handleShowConfigDriftModal: () => void;
+    selectedTab: AppStatusModalTabType;
+    deploymentStatusDetailsBreakdownData: DeploymentStatusDetailsBreakdownDataType;
+}
+export interface AppStatusContentProps extends Required<Pick<AppStatusBodyProps, 'appDetails'>>, Partial<Pick<AppStatusBodyProps, 'handleShowConfigDriftModal'>> {
+    /**
+     * @default false
+     */
+    filterHealthyNodes?: boolean;
+    /**
+     * @default true
+     */
+    isCardLayout?: boolean;
+}
+export interface GetFilteredFlattenedNodesFromAppDetailsParamsType extends Pick<AppStatusContentProps, 'appDetails' | 'filterHealthyNodes'> {
+}
+/**
+ * Params for getAppDetails which is called in case of release [i.e, devtron apps]
+ */
+export interface GetAppDetailsParamsType extends Pick<APIOptions, 'abortControllerRef'> {
+    appId: number;
+    envId: number;
+}
+export type GetDeploymentStatusWithTimelineParamsType = Pick<APIOptions, 'abortControllerRef'> & {
+    /**
+     * Incase of helm apps this is installed app id
+     */
+    appId: number;
+    envId: number;
+    showTimeline: boolean;
+    virtualEnvironmentConfig?: {
+        processVirtualEnvironmentDeploymentData: AppStatusModalProps['processVirtualEnvironmentDeploymentData'];
+        wfrId: AppDetails['resourceTree']['wfrId'];
+    };
+    isHelmApp?: boolean;
+    deploymentAppType: DeploymentAppTypes;
+};
+export interface AppStatusModalTabListProps extends Pick<AppStatusModalProps, 'appDetails' | 'type'> {
+    handleSelectTab: (updatedTab: AppStatusModalTabType) => void;
+    selectedTab: AppStatusModalTabType;
+    deploymentStatusDetailsBreakdownData: DeploymentStatusDetailsBreakdownDataType;
+}
+export interface StatusHeadingContainerProps extends PropsWithChildren<Pick<AppStatusBodyProps, 'type'>> {
+    appId: number;
+    envId?: number;
+    actionItem?: ReactNode;
+}
+export interface InfoCardItemProps {
+    heading: string;
+    value: ReactNode;
+    isLast?: boolean;
+    alignCenter?: boolean;
+}

package/dist/Shared/Components/AppStatusModal/utils.d.ts

@@ -0,0 +1,8 @@
+import { GenericEmptyStateType } from '../../../Common/Types';
+import { AppDetails, DeploymentStatusDetailsBreakdownDataType, Node } from '../../types';
+import { AppStatusModalProps, GetFilteredFlattenedNodesFromAppDetailsParamsType as GetFlattenedNodesFromAppDetailsParamsType } from './types';
+export declare const getAppStatusMessageFromAppDetails: (appDetails: AppDetails) => string;
+export declare const getFlattenedNodesFromAppDetails: ({ appDetails, filterHealthyNodes, }: GetFlattenedNodesFromAppDetailsParamsType) => Node[];
+export declare const getResourceKey: (nodeDetails: Node) => string;
+export declare const getShowDeploymentStatusModal: ({ type, appDetails, }: Pick<AppStatusModalProps, "type" | "appDetails">) => boolean;
+export declare const getEmptyViewImageFromHelmDeploymentStatus: (status: DeploymentStatusDetailsBreakdownDataType["deploymentStatus"]) => GenericEmptyStateType["image"];

package/dist/Shared/Components/ArtifactInfoModal/ArtifactInfoModal.component.d.ts

@@ -1,3 +1,3 @@
 import { ArtifactInfoModalProps } from './types';
-declare const ArtifactInfoModal: ({ envId, ciArtifactId, handleClose, renderCIListHeader, fetchOnlyArtifactInfo, }: ArtifactInfoModalProps) => JSX.Element;
+declare const ArtifactInfoModal: ({ envId, ciArtifactId, handleClose, renderCIListHeader, fetchOnlyArtifactInfo, }: ArtifactInfoModalProps) => import("react/jsx-runtime").JSX.Element;
 export default ArtifactInfoModal;

package/dist/Shared/Components/Backdrop/Backdrop.d.ts

@@ -0,0 +1,3 @@
+import { BackdropProps } from './types';
+declare const Backdrop: ({ children, onEscape, onClick, hasClearBackground, onBackdropMount, deactivateFocusOnEscape, initialFocus, returnFocusOnDeactivate, }: BackdropProps) => import('react').ReactPortal;
+export default Backdrop;

package/dist/Shared/Components/Backdrop/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Backdrop } from './Backdrop';
+export * from './types';