@devtron-labs/devtron-fe-common-lib 1.13.0-pre-3 → 1.13.0-pre-5

package/dist/Common/Common.service.d.ts

@@ -1,6 +1,6 @@
 import { MutableRefObject } from 'react';
 import { RuntimeParamsAPIResponseType, RuntimePluginVariables } from '../Shared/types';
-import { TeamList, ResponseType, DeploymentNodeType, CDMaterialServiceEnum, CDMaterialServiceQueryParams, CDMaterialResponseType, CDMaterialFilterQuery, EnvironmentListHelmResponse, UserApprovalMetadataType, GlobalVariableOptionType, UserRole, EnvAppsMetaDTO, GetAppsInfoForEnvProps } from './Types';
+import { TeamList, ResponseType, DeploymentNodeType, CDMaterialServiceEnum, CDMaterialServiceQueryParams, CDMaterialResponseType, CDMaterialFilterQuery, EnvironmentListHelmResponse, UserApprovalMetadataType, GlobalVariableOptionType, UserRole, APIOptions, EnvAppsMetaDTO, GetAppsInfoForEnvProps } from './Types';
 import { ApiResourceType } from '../Pages';
 export declare const getTeamListMin: () => Promise<TeamList>;
 export declare const SourceTypeMap: {
@@ -21,7 +21,7 @@ export declare const getDefaultConfig: () => Promise<ResponseType>;
 export declare function getEnvironmentListMinPublic(includeAllowedDeploymentTypes?: boolean): Promise<ResponseType<any>>;
 export declare function getClusterListMin(): Promise<ResponseType<any>>;
 export declare const getResourceGroupListRaw: (clusterId: string) => Promise<ResponseType<ApiResourceType>>;
-export declare function getNamespaceListMin(clusterIdsCsv: string): Promise<EnvironmentListHelmResponse>;
+export declare function getNamespaceListMin(clusterIdsCsv: string, abortControllerRef?: APIOptions['abortControllerRef']): Promise<EnvironmentListHelmResponse>;
 export declare function getWebhookEventsForEventId(eventId: string | number): Promise<ResponseType<any>>;
 /**
  *

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/Pages/GlobalConfigurations/ClustersAndEnvironments/index.d.ts

@@ -0,0 +1 @@
+export type { NewClusterFormFooterProps, NewClusterFormProps } from './types';

package/dist/Pages/GlobalConfigurations/ClustersAndEnvironments/types.d.ts

@@ -0,0 +1,8 @@
+export interface NewClusterFormFooterProps {
+    apiCallInProgress: boolean;
+    handleModalClose: () => void;
+    closeButtonText?: string;
+}
+export interface NewClusterFormProps extends Pick<NewClusterFormFooterProps, 'handleModalClose'> {
+    FooterComponent: React.FunctionComponent<NewClusterFormFooterProps> & Record<'CTA' | 'Start', React.FunctionComponent<{}>>;
+}

package/dist/Pages/GlobalConfigurations/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Authorization';
 export * from './BuildInfra';
+export * from './ClustersAndEnvironments';
 export * from './DeploymentCharts';
 export * from './ScopedVariables';

package/dist/Pages/ResourceBrowser/service.d.ts

@@ -7,4 +7,4 @@ export declare const deleteResource: (resourceListPayload: ResourceListPayloadTy
 export declare const deleteNodeCapacity: (requestPayload: NodeActionRequest, abortControllerRef?: APIOptions["abortControllerRef"]) => Promise<ResponseType>;
 export declare const cordonNodeCapacity: (requestPayload: NodeCordonRequest, abortControllerRef?: APIOptions["abortControllerRef"]) => Promise<ResponseType>;
 export declare const drainNodeCapacity: (requestPayload: NodeActionRequest, abortControllerRef?: APIOptions["abortControllerRef"]) => Promise<ResponseType>;
-export declare const getClusterListRaw: () => Promise<ResponseType<ClusterDetail[]>>;
+export declare const getClusterListRaw: (abortControllerRef?: APIOptions["abortControllerRef"]) => Promise<ResponseType<ClusterDetail[]>>;

package/dist/Pages/ResourceBrowser/types.d.ts

@@ -1,10 +1,20 @@
 import { Dispatch, ReactElement, SetStateAction } from 'react';
+import { InstallationClusterType } from '../../Shared/types';
 import { NodeActionRequest } from './ResourceBrowser.Types';
 export declare enum ClusterFiltersType {
     ALL_CLUSTERS = "all",
     HEALTHY = "healthy",
     UNHEALTHY = "unhealthy"
 }
+export declare enum InstallationClusterStatus {
+    Creating = "Creating",
+    Updated = "Updated",
+    Updating = "Updating",
+    Installed = "Installed",
+    Failed = "Failed",
+    Deleting = "Deleting",
+    Deleted = "Deleted"
+}
 export declare enum ClusterStatusType {
     HEALTHY = "healthy",
     UNHEALTHY = "unhealthy",
@@ -42,6 +52,7 @@ export interface ClusterCapacityType {
     nodeErrors: Record<string, string>[];
     status?: ClusterStatusType;
     isProd: boolean;
+    installationId?: number;
 }
 export interface ClusterDetail extends ClusterCapacityType {
     id: number;
@@ -70,4 +81,31 @@ export interface AdditionalConfirmationModalOptionsProps<T = unknown> {
     setOptionsData: Dispatch<SetStateAction<T>>;
     children?: ReactElement;
 }
+export interface InstallationClusterStepType {
+    lastTransitionTime: string;
+    lastProbeTime: string;
+    message: string;
+    reason: string;
+    status: 'False' | 'True' | 'Unknown';
+    type: string;
+}
+export interface InstallationClusterConfigDTO {
+    installationId: number;
+    installationStatus: InstallationClusterStatus;
+    name: string;
+    values: string;
+    valuesSchema: string;
+    isProd: boolean;
+    installationType: InstallationClusterType;
+    conditions: InstallationClusterStepType[];
+    installedEntityId: number | 0;
+}
+export interface InstallationClusterConfigType extends Pick<InstallationClusterConfigDTO, 'installationType' | 'conditions'> {
+    schema: object;
+    values: object;
+    installationId: number;
+    name: string;
+    status: InstallationClusterStatus;
+    correspondingClusterId: number | 0;
+}
 export {};

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/Header/HeaderWithCreateButton/HeaderWithCreateButon.d.ts

@@ -1,5 +1,3 @@
-export interface HeaderWithCreateButtonProps {
-    headerName: string;
-}
+import { HeaderWithCreateButtonProps } from './types';
 export declare const HeaderWithCreateButton: ({ headerName }: HeaderWithCreateButtonProps) => JSX.Element;
 export default HeaderWithCreateButton;

package/dist/Shared/Components/Header/HeaderWithCreateButton/types.d.ts

@@ -0,0 +1,10 @@
+import { ActionMenuProps } from '@Shared/Components/ActionMenu';
+export interface HeaderWithCreateButtonProps {
+    headerName: string;
+}
+export declare enum CreateActionMenuItems {
+    CUSTOM_APP = "create-custom-app",
+    CHART_STORE = "create-from-chart-store",
+    JOB = "create-job"
+}
+export type CreateActionMenuProps = ActionMenuProps<CreateActionMenuItems>;

package/dist/Shared/Components/Header/HeaderWithCreateButton/utils.d.ts

@@ -0,0 +1,2 @@
+import { CreateActionMenuProps } from './types';
+export declare const getCreateActionMenuOptions: (createCustomAppURL: string) => CreateActionMenuProps["options"];

package/dist/Shared/Components/Header/HelpButton.d.ts

@@ -0,0 +1,2 @@
+import { HelpButtonProps } from './types';
+export declare const HelpButton: ({ serverInfo, fetchingServerInfo, onClick }: HelpButtonProps) => JSX.Element;

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

@@ -1,4 +1,5 @@
-import { HelpOptionType } from './types';
-export declare const EnterpriseHelpOptions: HelpOptionType[];
-export declare const OSSHelpOptions: HelpOptionType[];
-export declare const TrialHelpOptions: HelpOptionType[];
+import { HelpButtonActionMenuProps } from './types';
+export declare const COMMON_HELP_ACTION_MENU_ITEMS: HelpButtonActionMenuProps['options'][number]['items'];
+export declare const OSS_HELP_ACTION_MENU_ITEMS: HelpButtonActionMenuProps['options'][number]['items'];
+export declare const ENTERPRISE_TRIAL_HELP_ACTION_MENU_ITEMS: HelpButtonActionMenuProps['options'][number]['items'];
+export declare const ENTERPRISE_HELP_ACTION_MENU_ITEMS: HelpButtonActionMenuProps['options'][number]['items'];

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

@@ -1,5 +1,6 @@
 import { ModuleStatus } from '../../types';
 import { ResponseType, TippyCustomizedProps } from '../../../Common';
+import { ActionMenuProps } from '../ActionMenu';
 export declare enum InstallationType {
     OSS_KUBECTL = "oss_kubectl",
     OSS_HELM = "oss_helm",
@@ -33,16 +34,21 @@ export interface ServerInfo {
 export interface ServerInfoResponse extends ResponseType {
     result?: ServerInfo;
 }
-export interface HelpNavType {
-    className: string;
-    setShowHelpCard: React.Dispatch<React.SetStateAction<boolean>>;
+export interface HelpButtonProps {
     serverInfo: ServerInfo;
     fetchingServerInfo: boolean;
-    setGettingStartedClicked: (isClicked: boolean) => void;
-    showHelpCard: boolean;
+    onClick: () => void;
 }
-export interface HelpOptionType {
-    name: string;
-    link: string;
-    icon: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+export declare enum HelpMenuItems {
+    GETTING_STARTED = "getting-started",
+    VIEW_DOCUMENTATION = "view-documentation",
+    JOIN_DISCORD_COMMUNITY = "join-discord-community",
+    ABOUT_DEVTRON = "about-devtron",
+    REQUEST_SUPPORT = "request-support",
+    OPEN_NEW_TICKET = "open-new-ticket",
+    VIEW_ALL_TICKETS = "view-all-tickets",
+    GIVE_FEEDBACK = "give-feedback",
+    CHAT_WITH_SUPPORT = "chat-with-support",
+    RAISE_ISSUE_REQUEST = "raise-issue-request"
 }
+export type HelpButtonActionMenuProps = ActionMenuProps<HelpMenuItems>;

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

@@ -1,6 +1,10 @@
 import { DevtronLicenseInfo } from '../License';
+import { HelpButtonActionMenuProps } from './types';
 export declare const getDateInMilliseconds: (days: any) => number;
 export declare const handlePostHogEventUpdate: (eventName: string) => Promise<void>;
 export declare const setActionWithExpiry: (key: string, days: number) => void;
 export declare const getIsShowingLicenseData: (licenseData: DevtronLicenseInfo) => boolean;
-export declare const getHelpOptions: (isEnterprise: boolean, isTrial: boolean) => import('./types').HelpOptionType[];
+export declare const getHelpActionMenuOptions: ({ isEnterprise, isTrial, }: {
+    isEnterprise: boolean;
+    isTrial: boolean;
+}) => HelpButtonActionMenuProps["options"];