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

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

@@ -0,0 +1,3 @@
+import { SwitchThemeDialogProps } from './types';
+declare const SwitchThemeDialog: ({ initialThemePreference, handleClose, handleUpdateUserThemePreference, disableAPICalls, }: SwitchThemeDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default SwitchThemeDialog;

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

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

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

@@ -0,0 +1,35 @@
+import { AppThemeType, useTheme } from '../../Providers';
+type ThemePreferenceType = ReturnType<typeof useTheme>['themePreference'];
+export type SwitchThemeDialogProps = {
+    /**
+     * @description The initial theme preference of the user fetched from api, in case of error would be null
+     */
+    initialThemePreference: ThemePreferenceType;
+    handleUpdateUserThemePreference: (themePreference: ThemePreferenceType) => void;
+    handleClose: () => void;
+} & ({
+    /**
+     * @default false
+     * @description Required for storybook
+     */
+    disableAPICalls?: false;
+} | {
+    currentUserPreferences?: never;
+    disableAPICalls: true;
+});
+export interface ThemePreferenceOptionProps {
+    selectedThemePreference: SwitchThemeDialogProps['initialThemePreference'];
+    value: SwitchThemeDialogProps['initialThemePreference'];
+    handleChangedThemePreference: (themePreference: SwitchThemeDialogProps['initialThemePreference']) => void;
+}
+export interface ThemePreferenceLabelFigureProps extends Pick<ThemePreferenceOptionProps, 'value'> {
+    isSelected: boolean;
+}
+export interface BaseLabelFigureProps extends Pick<ThemePreferenceLabelFigureProps, 'isSelected'> {
+    value: AppThemeType;
+    /**
+     * @default false
+     */
+    noLeftRadius?: boolean;
+}
+export {};

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

@@ -1,2 +1,2 @@
 import { TabGroupProps } from './TabGroup.types';
-export declare const TabGroup: ({ tabs, size, rightComponent, alignActiveBorderWithContainer, hideTopPadding, }: TabGroupProps) => JSX.Element;
+export declare const TabGroup: ({ tabs, size, rightComponent, hideTopPadding, }: TabGroupProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Components/TabGroup/TabGroup.helpers.d.ts

@@ -1,7 +1,7 @@
-import { TabProps } from './TabGroup.types';
-export declare const getTabIcon: ({ icon: Icon, showError, showWarning, className, }: Pick<TabProps, "showError" | "showWarning" | "icon"> & {
+import { TabGroupProps, TabProps } from './TabGroup.types';
+export declare const getTabIcon: ({ icon, showError, showWarning, className, size, active, iconElement, }: Pick<TabProps, "showError" | "showWarning" | "icon" | "active" | "iconElement"> & Pick<TabGroupProps, "size"> & {
     className: string;
-}) => JSX.Element;
-export declare const getTabBadge: (badge: TabProps["badge"], className: string) => JSX.Element;
-export declare const getTabIndicator: (showIndicator: TabProps["showIndicator"]) => JSX.Element;
-export declare const getTabDescription: (description: TabProps["description"]) => JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const getTabBadge: (badge: TabProps["badge"], className: string) => import("react/jsx-runtime").JSX.Element;
+export declare const getTabIndicator: (showIndicator: TabProps["showIndicator"]) => import("react/jsx-runtime").JSX.Element;
+export declare const getTabDescription: (description: TabProps["description"]) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,6 +1,9 @@
+import { JSX } from 'react';
 import { LinkProps, NavLinkProps } from 'react-router-dom';
+import { TooltipProps } from '../../../Common/Tooltip';
 import { ComponentSizeType } from '../../constants';
 import { DataAttributes } from '../../types';
+import { IconName } from '../Icon';
 type TabComponentProps<TabTypeProps> = TabTypeProps & DataAttributes;
 type ConditionalTabType = {
     /**
@@ -56,6 +59,45 @@ type ConditionalTabType = {
      */
     active?: never | false;
 };
+type TabTooltipProps = {
+    shouldWrapTooltip: boolean;
+    tooltipProps: TooltipProps;
+} | {
+    shouldWrapTooltip?: never;
+    tooltipProps?: never;
+};
+/**
+ * Represents the properties for defining an icon in a tab group.
+ * This type allows for three configurations:
+ *
+ * 1. **Icon as a functional component or string**:
+ *    - Use the `icon` property to specify either a functional component that renders an SVG or a string representing the name of the icon.
+ *    - The `iconElement` property must not be provided in this case.
+ *
+ * 2. **Icon as a JSX element**:
+ *    - Use the `iconElement` property to specify a JSX element representing the icon.
+ *    - The `icon` property must not be provided in this case.
+ *
+ * 3. **No icon**:
+ *    - Neither `icon` nor `iconElement` is provided, resulting in no icon being displayed.
+ *
+ */
+type TabGroupIconProp = {
+    /**
+     * A functional component rendering an SVG or a string representing the icon name. Mutually exclusive with `iconElement`.
+     */
+    icon: React.FunctionComponent<React.SVGProps<SVGSVGElement>> | IconName;
+    iconElement?: never;
+} | {
+    icon?: never;
+    /**
+     * A JSX element representing the icon. Mutually exclusive with `icon`.
+     */
+    iconElement: JSX.Element;
+} | {
+    icon?: never;
+    iconElement?: never;
+};
 export type TabProps = {
     /**
      * Unique identifier for the tab.
@@ -70,11 +112,6 @@ export type TabProps = {
      * @note - If passed as a `string[]`, it will be rendered with a bullet in-between strings.
      */
     description?: string | string[];
-    /**
-     * Icon component to be displayed in the tab.
-     * This should be a functional component that renders an SVG.
-     */
-    icon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
     /**
      * Badge number to be displayed on the tab, typically for notifications.
      */
@@ -97,7 +134,7 @@ export type TabProps = {
      * Disables the tab, preventing interaction and indicating an inactive state.
      */
     disabled?: boolean;
-} & ConditionalTabType;
+} & ConditionalTabType & TabTooltipProps & TabGroupIconProp;
 export interface TabGroupProps {
     /**
      * Array of tabs to be rendered.
@@ -112,15 +149,13 @@ export interface TabGroupProps {
      * Optional component to be rendered on the right side of the tab list.
      */
     rightComponent?: React.ReactElement;
-    /**
-     * Set to `true` to align the active tab's border with the bottom border of the parent container.
-     * @default false
-     */
-    alignActiveBorderWithContainer?: boolean;
     /**
      * Determines if the top padding of the tab group should be hidden.
      * @default false
      */
     hideTopPadding?: boolean;
 }
+export type AdditionalTabProps = {
+    uniqueGroupId: string;
+};
 export {};

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

@@ -1,7 +1,9 @@
+import { IconsProps } from '../Icon';
 import { TabGroupProps } from './TabGroup.types';
-export declare const getClassNameBySizeMap: ({ hideTopPadding, alignActiveBorderWithContainer, }: Pick<TabGroupProps, "hideTopPadding" | "alignActiveBorderWithContainer">) => Record<TabGroupProps["size"], {
+export declare const getClassNameBySizeMap: ({ hideTopPadding, }: Pick<TabGroupProps, "hideTopPadding">) => Record<TabGroupProps["size"], {
     tabClassName: string;
     iconClassName: string;
     badgeClassName: string;
 }>;
+export declare const TAB_ICON_SIZE_MAP: Record<TabGroupProps['size'], IconsProps['size']>;
 export declare const tabGroupClassMap: Record<TabGroupProps['size'], string>;

package/dist/Shared/Components/Table/BulkSelectionActionWidget.d.ts

@@ -0,0 +1,3 @@
+import { BulkSelectionActionWidgetProps } from './types';
+declare const BulkSelectionActionWidget: ({ count, handleClearBulkSelection, parentRef, BulkActionsComponent, bulkActionsData, setBulkActionState, }: BulkSelectionActionWidgetProps) => import("react/jsx-runtime").JSX.Element;
+export default BulkSelectionActionWidget;

package/dist/Shared/Components/Table/InternalTable.d.ts

@@ -0,0 +1,3 @@
+import { FiltersTypeEnum, InternalTableProps } from './types';
+declare const InternalTable: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>({ filtersVariant, filterData, rows, getRows, columns, ViewWrapper, resizableConfig, emptyStateConfig, additionalProps, areColumnsConfigurable, filter, setVisibleColumns, visibleColumns, stylesConfig, loading, bulkSelectionConfig, bulkSelectionReturnValue, id, handleClearBulkSelection, handleToggleBulkSelectionOnRow, paginationVariant, rowActionOnHoverConfig, pageSizeOptions, clearFilters: userGivenUrlClearFilters, rowStartIconConfig, onRowClick, areFiltersApplied: userProvidedAreFiltersApplied, }: InternalTableProps<RowData, FilterVariant, AdditionalProps>) => import("react/jsx-runtime").JSX.Element;
+export default InternalTable;

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

@@ -0,0 +1,3 @@
+import { FiltersTypeEnum, TableProps } from './types';
+declare const TableWrapper: <RowData extends unknown = unknown, FilterVariant extends FiltersTypeEnum = FiltersTypeEnum.NONE, AdditionalProps extends Record<string, any> = {}>(tableProps: TableProps<RowData, FilterVariant, AdditionalProps>) => import("react/jsx-runtime").JSX.Element;
+export default TableWrapper;

package/dist/Shared/Components/Table/TableContent.d.ts

@@ -0,0 +1,3 @@
+import { FiltersTypeEnum, TableContentProps } from './types';
+declare const TableContent: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>({ filterData, rows, resizableConfig, additionalProps, visibleColumns, stylesConfig, loading, bulkSelectionConfig, bulkSelectionReturnValue, handleClearBulkSelection, handleToggleBulkSelectionOnRow, paginationVariant, rowActionOnHoverConfig, pageSizeOptions, filteredRows, areFilteredRowsLoading, getRows, totalRows, rowStartIconConfig, onRowClick, }: TableContentProps<RowData, FilterVariant, AdditionalProps>) => import("react/jsx-runtime").JSX.Element;
+export default TableContent;

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

@@ -0,0 +1,9 @@
+export declare const SEARCH_SORT_CHANGE_DEBOUNCE_TIME = 350; /** in ms */
+export declare const LOCAL_STORAGE_EXISTS: boolean;
+export declare const LOCAL_STORAGE_KEY_FOR_VISIBLE_COLUMNS = "generic-table-configurable-columns";
+export declare const BULK_ACTION_GUTTER_LABEL = "bulk-action-gutter";
+export declare const EVENT_TARGET: EventTarget;
+export declare const DRAG_SELECTOR_IDENTIFIER = "table-drag-selector";
+export declare const SHIMMER_DUMMY_ARRAY: number[];
+export declare const NO_ROWS_OR_GET_ROWS_ERROR: Error;
+export declare const ACTION_GUTTER_SIZE = 24;

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

@@ -0,0 +1,3 @@
+export { default as Table } from './Table.component';
+export type { BulkActionsComponentProps as TableBulkActionsComponentProps, BulkOperationModalProps as TableBulkOperationModalProps, CellComponentProps as TableCellComponentProps, Column as TableColumnType, TableProps, RowActionsOnHoverComponentProps as TableRowActionsOnHoverComponentProps, ViewWrapperProps as TableViewWrapperProps, } from './types';
+export { FiltersTypeEnum, PaginationEnum, SignalEnum as TableSignalEnum } from './types';

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

@@ -0,0 +1,240 @@
+import { Dispatch, FunctionComponent, MouseEvent, PropsWithChildren, SetStateAction } from 'react';
+import { GenericFilterEmptyStateProps } from '../../../Common/EmptyState/types';
+import { UseStateFiltersProps, UseStateFiltersReturnType, UseUrlFiltersProps, UseUrlFiltersReturnType } from '../../../Common/Hooks';
+import { GenericEmptyStateType } from '../../../Common/index';
+import { PageSizeOption } from '../../../Common/Pagination/types';
+import { SortableTableHeaderCellProps, useResizableTableConfig } from '../../../Common/SortableTableHeaderCell';
+import { IconsProps } from '../Icon';
+import { useBulkSelection, UseBulkSelectionProps } from '../BulkSelection';
+export interface UseFiltersReturnType extends UseStateFiltersReturnType<string> {
+}
+export declare enum SignalEnum {
+    COLLAPSE_ROW = "collapse-row",
+    EXPAND_ROW = "expand-row",
+    ENTER_PRESSED = "enter-pressed",
+    DELETE_PRESSED = "delete-pressed",
+    ESCAPE_PRESSED = "escape-pressed",
+    OPEN_CONTEXT_MENU = "open-context-menu",
+    ROW_CLICKED = "row-clicked"
+}
+export interface SignalsType<T extends string = SignalEnum> extends Pick<EventTarget, 'addEventListener' | 'removeEventListener'> {
+    addEventListener: (type: T, callback: (event: CustomEvent) => void, options?: Parameters<EventTarget['addEventListener']>[2]) => ReturnType<EventTarget['addEventListener']>;
+    removeEventListener: (type: T, callback: (event: CustomEvent) => void, options?: Parameters<EventTarget['removeEventListener']>[2]) => ReturnType<EventTarget['removeEventListener']>;
+}
+type SizeType = {
+    /** This signifies this column is resizable */
+    range: {
+        startWidth: number;
+        minWidth: number;
+        maxWidth: number | 'infinite';
+    };
+    /** If we want a fixed width */
+    fixed?: never;
+} | {
+    range?: never;
+    fixed: number;
+} | null;
+type BaseColumnType = {
+    /** This is the key using which we will fetch the data of  */
+    field: string;
+    /** This is the string that will be displayed to the user as header text */
+    label?: string;
+    /**
+     * If we want resizable columns, then every column has to have a fixed height
+     * If we specify size to be null then the size be will set to 1fr
+     */
+    size: SizeType;
+    horizontallySticky?: boolean;
+} & Pick<SortableTableHeaderCellProps, 'infoTooltipText'>;
+type CommonRowType<Data extends unknown> = {
+    id: string;
+    data: Data;
+};
+export type ExpandedRowPrefixType = 'expanded-row-';
+export type ExpandedRowType<Data extends unknown> = CommonRowType<Data> & {
+    id: `${ExpandedRowPrefixType}${string}`;
+};
+export type RowType<Data extends unknown> = CommonRowType<Data> & {
+    expandableRows?: Array<ExpandedRowType<Data>>;
+};
+export type RowsType<Data extends unknown> = RowType<Data>[];
+export declare enum FiltersTypeEnum {
+    STATE = "state",
+    URL = "url",
+    NONE = "none"
+}
+export type CellComponentProps<RowData extends unknown = unknown, FilterVariant extends FiltersTypeEnum = FiltersTypeEnum.NONE, AdditionalProps extends Record<string, any> = {}> = Pick<BaseColumnType, 'field'> & AdditionalProps & {
+    signals: SignalsType;
+    value: unknown;
+    row: RowType<RowData>;
+    filterData: FilterVariant extends FiltersTypeEnum.NONE ? null : FilterVariant extends FiltersTypeEnum.STATE ? UseFiltersReturnType : UseUrlFiltersReturnType<string>;
+    isRowActive: boolean;
+    isExpandedRow: boolean;
+    isRowInExpandState: boolean;
+    expandRowCallback: (e: MouseEvent<HTMLButtonElement>) => void;
+};
+export type RowActionsOnHoverComponentProps<RowData extends unknown = unknown, AdditionalProps extends Record<string, any> = {}> = {
+    row: RowType<RowData>;
+} & AdditionalProps;
+export type Column<RowData extends unknown = unknown, FilterVariant extends FiltersTypeEnum = FiltersTypeEnum.NONE, AdditionalProps extends Record<string, any> = {}> = Pick<SortableTableHeaderCellProps, 'showTippyOnTruncate'> & BaseColumnType & {
+    CellComponent?: FunctionComponent<CellComponentProps<RowData, FilterVariant, AdditionalProps>>;
+} & ({
+    isSortable: true;
+    /**
+     * Compare two rows when sorting is triggered on this column
+     * Values fed are from the field key in the row's data object
+     * @returns -1 if a < b, 0 if a === b, 1 if a > b
+     */
+    comparator?: (a: unknown, b: unknown) => number;
+} | {
+    isSortable?: false;
+    comparator?: never;
+});
+export interface BulkActionsComponentProps {
+    onActionClick: (event: MouseEvent<HTMLButtonElement>) => void;
+    bulkActionsData: unknown;
+}
+type BulkSelectionReturnValueType = ReturnType<typeof useBulkSelection>;
+export interface BulkOperationModalProps<T extends string = string, RowData extends Record<string, any> = Record<string, any>> extends Pick<BulkSelectionReturnValueType, 'isBulkSelectionApplied'> {
+    action: T;
+    onClose: () => void;
+    selections: RowsType<RowData> | null;
+    bulkOperationModalData: unknown;
+}
+type BulkSelectionConfigType = Pick<UseBulkSelectionProps<unknown>, 'getSelectAllDialogStatus'> & {
+    BulkActionsComponent: FunctionComponent<BulkActionsComponentProps>;
+    BulkOperationModal: FunctionComponent<BulkOperationModalProps>;
+    disableSelectAllAcrossEvenIfPaginated?: boolean;
+} & Pick<BulkActionsComponentProps, 'bulkActionsData'> & Pick<BulkOperationModalProps, 'bulkOperationModalData'>;
+export declare enum PaginationEnum {
+    PAGINATED = "paginated",
+    INFINITE = "infinite",
+    NOT_PAGINATED = "not-paginated"
+}
+export interface ConfigurableColumnsType<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> {
+    allColumns: Column<RowData, FilterVariant, AdditionalProps>[];
+    visibleColumns: Column<RowData, FilterVariant, AdditionalProps>[];
+    setVisibleColumns: Dispatch<SetStateAction<Column<RowData, FilterVariant, AdditionalProps>[]>>;
+}
+interface GetRowsProps extends Pick<UseFiltersReturnType, 'offset' | 'pageSize' | 'searchKey' | 'sortBy' | 'sortOrder'> {
+}
+type AdditionalFilterPropsType<T extends FiltersTypeEnum> = T extends FiltersTypeEnum.URL ? Pick<UseUrlFiltersProps<string, unknown>, 'parseSearchParams' | 'localStorageKey' | 'redirectionMethod' | 'initialSortKey' | 'defaultPageSize'> : T extends FiltersTypeEnum.STATE ? Pick<UseStateFiltersProps<string>, 'initialSortKey' | 'defaultPageSize'> : never;
+export type ViewWrapperProps<RowData extends unknown = unknown, FilterVariant extends FiltersTypeEnum = FiltersTypeEnum.NONE, AdditionalProps extends Record<string, any> = {}> = PropsWithChildren<(FilterVariant extends FiltersTypeEnum.NONE ? {} : Pick<UseFiltersReturnType, 'offset' | 'handleSearch' | 'searchKey' | 'sortBy' | 'sortOrder' | 'clearFilters' | 'areFiltersApplied'>) & AdditionalProps & Partial<ConfigurableColumnsType<RowData, FilterVariant, AdditionalProps>> & {
+    areRowsLoading: boolean;
+    filteredRows: RowsType<RowData> | null;
+    rows: RowsType<RowData> | null;
+} & (FilterVariant extends FiltersTypeEnum.URL ? Pick<UseUrlFiltersReturnType<string>, 'updateSearchParams'> : {})>;
+type FilterConfig<FilterVariant extends FiltersTypeEnum, RowData extends unknown, AdditionalProps extends Record<string, any>> = {
+    filtersVariant: FilterVariant;
+    /**
+     * Props for useUrlFilters/useStateFilters hooks
+     */
+    additionalFilterProps?: AdditionalFilterPropsType<FilterVariant>;
+    /**
+     * This func is used to filter the rows based on filter data.
+     * Only applicable if filtersVariant is NOT set to NONE
+     *
+     * If filter is only being used for sorting, then send `noop` in this prop
+     */
+    filter: FilterVariant extends FiltersTypeEnum.NONE ? null : (row: RowType<RowData>, filterData: UseFiltersReturnType, additionalProps: AdditionalProps) => boolean;
+    clearFilters?: FilterVariant extends FiltersTypeEnum.URL ? () => void : FilterVariant extends FiltersTypeEnum.STATE ? never : never;
+    areFiltersApplied?: FilterVariant extends FiltersTypeEnum.NONE ? never : boolean;
+};
+export type InternalTableProps<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> = Required<Pick<ConfigurableColumnsType<RowData, FilterVariant, AdditionalProps>, 'visibleColumns' | 'setVisibleColumns'>> & {
+    id: `table__${string}`;
+    loading?: boolean;
+    /**
+     * Memoize columns before passing as props.
+     *
+     * For columns from backend: initialize as empty array and set loading
+     * to true until API call completes.
+     */
+    columns: Column<RowData, FilterVariant, AdditionalProps>[];
+    /** If bulk selections are not a concern omit this prop */
+    bulkSelectionConfig?: BulkSelectionConfigType;
+    emptyStateConfig: {
+        noRowsConfig: Omit<GenericEmptyStateType, 'children'>;
+        noRowsForFilterConfig?: Pick<GenericFilterEmptyStateProps, 'title' | 'subTitle' | 'handleClearFilters'> & {
+            clearFilters?: () => void;
+        };
+    };
+    filterData: UseFiltersReturnType | null;
+    resizableConfig: ReturnType<typeof useResizableTableConfig> | null;
+    /**
+     * Enable this to let users choose which columns to display.
+     * Example: Resource Browser > Node Listing
+     *
+     * Using the provided id for this table, we will store the user's preference in localStorage
+     */
+    areColumnsConfigurable?: boolean;
+    additionalProps?: AdditionalProps;
+    /** Control the look of the table using this prop */
+    stylesConfig?: {
+        showSeparatorBetweenRows: boolean;
+    };
+    /**
+     * Use this component to display additional content at the end of a row when it is hovered over.
+     */
+    rowActionOnHoverConfig?: {
+        Component: FunctionComponent<RowActionsOnHoverComponentProps<RowData, AdditionalProps>>;
+        width: string | number;
+    };
+    bulkSelectionReturnValue: BulkSelectionReturnValueType | null;
+    handleClearBulkSelection: () => void;
+    handleToggleBulkSelectionOnRow: (row: RowType<RowData>) => void;
+    ViewWrapper?: FunctionComponent<ViewWrapperProps<RowData, FilterVariant, AdditionalProps>>;
+    /**
+     * An icon as the first element of the row, that hides actions like expand or bulk select icons
+     * until user hovers over the row or the row has focus from keyboard navigation
+     */
+    rowStartIconConfig?: Omit<IconsProps, 'dataTestId'>;
+    onRowClick?: (row: RowType<RowData>, isExpandedRow: boolean) => void;
+} & ({
+    /**
+     * Direct rows data for frontend-only datasets like resource browser.
+     */
+    rows: RowsType<RowData>;
+    /**
+     * Use `getRows` function instead for data that needs to be fetched from backend with pagination/sorting/filtering.
+     */
+    getRows?: never;
+} | {
+    rows?: never;
+    /** NOTE: Sorting on frontend is only handled if rows is provided instead of getRows */
+    getRows: (props: GetRowsProps, signal: AbortSignal) => Promise<{
+        rows: RowsType<RowData>;
+        totalRows: number;
+    }>;
+}) & ({
+    paginationVariant: PaginationEnum.PAGINATED;
+    pageSizeOptions?: PageSizeOption[];
+} | {
+    paginationVariant: Omit<PaginationEnum, 'PAGINATED'>;
+    pageSizeOptions?: never;
+}) & FilterConfig<FilterVariant, RowData, AdditionalProps>;
+export type UseResizableTableConfigWrapperProps<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> = Omit<InternalTableProps<RowData, FilterVariant, AdditionalProps>, 'resizableConfig'>;
+export type TableWithBulkSelectionProps<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> = Omit<UseResizableTableConfigWrapperProps<RowData, FilterVariant, AdditionalProps>, 'bulkSelectionReturnValue' | 'handleClearBulkSelection' | 'handleToggleBulkSelectionOnRow'>;
+export type VisibleColumnsWrapperProps<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> = Omit<TableWithBulkSelectionProps<RowData, FilterVariant, AdditionalProps>, 'visibleColumns' | 'setVisibleColumns'>;
+export type FilterWrapperProps<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> = Omit<VisibleColumnsWrapperProps<RowData, FilterVariant, AdditionalProps>, 'filterData'>;
+export type TableProps<RowData extends unknown = unknown, FilterVariant extends FiltersTypeEnum = FiltersTypeEnum.NONE, AdditionalProps extends Record<string, any> = {}> = Pick<FilterWrapperProps<RowData, FilterVariant, AdditionalProps>, 'additionalFilterProps' | 'bulkSelectionConfig' | 'areColumnsConfigurable' | 'emptyStateConfig' | 'filtersVariant' | 'filter' | 'additionalProps' | 'columns' | 'getRows' | 'rows' | 'paginationVariant' | 'stylesConfig' | 'id' | 'rowActionOnHoverConfig' | 'loading' | 'ViewWrapper' | 'pageSizeOptions' | 'clearFilters' | 'rowStartIconConfig' | 'onRowClick' | 'areFiltersApplied'>;
+export type BulkActionStateType = string | null;
+export interface BulkSelectionActionWidgetProps extends Pick<BulkSelectionConfigType, 'BulkActionsComponent' | 'bulkActionsData'> {
+    count: number;
+    handleClearBulkSelection: () => void;
+    parentRef: React.RefObject<HTMLDivElement>;
+    /** If it is null, we can say no bulk action has been selected yet */
+    setBulkActionState: Dispatch<SetStateAction<BulkActionStateType>>;
+}
+export type ConfigurableColumnsConfigType<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> = Record<string, ConfigurableColumnsType<RowData, FilterVariant, AdditionalProps>['visibleColumns']>;
+export interface GetFilteringPromiseProps<RowData extends unknown> {
+    searchSortTimeoutRef: React.MutableRefObject<ReturnType<typeof setTimeout> | number>;
+    callback: () => Promise<RowsType<RowData>> | RowsType<RowData>;
+}
+export interface RowsResultType<RowData extends unknown> {
+    filteredRows: RowsType<RowData>;
+    totalRows: number;
+}
+export interface TableContentProps<RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>> extends Pick<InternalTableProps<RowData, FilterVariant, AdditionalProps>, 'filterData' | 'rows' | 'resizableConfig' | 'additionalProps' | 'visibleColumns' | 'stylesConfig' | 'loading' | 'bulkSelectionConfig' | 'bulkSelectionReturnValue' | 'handleClearBulkSelection' | 'handleToggleBulkSelectionOnRow' | 'paginationVariant' | 'rowActionOnHoverConfig' | 'pageSizeOptions' | 'getRows' | 'rowStartIconConfig' | 'onRowClick'>, RowsResultType<RowData> {
+    areFilteredRowsLoading: boolean;
+}
+export {};

package/dist/Shared/Components/Table/useTableWithKeyboardShortcuts.d.ts

@@ -0,0 +1,11 @@
+import { FiltersTypeEnum, InternalTableProps, RowsType } from './types';
+declare const useTableWithKeyboardShortcuts: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>({ bulkSelectionConfig, handleToggleBulkSelectionOnRow, bulkSelectionReturnValue, }: Pick<InternalTableProps<RowData, FilterVariant, AdditionalProps>, "bulkSelectionConfig" | "bulkSelectionReturnValue" | "handleToggleBulkSelectionOnRow">, visibleRows: RowsType<RowData>, showPagination: boolean, bulkSelectionButtonRef: React.RefObject<HTMLLabelElement>) => {
+    activeRowIndex: number;
+    setActiveRowIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+    shortcutContainerProps: {
+        onKeyDown: (event: import('react').KeyboardEvent<HTMLElement>) => void;
+        onKeyUp: (event: import('react').KeyboardEvent<HTMLElement>) => void;
+        onBlur: (event: import('react').FocusEvent<HTMLElement>) => void;
+    };
+};
+export default useTableWithKeyboardShortcuts;

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

@@ -0,0 +1,11 @@
+import { Column, ConfigurableColumnsType, FiltersTypeEnum, GetFilteringPromiseProps, RowsType, TableProps, UseFiltersReturnType } from './types';
+export declare const searchAndSortRows: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>(rows: TableProps<RowData, FilterVariant, AdditionalProps>["rows"], filter: TableProps<RowData, FilterVariant, AdditionalProps>["filter"], filterData: UseFiltersReturnType, additionalProps: AdditionalProps, comparator?: Column<RowData, FilterVariant, AdditionalProps>["comparator"]) => Awaited<ReturnType<TableProps<RowData>["getRows"]>>;
+export declare const getVisibleColumnsFromLocalStorage: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>({ allColumns, id, }: Pick<ConfigurableColumnsType<RowData, FilterVariant, AdditionalProps>, "allColumns"> & Pick<TableProps<RowData, FilterVariant, AdditionalProps>, "id">) => Column<RowData, FilterVariant, AdditionalProps>[];
+export declare const setVisibleColumnsToLocalStorage: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>({ id, visibleColumns, }: Pick<ConfigurableColumnsType<RowData, FilterVariant, AdditionalProps>, "visibleColumns"> & Pick<TableProps<RowData, FilterVariant, AdditionalProps>, "id">) => void;
+export declare const getVisibleColumns: <RowData extends unknown, FilterVariant extends FiltersTypeEnum, AdditionalProps extends Record<string, any>>({ areColumnsConfigurable, columns, id, }: Pick<TableProps<RowData, FilterVariant, AdditionalProps>, "areColumnsConfigurable" | "columns" | "id">) => Column<RowData, FilterVariant, AdditionalProps>[];
+export declare const getFilteringPromise: <RowData extends unknown>({ searchSortTimeoutRef, callback, }: GetFilteringPromiseProps<RowData>) => Promise<RowsType<RowData>>;
+export declare const getStickyColumnConfig: (gridTemplateColumns: string, columnIndex: number) => {
+    className: string;
+    left: string;
+};
+export declare const scrollToShowActiveElementIfNeeded: (activeElement: HTMLDivElement, parent: HTMLDivElement, topMargin: number) => void;

package/dist/Shared/Components/TagsKeyValueTable/TagsContainer.d.ts

@@ -0,0 +1,3 @@
+import { TagsContainerProps } from './types';
+declare const TagsContainer: ({ isCreateApp, hidePropagateTags, ...props }: TagsContainerProps) => import("react/jsx-runtime").JSX.Element;
+export default TagsContainer;

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

@@ -0,0 +1,4 @@
+import { DynamicDataTableHeaderType } from '../DynamicDataTable';
+import { TagsTableColumnsType } from './types';
+export declare const TAGS_TABLE_HEADERS: DynamicDataTableHeaderType<TagsTableColumnsType>[];
+export declare const DEVTRON_AI_URL: string;

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

@@ -0,0 +1,4 @@
+export { DEVTRON_AI_URL } from './constants';
+export { default as TagsContainer } from './TagsContainer';
+export type { TagsTableColumnsType } from './types';
+export { getEmptyTagTableRow } from './utils';

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

@@ -0,0 +1,12 @@
+import { DynamicDataTableCellErrorType, DynamicDataTableProps, DynamicDataTableRowType } from '../DynamicDataTable';
+export type TagsTableColumnsType = 'tagKey' | 'tagValue';
+export interface TagsContainerProps extends Partial<Pick<DynamicDataTableProps<TagsTableColumnsType>, 'onRowEdit'>> {
+    appType: string;
+    isCreateApp?: boolean;
+    rows: DynamicDataTableRowType<TagsTableColumnsType>[];
+    setRows: (updatedRows: DynamicDataTableRowType<TagsTableColumnsType>[]) => void;
+    hidePropagateTags?: boolean;
+    getEmptyRow?: (keyChoices?: string[]) => DynamicDataTableRowType<TagsTableColumnsType>;
+    tagsError: DynamicDataTableCellErrorType<TagsTableColumnsType>;
+    setTagErrors: (updatedTagsError: DynamicDataTableCellErrorType<TagsTableColumnsType>) => void;
+}

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

@@ -0,0 +1,3 @@
+import { DynamicDataTableRowType } from '../DynamicDataTable';
+import { TagsTableColumnsType } from './types';
+export declare const getEmptyTagTableRow: () => DynamicDataTableRowType<TagsTableColumnsType>;

package/dist/Shared/Components/TargetPlatforms/TargetPlatformBadgeList.d.ts

@@ -0,0 +1,3 @@
+import { TargetPlatformBadgeListProps } from './types';
+declare const TargetPlatformBadgeList: ({ targetPlatforms }: TargetPlatformBadgeListProps) => import("react/jsx-runtime").JSX.Element;
+export default TargetPlatformBadgeList;

package/dist/Shared/Components/TargetPlatforms/TargetPlatformListTooltip.d.ts

@@ -0,0 +1,3 @@
+import { TargetPlatformListTooltipProps } from './types';
+declare const TargetPlatformListTooltip: ({ targetPlatforms, children, appendTo }: TargetPlatformListTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export default TargetPlatformListTooltip;

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

@@ -0,0 +1,3 @@
+export { default as TargetPlatformBadgeList } from './TargetPlatformBadgeList';
+export { default as TargetPlatformListTooltip } from './TargetPlatformListTooltip';
+export * from './types';

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

@@ -0,0 +1,6 @@
+import { TooltipProps } from '../../../Common/Tooltip';
+import { TargetPlatformsDTO } from '../../types';
+export interface TargetPlatformBadgeListProps extends Required<Pick<TargetPlatformsDTO, 'targetPlatforms'>> {
+}
+export interface TargetPlatformListTooltipProps extends Pick<TargetPlatformsDTO, 'targetPlatforms'>, Pick<TooltipProps, 'children' | 'appendTo'> {
+}

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

@@ -0,0 +1 @@
+export declare const TempAppWindow: () => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,3 @@
+import { TextareaProps } from './types';
+declare const Textarea: ({ name, label, textareaRef: textareaRefProp, fullWidth, error, helperText, warningText, layout, required, onBlur, shouldTrim, size, ariaLabel, borderRadiusConfig, labelTooltipConfig, labelTippyCustomizedConfig, hideFormFieldInfo, value, borderConfig, disableResize, newlineOnShiftEnter, ...props }: TextareaProps) => import("react/jsx-runtime").JSX.Element;
+export default Textarea;

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

@@ -0,0 +1,4 @@
+export declare const TEXTAREA_CONSTRAINTS: {
+    MIN_HEIGHT: number;
+    AUTO_EXPANSION_MAX_HEIGHT: number;
+};

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

@@ -0,0 +1,2 @@
+export { default as Textarea } from './Textarea.component';
+export type { TextareaProps } from './types';

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

@@ -0,0 +1,37 @@
+import { TextareaHTMLAttributes } from 'react';
+import { ComponentSizeType } from '../../constants';
+import { FormFieldWrapperProps } from '../FormFieldWrapper';
+export interface TextareaProps extends Omit<FormFieldWrapperProps, 'children' | 'inputId'>, Pick<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onBlur' | 'disabled' | 'autoFocus' | 'onFocus'>, Required<Pick<TextareaHTMLAttributes<HTMLTextAreaElement>, 'placeholder' | 'onChange' | 'name'>> {
+    /**
+     * If false, the input is not trimmed on blur
+     *
+     * @default true
+     */
+    shouldTrim?: boolean;
+    /**
+     * Size of the textarea
+     *
+     * @default ComponentSizeType.large
+     */
+    size?: Extract<ComponentSizeType, ComponentSizeType.small | ComponentSizeType.medium | ComponentSizeType.large>;
+    /**
+     * Value of the textarea
+     */
+    value: string;
+    /**
+     * If true, the textarea resize is disabled
+     *
+     * @default false
+     */
+    disableResize?: true;
+    /**
+     * Allows inserting a newline with Shift + Enter instead of Enter alone.
+     *
+     * When enabled, pressing Enter submits the form, while Shift + Enter inserts a newline.
+     * Useful for forms where Enter should trigger submission, but multiline input is still needed.
+     *
+     * @default false
+     */
+    newlineOnShiftEnter?: boolean;
+    textareaRef?: React.MutableRefObject<HTMLTextAreaElement> | React.RefCallback<HTMLTextAreaElement>;
+}

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

@@ -0,0 +1,5 @@
+import { TextareaProps } from './types';
+export declare const getTextAreaConstraintsForSize: (size: TextareaProps["size"]) => {
+    MIN_HEIGHT: number;
+    AUTO_EXPANSION_MAX_HEIGHT: number;
+};

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

@@ -0,0 +1,3 @@
+import { ThemeSwitcherProps } from './types';
+declare const ThemeSwitcher: ({ onClick }: ThemeSwitcherProps) => import("react/jsx-runtime").JSX.Element;
+export default ThemeSwitcher;

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

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

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

@@ -0,0 +1,3 @@
+export interface ThemeSwitcherProps {
+    onClick?: () => void;
+}

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

@@ -0,0 +1,3 @@
+import { ToggleResolveScopedVariablesProps } from './types';
+declare const ToggleResolveScopedVariables: ({ name, resolveScopedVariables, handleToggleScopedVariablesView, isDisabled, showTooltip, }: ToggleResolveScopedVariablesProps) => import("react/jsx-runtime").JSX.Element;
+export default ToggleResolveScopedVariables;