@devtron-labs/devtron-fe-common-lib 1.13.0-pre-4 → 1.13.0-pre-6

package/dist/Common/Helper.d.ts

@@ -147,4 +147,5 @@ export declare const getGoLangFormattedDateWithTimezone: (dateFormat: string) =>
 export declare const getHashedValue: (value: string) => Promise<string | null>;
 export declare const getTTLInHumanReadableFormat: (ttl: number) => string;
 export declare const getAIAnalyticsEvents: (context: string, appType?: AppType) => string;
+export declare const findRight: <T>(arr: T[], predicate: (item: T) => boolean) => T | null;
 export {};

package/dist/Common/RJSF/Form.d.ts

@@ -1,3 +1,3 @@
 import { default as RJSF } from '@rjsf/core';
 import { FormProps } from './types';
-export declare const RJSFForm: import('react').ForwardRefExoticComponent<Pick<FormProps, "children" | "className" | "name" | "id" | "disabled" | "action" | "target" | "onFocus" | "onBlur" | "onChange" | "onSubmit" | "onError" | "method" | "autoComplete" | "tagName" | "noValidate" | "readonly" | "uiSchema" | "schema" | "formContext" | "formData" | "idPrefix" | "idSeparator" | "fields" | "templates" | "widgets" | "translateString" | "acceptcharset" | "acceptCharset" | "enctype" | "customValidate" | "extraErrors" | "extraErrorsBlockSubmit" | "noHtml5Validate" | "liveValidate" | "liveOmit" | "omitExtraData" | "showErrorList" | "transformErrors" | "focusOnFirstError" | "experimental_defaultFormStateBehavior" | "_internalFormWrapper"> & import('react').RefAttributes<RJSF<any, import('./types').RJSFFormSchema, any>>>;
+export declare const RJSFForm: import('react').ForwardRefExoticComponent<Pick<FormProps, "children" | "className" | "name" | "id" | "disabled" | "target" | "onFocus" | "onBlur" | "onChange" | "onSubmit" | "onError" | "autoComplete" | "method" | "action" | "tagName" | "noValidate" | "readonly" | "uiSchema" | "schema" | "formContext" | "formData" | "idPrefix" | "idSeparator" | "fields" | "templates" | "widgets" | "translateString" | "acceptcharset" | "acceptCharset" | "enctype" | "customValidate" | "extraErrors" | "extraErrorsBlockSubmit" | "noHtml5Validate" | "liveValidate" | "liveOmit" | "omitExtraData" | "showErrorList" | "transformErrors" | "focusOnFirstError" | "experimental_defaultFormStateBehavior" | "_internalFormWrapper"> & import('react').RefAttributes<RJSF<any, import('./types').RJSFFormSchema, any>>>;

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

@@ -1,3 +1,2 @@
 import { ActionMenuProps } from './types';
-declare const ActionMenu: ({ options, disableDescriptionEllipsis, children, onClick }: ActionMenuProps) => JSX.Element;
-export default ActionMenu;
+export declare const ActionMenu: <T extends string | number = string | number>({ id, options, onClick, position, alignment, width, isSearchable, disableDescriptionEllipsis, buttonProps, children, onOpen, footerConfig, }: ActionMenuProps<T>) => JSX.Element;

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>) => JSX.Element;

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

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

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

@@ -1,19 +1,96 @@
-import { ReactElement } from 'react';
-import { GroupBase, OptionsOrGroups } from 'react-select';
+import { LegacyRef, Ref } from 'react';
+import { LinkProps } from 'react-router-dom';
+import { IconsProps } from '../Icon';
+import { PopoverProps, UsePopoverProps } from '../Popover';
 import { SelectPickerOptionType, SelectPickerProps } from '../SelectPicker';
-type ActionMenuOptionType = SelectPickerOptionType & {
+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;
+};
+type ActionMenuItemIconType = Pick<IconsProps, 'name'> & {
+    /** @default 'N800' */
+    color?: IconsProps['color'];
+};
+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 icon to be displayed at the end of the menu item. */
+    endIcon?: ActionMenuItemIconType;
+} & 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>) => 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 interface ActionMenuProps extends Pick<SelectPickerProps, 'disableDescriptionEllipsis'> {
-    children: ReactElement;
-    options: OptionsOrGroups<ActionMenuOptionType, GroupBase<ActionMenuOptionType>>;
-    onClick: (option: SelectPickerOptionType) => void;
-}
-export interface ActionMenuOptionProps extends Pick<ActionMenuProps, 'onClick' | 'disableDescriptionEllipsis'> {
-    option: ActionMenuOptionType;
-}
 export {};

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

@@ -0,0 +1,275 @@
+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: import('react').MutableRefObject<RefObject<HTMLAnchorElement | HTMLButtonElement>[]>;
+    triggerProps: import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+    overlayProps: import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+    popoverProps: {
+        slot?: string;
+        title?: string;
+        children?: import('react').ReactNode;
+        className?: string;
+        defaultValue?: string | number | readonly string[];
+        id?: string;
+        color?: string;
+        role?: import('react').AriaRole;
+        about?: string;
+        is?: string;
+        security?: string;
+        onMouseEnter?: import('react').MouseEventHandler<HTMLDivElement>;
+        "aria-describedby"?: string;
+        "aria-errormessage"?: string;
+        "aria-label"?: string;
+        "aria-labelledby"?: string;
+        onClick?: import('react').MouseEventHandler<HTMLDivElement>;
+        defaultChecked?: boolean;
+        suppressContentEditableWarning?: boolean;
+        suppressHydrationWarning?: boolean;
+        accessKey?: string;
+        contentEditable?: "inherit" | (boolean | "true" | "false");
+        contextMenu?: string;
+        dir?: string;
+        draggable?: boolean | "true" | "false";
+        hidden?: boolean;
+        lang?: string;
+        placeholder?: string;
+        spellCheck?: boolean | "true" | "false";
+        tabIndex?: number;
+        translate?: "no" | "yes";
+        radioGroup?: string;
+        datatype?: string;
+        inlist?: any;
+        prefix?: string;
+        property?: string;
+        resource?: string;
+        typeof?: string;
+        vocab?: string;
+        autoCapitalize?: string;
+        autoCorrect?: string;
+        autoSave?: string;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        itemID?: string;
+        itemRef?: string;
+        results?: number;
+        unselectable?: "on" | "off";
+        inputMode?: "search" | "text" | "none" | "url" | "tel" | "email" | "numeric" | "decimal";
+        "aria-activedescendant"?: string;
+        "aria-atomic"?: boolean | "true" | "false";
+        "aria-autocomplete"?: "list" | "none" | "inline" | "both";
+        "aria-busy"?: boolean | "true" | "false";
+        "aria-checked"?: boolean | "true" | "false" | "mixed";
+        "aria-colcount"?: number;
+        "aria-colindex"?: number;
+        "aria-colspan"?: number;
+        "aria-controls"?: string;
+        "aria-current"?: boolean | "time" | "true" | "false" | "page" | "step" | "location" | "date";
+        "aria-details"?: string;
+        "aria-disabled"?: boolean | "true" | "false";
+        "aria-dropeffect"?: "link" | "none" | "popup" | "copy" | "execute" | "move";
+        "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-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"?: "text" | "all" | "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-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;
+        };
+        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').FormEventHandler<HTMLDivElement>;
+        onChangeCapture?: import('react').FormEventHandler<HTMLDivElement>;
+        onBeforeInput?: import('react').FormEventHandler<HTMLDivElement>;
+        onBeforeInputCapture?: import('react').FormEventHandler<HTMLDivElement>;
+        onInput?: import('react').FormEventHandler<HTMLDivElement>;
+        onInputCapture?: import('react').FormEventHandler<HTMLDivElement>;
+        onReset?: import('react').FormEventHandler<HTMLDivElement>;
+        onResetCapture?: import('react').FormEventHandler<HTMLDivElement>;
+        onSubmit?: import('react').FormEventHandler<HTMLDivElement>;
+        onSubmitCapture?: import('react').FormEventHandler<HTMLDivElement>;
+        onInvalid?: import('react').FormEventHandler<HTMLDivElement>;
+        onInvalidCapture?: import('react').FormEventHandler<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>;
+        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>;
+        onPointerEnterCapture?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerLeave?: import('react').PointerEventHandler<HTMLDivElement>;
+        onPointerLeaveCapture?: 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>;
+        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>;
+        onTransitionEnd?: import('react').TransitionEventHandler<HTMLDivElement>;
+        onTransitionEndCapture?: 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<HTMLElement>;
+};

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/AppStatusModal/AppStatusBody.d.ts

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

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

@@ -1,3 +1,3 @@
 import { AppStatusModalProps } from './types';
-declare const AppStatusModal: ({ titleSegments, handleClose, type, appDetails: appDetailsProp, isConfigDriftEnabled, configDriftModal: ConfigDriftModal, appId, envId, debugWithAIButton, }: AppStatusModalProps) => JSX.Element;
+declare const AppStatusModal: ({ titleSegments, handleClose, type, appDetails: appDetailsProp, processVirtualEnvironmentDeploymentData, updateDeploymentStatusDetailsBreakdownData, isConfigDriftEnabled, configDriftModal: ConfigDriftModal, appId, envId, initialTab, debugWithAIButton, }: AppStatusModalProps) => 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) => JSX.Element;
+export default AppStatusModalTabList;

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

@@ -1,2 +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

@@ -1,3 +1,4 @@
-import { APIOptions } from '../../../Common/Types';
-import { AppDetails } from '../../types';
-export declare const getAppDetails: (appId: number, envId: number, abortControllerRef: APIOptions["abortControllerRef"]) => Promise<AppDetails>;
+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, }: GetDeploymentStatusWithTimelineParamsType) => Promise<DeploymentStatusDetailsBreakdownDataType>;

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

@@ -1,14 +1,16 @@
-import { FunctionComponent } from 'react';
-import { AppDetails, ConfigDriftModalProps, IntelligenceConfig } from '../../types';
+import { FunctionComponent, PropsWithChildren, ReactNode } from 'react';
+import { APIOptions } from '../../../Common/Types';
+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;
-    /**
-     * If given would not poll for app details and resource tree, Polling for gitops timeline would still be done
-     */
-    appDetails?: AppDetails;
     isConfigDriftEnabled: boolean;
     configDriftModal: FunctionComponent<ConfigDriftModalProps>;
+    processVirtualEnvironmentDeploymentData: (data?: DeploymentStatusDetailsType) => DeploymentStatusDetailsBreakdownDataType;
     debugWithAIButton: FunctionComponent<{
         intelligenceConfig: IntelligenceConfig;
     }>;
@@ -16,13 +18,21 @@ export type AppStatusModalProps = {
     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'>> {
     handleShowConfigDriftModal: () => void;
+    selectedTab: AppStatusModalTabType;
+    deploymentStatusDetailsBreakdownData: DeploymentStatusDetailsBreakdownDataType;
 }
 export interface AppStatusContentProps extends Required<Pick<AppStatusBodyProps, 'appDetails'>>, Partial<Pick<AppStatusBodyProps, 'handleShowConfigDriftModal'>> {
     /**
@@ -36,3 +46,39 @@ export interface AppStatusContentProps extends Required<Pick<AppStatusBodyProps,
 }
 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;
+};
+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

@@ -1,5 +1,8 @@
-import { AppDetails, Node } from '../../types';
-import { GetFilteredFlattenedNodesFromAppDetailsParamsType as GetFlattenedNodesFromAppDetailsParamsType } from './types';
+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/CICDHistory/DeploymentStatusBreakdown.d.ts

@@ -1,3 +1,3 @@
 import { DeploymentStatusDetailBreakdownType } from './types';
-declare const DeploymentStatusDetailBreakdown: ({ deploymentStatusDetailsBreakdownData, isVirtualEnvironment, }: DeploymentStatusDetailBreakdownType) => JSX.Element;
+declare const DeploymentStatusDetailBreakdown: ({ deploymentStatusDetailsBreakdownData, isVirtualEnvironment, appDetails, rootClassName, }: DeploymentStatusDetailBreakdownType) => JSX.Element;
 export default DeploymentStatusDetailBreakdown;

package/dist/Shared/Components/CICDHistory/DeploymentStatusDetailRow.d.ts

@@ -1,2 +1,2 @@
 import { DeploymentStatusDetailRowType } from './types';
-export declare const DeploymentStatusDetailRow: ({ type, hideVerticalConnector, deploymentDetailedData, }: DeploymentStatusDetailRowType) => JSX.Element;
+export declare const DeploymentStatusDetailRow: ({ type, hideVerticalConnector, deploymentDetailedData, appDetails, }: DeploymentStatusDetailRowType) => JSX.Element;

package/dist/Shared/Components/CICDHistory/LogStageAccordion.d.ts

@@ -1,3 +1,3 @@
 import { LogStageAccordionProps } from './types';
-declare const LogStageAccordion: ({ stage, isOpen, logs, endTime, startTime, status, handleStageClose, handleStageOpen, stageIndex, isLoading, fullScreenView, searchIndex, targetPlatforms, }: LogStageAccordionProps) => JSX.Element;
+declare const LogStageAccordion: ({ stage, isOpen, logs, endTime, startTime, status, handleStageClose, handleStageOpen, stageIndex, isLoading, fullScreenView, searchIndex, targetPlatforms, logsRendererRef, }: LogStageAccordionProps) => JSX.Element;
 export default LogStageAccordion;

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

@@ -10,6 +10,9 @@ export declare function getTriggerDetails({ appId, envId, pipelineId, triggerId,
 export declare const getTagDetails: (params: any) => Promise<ResponseType<any>>;
 export declare const cancelCiTrigger: (params: any, isForceAbort: any) => Promise<ResponseType<any>>;
 export declare const cancelPrePostCdTrigger: (pipelineId: any, workflowRunner: any, isForceAbort: boolean) => Promise<ResponseType<any>>;
+/**
+ * @deprecated
+ */
 export declare function getDeploymentStatusDetail(appId: string, envId: string, showTimeline: boolean, triggerId?: string, isHelmApps?: boolean, installedAppVersionHistoryId?: number): Promise<DeploymentStatusDetailsResponse>;
 export declare function getManualSync(params: {
     appId: string;