@devtron-labs/devtron-fe-common-lib 1.13.0-redfish-preview-beta-1 → 1.14.0

package/dist/Common/Checkbox/Checkbox.d.ts

@@ -0,0 +1,2 @@
+import { CheckboxProps } from '../Types';
+export declare const Checkbox: ({ rootClassName, onClick, name, disabled, value, onChange, tabIndex, isChecked, id, dataTestId, children, }: CheckboxProps) => JSX.Element;

package/dist/Common/Checkbox/index.d.ts

@@ -0,0 +1 @@
+export * from './Checkbox';

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

@@ -13,6 +13,7 @@ export declare const DOCUMENTATION: {
     GLOBAL_CONFIG_BUILD_INFRA: string;
     ENTERPRISE_LICENSE: string;
     KUBE_CONFIG: string;
+    TENANT_INSTALLATION: string;
 };
 export declare const PATTERNS: {
     STRING: RegExp;
@@ -42,7 +43,6 @@ export declare const URLS: {
     readonly CREATE_JOB: "create-job";
     readonly GETTING_STARTED: "getting-started";
     readonly STACK_MANAGER_ABOUT: "/stack-manager/about";
-    readonly APP_LIST_HELM: "h";
     readonly APP_CI_DETAILS: "ci-details";
     readonly LOGS: "Logs";
     readonly CREATE: "/create";
@@ -64,7 +64,6 @@ export declare const URLS: {
     readonly COMPARE_CLUSTERS: "/compare-clusters";
     readonly APP_CONFIG: "edit";
     readonly GLOBAL_CONFIG: "/global-config";
-    readonly CONFIG_DRIFT: "config-drift";
     readonly GLOBAL_CONFIG_TEMPLATES_DEVTRON_APP: "/global-config/templates/devtron-apps";
     readonly GLOBAL_CONFIG_TEMPLATES_DEVTRON_APP_CREATE: "/global-config/templates/devtron-apps/create";
     readonly GLOBAL_CONFIG_TEMPLATES_DEVTRON_APP_DETAIL: "/global-config/templates/devtron-apps/detail/:appId";
@@ -111,6 +110,7 @@ export declare const ROUTES: {
     readonly ATTRIBUTES_CREATE: "attributes/create";
     readonly ATTRIBUTES_UPDATE: "attributes/update";
     readonly APP_LIST_MIN: "app/min";
+    readonly APP_DETAIL: "app/detail";
     readonly CLUSTER_LIST_MIN: "cluster/autocomplete";
     readonly CLUSTER_LIST_RAW: "k8s/capacity/cluster/list/raw";
     readonly PLUGIN_GLOBAL_LIST_DETAIL_V2: "plugin/global/list/detail/v2";

package/dist/Common/Drawer/index.d.ts

@@ -0,0 +1 @@
+export * from './Drawer';

package/dist/Common/EmptyState/index.d.ts

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

package/dist/Common/Helper.d.ts

@@ -1,7 +1,7 @@
 import { default as React, SyntheticEvent } from 'react';
 import { JSONPathOptions } from 'jsonpath-plus';
 import { AsyncOptions, DeploymentNodeType, UseSearchString } from './Types';
-import { scrollableInterface } from '../Shared';
+import { scrollableInterface, AppType } from '../Shared';
 import * as Sentry from '@sentry/browser';
 export declare function showError(serverError: any, showToastOnUnknownError?: boolean, hideAccessError?: boolean): void;
 interface ConditionalWrapper<T> {
@@ -95,8 +95,10 @@ export declare const flatMapOfJSONPaths: (paths: string[], json: object, resultT
 export declare const applyCompareDiffOnUneditedDocument: (uneditedDocument: object, editedDocument: object) => any;
 /**
  * Returns a debounced variant of the function
+ * @deprecated - It should use useRef instead, pls use useDebounce
  */
 export declare const debounce: (func: any, timeout?: number) => (this: any, ...args: any[]) => void;
+export declare const useDebounce: <Callback extends (...args: any[]) => void>(cb: Callback, delay: number) => (...args: Parameters<Callback>) => void;
 /**
  * Returns a capitalized string with first letter in uppercase and rest in lowercase
  */
@@ -144,4 +146,6 @@ 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/Common/Toggle/Toggle.d.ts

@@ -1,4 +1,5 @@
-declare const Toggle: ({ selected, onSelect, color, rootClassName, disabled, dataTestId, Icon, iconClass, throttleOnChange, shouldToggleValueOnLabelClick, isLoading, ...props }: {
+import { CHECKBOX_VALUE } from '../Types';
+declare const Toggle: ({ selected, onSelect, color, rootClassName, disabled, dataTestId, Icon, iconClass, throttleOnChange, shouldToggleValueOnLabelClick, isLoading, value, isControlled, ...props }: {
     [x: string]: any;
     selected?: boolean;
     onSelect?: any;
@@ -11,5 +12,7 @@ declare const Toggle: ({ selected, onSelect, color, rootClassName, disabled, dat
     throttleOnChange?: boolean;
     shouldToggleValueOnLabelClick?: boolean;
     isLoading?: boolean;
+    value?: CHECKBOX_VALUE;
+    isControlled?: boolean;
 }) => JSX.Element;
 export default Toggle;

package/dist/Common/Types.d.ts

@@ -75,6 +75,7 @@ export interface CheckboxProps {
     onClick?: (event: any) => void;
     id?: string;
     dataTestId?: string;
+    children?: ReactNode;
 }
 export interface TippyCustomizedProps extends Pick<TippyProps, 'appendTo'> {
     theme: TippyTheme;
@@ -110,6 +111,7 @@ export interface InfoIconTippyProps extends Pick<TippyCustomizedProps, 'heading'
     dataTestid?: string;
     children?: TippyCustomizedProps['children'];
     iconClassName?: string;
+    buttonPadding?: string;
 }
 export interface GenericEmptyStateType {
     title: ReactNode;

package/dist/Common/index.d.ts

@@ -15,9 +15,8 @@ export { default as DevtronCopyright } from './DevtronCopyright';
 export * from './DevtronProgressing';
 export * from './Dialogs';
 export * from './DraggableWrapper';
-export * from './Drawer/Drawer';
-export { default as GenericEmptyState } from './EmptyState/GenericEmptyState';
-export { default as GenericFilterEmptyState } from './EmptyState/GenericFilterEmptyState';
+export * from './Drawer';
+export * from './EmptyState';
 export { default as ErrorScreenManager } from './ErrorScreenManager';
 export { default as ErrorScreenNotAuthorized } from './ErrorScreenNotAuthorized';
 export * from './GenericDescription';

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,11 +1,21 @@
 import { Dispatch, ReactElement, SetStateAction } from 'react';
 import { TabProps } from '../../Shared/Components';
+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",
@@ -43,6 +53,7 @@ export interface ClusterCapacityType {
     nodeErrors: Record<string, string>[];
     status?: ClusterStatusType;
     isProd: boolean;
+    installationId?: number;
 }
 export interface ClusterDetail extends ClusterCapacityType {
     id: number;
@@ -75,4 +86,31 @@ export type NodeDetailTabsInfoType = (Pick<TabProps, 'label' | 'icon'> & {
     id: string;
     renderComponent: () => JSX.Element;
 })[];
+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>;
+};