@devtron-labs/devtron-fe-common-lib 1.13.0 → 1.14.0-beta-0

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;
+        hidden?: boolean;
+        prefix?: string;
+        resource?: string;
+        draggable?: boolean | "true" | "false";
+        onClick?: import('react').MouseEventHandler<HTMLDivElement>;
+        onError?: import('react').ReactEventHandler<HTMLDivElement>;
+        onChange?: import('react').FormEventHandler<HTMLDivElement>;
+        onBlur?: import('react').FocusEventHandler<HTMLDivElement>;
+        onSubmit?: import('react').FormEventHandler<HTMLDivElement>;
+        dir?: string;
+        onMouseEnter?: import('react').MouseEventHandler<HTMLDivElement>;
+        "aria-describedby"?: string;
+        "aria-errormessage"?: string;
+        "aria-label"?: string;
+        "aria-labelledby"?: string;
+        defaultChecked?: boolean;
+        suppressContentEditableWarning?: boolean;
+        suppressHydrationWarning?: boolean;
+        accessKey?: string;
+        contentEditable?: "inherit" | (boolean | "true" | "false");
+        contextMenu?: string;
+        lang?: string;
+        placeholder?: string;
+        spellCheck?: boolean | "true" | "false";
+        tabIndex?: number;
+        translate?: "no" | "yes";
+        radioGroup?: string;
+        datatype?: string;
+        inlist?: any;
+        property?: string;
+        typeof?: string;
+        vocab?: string;
+        autoCapitalize?: string;
+        autoCorrect?: string;
+        autoSave?: string;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        itemID?: string;
+        itemRef?: string;
+        results?: number;
+        security?: string;
+        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" | "copy" | "execute" | "move" | "popup";
+        "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>;
+        onBlurCapture?: import('react').FocusEventHandler<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>;
+        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>;
+        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

@@ -0,0 +1,2 @@
+import { AppStatusBodyProps } from './types';
+export declare const AppStatusBody: ({ appDetails, type, handleShowConfigDriftModal, deploymentStatusDetailsBreakdownData, selectedTab, debugWithAIButton: ExplainWithAIButton, }: AppStatusBodyProps) => 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) => 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) => 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/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, }: GetDeploymentStatusWithTimelineParamsType) => Promise<DeploymentStatusDetailsBreakdownDataType>;

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

@@ -0,0 +1,84 @@
+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;
+    isConfigDriftEnabled: boolean;
+    configDriftModal: FunctionComponent<ConfigDriftModalProps>;
+    processVirtualEnvironmentDeploymentData: (data?: DeploymentStatusDetailsType) => DeploymentStatusDetailsBreakdownDataType;
+    debugWithAIButton: FunctionComponent<{
+        intelligenceConfig: IntelligenceConfig;
+    }>;
+} & ({
+    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'>> {
+    /**
+     * @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;
+};
+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/BulkOperations/types.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { APIOptions, DrawerProps } from '../../../Common/index';
-import { SegmentedBarChartProps } from '../../../Common/SegmentedBarChart';
+import { Entity } from '@Common/SegmentedBarChart/types';
 import { ConfirmationModalProps } from '../ConfirmationModal/types';
 import { getProgressingStateForStatus } from '../Security';
 interface BulkOperationAdditionalKeysType {
@@ -36,7 +36,7 @@ export type BulkOperationResultWithIdType = BulkOperationResultType & Record<'id
 export interface OperationResultStoreType {
     addResult: (result: BulkOperationResultType) => number;
     getResults: (sortComparator: (a: BulkOperationResultType, b: BulkOperationResultType) => number) => BulkOperationResultWithIdType[];
-    getBarChartEntities: () => SegmentedBarChartProps['entities'];
+    getBarChartEntities: () => NonNullable<Entity[]>;
     getResultsStatusCount: () => Record<BulkOperationResultType['status'], number>;
     getSize: () => number;
     updateResultStatus: (id: number, result: Partial<Pick<BulkOperationResultType, 'message' | 'renderContentAtResultRowEnd'>> & (FailedOperationType | OtherStatusOperationType)) => void;

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

@@ -14,7 +14,9 @@ export declare enum ButtonStyleType {
     negativeGrey = "negative-grey",
     positive = "positive",
     warning = "warning",
-    neutral = "neutral"
+    neutral = "neutral",
+    neutralN0 = "neutral-n0",
+    neutralWhite = "neutral-white"
 }
 export declare enum ButtonComponentType {
     button = "button",

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

@@ -84,3 +84,4 @@ export declare const PROGRESSING_STATUS: {
     readonly [x: string]: "progressing" | "starting" | "initiating" | "queued" | "running";
 };
 export declare const FAILED_WORKFLOW_STAGE_STATUS_MAP: Record<Extract<WorkflowStageStatusType, WorkflowStageStatusType.ABORTED | WorkflowStageStatusType.FAILED | WorkflowStageStatusType.TIMEOUT>, true>;
+export declare const APP_HEALTH_DROP_DOWN_LIST: string[];

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

@@ -1,4 +1,3 @@
-export { default as AppStatusDetailsChart } from './AppStatusDetailsChart';
 export { default as Artifacts } from './Artifacts';
 export { default as CDEmptyState } from './CDEmptyState';
 export * from './CiPipelineSourceConfig';

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;

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

@@ -1,8 +1,8 @@
-import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { CSSProperties, MutableRefObject, ReactElement, ReactNode } from 'react';
 import { SupportedKeyboardKeysType } from '@Common/Hooks/UseRegisterShortcut/types';
 import { DeploymentAppTypes, FilterConditionsListType, ImageComment, OptionType, PaginationProps, PromotionApprovalMetadataType, ReleaseTag, ResponseType, UserApprovalMetadataType, useScrollable } from '../../../Common';
 import { DeploymentStageType } from '../../constants';
-import { AggregationKeys, GitTriggers, Node, NodeType, ResourceKindType, ResourceVersionType, TargetPlatformsDTO } from '../../types';
+import { AggregationKeys, AppDetails, DeploymentStatusDetailsBreakdownDataType, DeploymentStatusDetailsType, DeploymentStatusTimelineType, GitTriggers, Node, NodeType, ResourceKindType, ResourceVersionType, TargetPlatformsDTO } from '../../types';
 import { TargetPlatformBadgeListProps } from '../TargetPlatforms';
 export declare enum HistoryComponentType {
     CI = "CI",
@@ -296,66 +296,7 @@ export type FinishedType = {
     status?: never;
     finishedOn?: never;
 });
-export interface SyncStageResourceDetail {
-    id: number;
-    cdWorkflowRunnerId: number;
-    resourceGroup: string;
-    resourceKind: string;
-    resourceName: string;
-    resourcePhase: string;
-    resourceStatus: string;
-    statusMessage: string;
-}
-export interface DeploymentStatusDetailsTimelineType {
-    id: number;
-    cdWorkflowRunnerId: number;
-    status: string;
-    statusDetail: string;
-    statusTime: string;
-    resourceDetails?: SyncStageResourceDetail[];
-}
-export interface DeploymentStatusDetailsType extends Pick<History, 'isDeploymentWithoutApproval'> {
-    deploymentFinishedOn: string;
-    deploymentStartedOn: string;
-    triggeredBy: string;
-    statusFetchCount: number;
-    statusLastFetchedAt: string;
-    timelines: DeploymentStatusDetailsTimelineType[];
-    wfrStatus?: string;
-}
-export interface DeploymentStatusDetailsResponse extends ResponseType {
-    result?: DeploymentStatusDetailsType;
-}
-interface DeploymentStatusDetailRow {
-    icon: string;
-    displayText: ReactNode;
-    displaySubText: string;
-    time: string;
-    resourceDetails?: any;
-    isCollapsed?: boolean;
-    kubeList?: {
-        icon: any;
-        message: string;
-    }[];
-    timelineStatus?: string;
-}
-export interface DeploymentStatusDetailsBreakdownDataType {
-    deploymentStatus: string;
-    deploymentStatusText: string;
-    deploymentTriggerTime: string;
-    deploymentEndTime: string;
-    deploymentError: string;
-    triggeredBy: string;
-    nonDeploymentError: string;
-    deploymentStatusBreakdown: {
-        DEPLOYMENT_INITIATED: DeploymentStatusDetailRow;
-        GIT_COMMIT?: DeploymentStatusDetailRow;
-        ARGOCD_SYNC?: DeploymentStatusDetailRow;
-        KUBECTL_APPLY?: DeploymentStatusDetailRow;
-        APP_HEALTH?: DeploymentStatusDetailRow;
-        HELM_PACKAGE_GENERATED?: DeploymentStatusDetailRow;
-    };
-}
+export type DeploymentStatusDetailsResponse = ResponseType<DeploymentStatusDetailsType>;
 export interface DeploymentDetailStepsType extends Pick<History, 'isDeploymentWithoutApproval'> {
     deploymentStatus?: string;
     deploymentAppType?: DeploymentAppTypes;
@@ -456,19 +397,17 @@ export interface LogsRendererType extends Pick<HistoryLogsProps, 'fullScreenView
 export interface DeploymentStatusDetailBreakdownType {
     deploymentStatusDetailsBreakdownData: DeploymentStatusDetailsBreakdownDataType;
     isVirtualEnvironment?: boolean;
+    /**
+     * Won't be available if coming directly to deployment history from url
+     */
+    appDetails: AppDetails | null;
+    rootClassName?: string;
 }
-export interface DeploymentStatusDetailRowType {
-    type: string;
+export interface DeploymentStatusDetailRowType extends Pick<DeploymentStatusDetailBreakdownType, 'appDetails'> {
+    type: DeploymentStatusTimelineType;
     hideVerticalConnector?: boolean;
     deploymentDetailedData: DeploymentStatusDetailsBreakdownDataType;
 }
-export interface ErrorInfoStatusBarType {
-    nonDeploymentError: string;
-    type: string;
-    errorMessage: string;
-    hideVerticalConnector?: boolean;
-    hideErrorIcon?: boolean;
-}
 export interface DeploymentConfigurationsRes extends ResponseType {
     result?: DeploymentTemplateList[];
 }
@@ -508,12 +447,6 @@ export interface DeploymentHistorySidebarType {
     deploymentHistoryList: DeploymentTemplateList[];
     setDeploymentHistoryList: React.Dispatch<React.SetStateAction<DeploymentTemplateList[]>>;
 }
-export interface AppStatusDetailsChartType {
-    filterRemoveHealth?: boolean;
-    showFooter: boolean;
-    showConfigDriftInfo?: boolean;
-    onClose?: () => void;
-}
 export interface StatusFilterButtonType {
     nodes: Array<Node>;
     selectedTab: string;
@@ -752,6 +685,7 @@ export interface LogStageAccordionProps extends StageDetailType, Pick<LogsRender
      */
     isLoading: boolean;
     searchIndex: string;
+    logsRendererRef: MutableRefObject<HTMLDivElement>;
 }
 export interface CreateMarkupReturnType {
     __html: string;

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

@@ -1,10 +1,11 @@
 import { ReactElement } from 'react';
-import { Node } from '../../types';
-import { DeploymentHistoryResultObject, ExecutionInfoType, NodeFilters, NodeStatus, StageStatusType, TriggerHistoryFilterCriteriaProps, TriggerHistoryFilterCriteriaType, WorkflowExecutionStagesMapDTO, WorkflowStageStatusType } from './types';
+import { DeploymentAppTypes } from '../../../Common/Types';
+import { DeploymentStatusBreakdownItemType, Node } from '../../types';
+import { TabGroupProps } from '../TabGroup';
+import { DeploymentHistoryResultObject, ExecutionInfoType, History, NodeFilters, NodeStatus, StageStatusType, TriggerHistoryFilterCriteriaProps, TriggerHistoryFilterCriteriaType, WorkflowExecutionStagesMapDTO, WorkflowStageStatusType } from './types';
 export declare const getTriggerHistoryFilterCriteria: ({ appId, envId, releaseId, showCurrentReleaseDeployments, }: TriggerHistoryFilterCriteriaProps) => TriggerHistoryFilterCriteriaType;
 export declare const getParsedTriggerHistory: (result: any) => DeploymentHistoryResultObject;
 export declare const buildHoverHtmlForWebhook: (eventName: any, condition: any, selectors: any) => JSX.Element;
-export declare const renderIcon: (iconState: string) => JSX.Element;
 export declare const getStageStatusIcon: (status: StageStatusType) => JSX.Element;
 export declare const getLogSearchIndex: ({ stageIndex, lineNumberInsideStage, }: Record<"stageIndex" | "lineNumberInsideStage", number>) => string;
 export declare const sanitizeWorkflowExecutionStages: (workflowExecutionStages: WorkflowExecutionStagesMapDTO["workflowExecutionStages"]) => ExecutionInfoType | null;
@@ -36,3 +37,6 @@ export declare const getStatusFilters: ({ allNodeCount, missingNodeCount, failed
 };
 export declare const getAppStatusIcon: (status: NodeStatus | NodeFilters, hideMessage?: boolean) => JSX.Element;
 export declare const getTriggerStatusIcon: (status: string) => string;
+export declare const renderDeploymentTimelineIcon: (iconState: DeploymentStatusBreakdownItemType["icon"]) => JSX.Element;
+export declare const getDeploymentTimelineBGColorFromIcon: (icon: DeploymentStatusBreakdownItemType["icon"]) => string;
+export declare const getTriggerOutputTabs: (triggerDetails: History, deploymentAppType: DeploymentAppTypes) => TabGroupProps["tabs"];