@devtron-labs/devtron-fe-common-lib 1.10.0 → 1.10.1-beta-1

package/dist/{@common-rjsf-B1NZSY87.js → @common-rjsf-h6_nZqkx.js}

@@ -1,7 +1,7 @@
 import { j as n, aq as y, as as k, ar as W } from "./@vendor-DXbFZ041.js";
 import V, { forwardRef as J, useMemo as P } from "react";
 import K, { getDefaultRegistry as q } from "@rjsf/core";
-import { T as F, j as N, c as v, b as S, a as Y, i as z, d as w, e as E, S as G } from "./@code-editor-Dd-Rsu69.js";
+import { T as F, j as N, c as v, b as S, a as Y, i as z, d as w, e as E, S as G } from "./@code-editor-BK2IgrtU.js";
 import Q, { components as D } from "react-select";
 import { ReactComponent as X } from "./assets/ic-chevron-down.fc70d7a7.svg";
 import { getUiOptions as B, getTemplate as $, getSubmitButtonOptions as Z, ADDITIONAL_PROPERTY_FLAG as L, errorId as ee, englishStringTranslator as te, TranslatableString as ne, titleId as re, canExpand as se, deepEquals as ae } from "@rjsf/utils";

package/dist/Common/Hooks/UseRegisterShortcut/types.d.ts

@@ -7,8 +7,21 @@ export declare const KEYBOARD_KEYS_MAP: {
     readonly E: "E";
     readonly R: "R";
     readonly K: "K";
+    readonly X: "X";
     readonly Escape: "Esc";
     readonly Enter: "↩";
+    readonly ArrowLeft: "←";
+    readonly ArrowRight: "→";
+    readonly ArrowUp: "↑";
+    readonly ArrowDown: "↓";
+    readonly PageUp: "PgUp";
+    readonly PageDown: "PgDn";
+    readonly Home: "Home";
+    readonly End: "End";
+    readonly Backspace: "⌫";
+    readonly Delete: "⌦";
+    readonly '.': ".";
+    readonly Space: "Space";
 };
 export type SupportedKeyboardKeysType = keyof typeof KEYBOARD_KEYS_MAP;
 export interface ShortcutType {

package/dist/Common/Hooks/UseRegisterShortcut/utils.d.ts

@@ -1,6 +1,6 @@
 import { ShortcutType } from './types';
 export declare const preprocessKeys: (keys: ShortcutType["keys"]) => {
-    keys: ("Escape" | "Control" | "Alt" | "F" | "E" | "R" | "K" | "Shift" | "Meta" | "Enter")[];
+    keys: ("Escape" | "Control" | "Alt" | "F" | "E" | "R" | "K" | "X" | "Home" | "End" | "." | "Space" | "Shift" | "Meta" | "Enter" | "ArrowLeft" | "ArrowRight" | "ArrowUp" | "ArrowDown" | "PageUp" | "PageDown" | "Backspace" | "Delete")[];
     id: string;
 };
 export declare const verifyCallbackStack: (stack: ShortcutType["callbackStack"]) => void;

package/dist/Common/Hooks/useStateFilters/types.d.ts

@@ -1,7 +1,7 @@
 import { UseUrlFiltersProps, UseUrlFiltersReturnType } from '../useUrlFilters';
 export interface UseStateFiltersProps<T> extends Pick<UseUrlFiltersProps<T, never>, 'initialSortKey'> {
 }
-export interface UseStateFiltersReturnType<T> extends Pick<UseUrlFiltersReturnType<T>, 'sortBy' | 'sortOrder' | 'handleSorting' | 'clearFilters' | 'changePage' | 'changePageSize' | 'offset' | 'pageSize' | 'searchKey' | 'handleSearch'> {
+export interface UseStateFiltersReturnType<T> extends Pick<UseUrlFiltersReturnType<T>, 'sortBy' | 'sortOrder' | 'handleSorting' | 'clearFilters' | 'changePage' | 'changePageSize' | 'offset' | 'pageSize' | 'searchKey' | 'handleSearch' | 'isFilterApplied'> {
 }
 export interface PaginationType<T> extends Pick<UseUrlFiltersReturnType<T>, 'pageSize'> {
     pageNumber: number;

package/dist/Common/Hooks/useUrlFilters/types.d.ts

@@ -67,4 +67,5 @@ export type UseUrlFiltersReturnType<T, K = unknown> = K & {
      * Update the search params with the passed object
      */
     updateSearchParams: (paramsToSerialize: Partial<K>, options?: UpdateSearchParamsOptionsType<T, K>) => void;
+    isFilterApplied: boolean;
 };

package/dist/Common/SegmentedControl/Segment.d.ts

@@ -0,0 +1,3 @@
+import { SegmentProps } from './types';
+declare const Segment: ({ segment, isSelected, name, selectedSegmentRef, onChange, fullWidth, size, disabled, }: SegmentProps) => JSX.Element;
+export default Segment;

package/dist/Common/SegmentedControl/SegmentedControl.component.d.ts

@@ -1,3 +1,3 @@
 import { SegmentedControlProps } from './types';
-declare const SegmentedControl: ({ tabs, initialTab, onChange, tooltips, disabled, rootClassName, name, variant, size, isControlled, }: SegmentedControlProps) => JSX.Element;
+declare const SegmentedControl: ({ segments, onChange, name, size, value: controlledValue, fullWidth, disabled, }: SegmentedControlProps) => JSX.Element;
 export default SegmentedControl;

package/dist/Common/SegmentedControl/constants.d.ts

@@ -1,2 +1,3 @@
 import { SegmentedControlProps } from './types';
-export declare const SEGMENTED_CONTROL_SIZE_TO_CLASS_MAP: Record<SegmentedControlProps['size'], string>;
+export declare const COMPONENT_SIZE_TO_SEGMENT_CLASS_MAP: Record<SegmentedControlProps['size'], string>;
+export declare const COMPONENT_SIZE_TO_ICON_CLASS_MAP: Record<SegmentedControlProps['size'], string>;

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

@@ -1,2 +1,2 @@
-export { type SegmentedControlProps, SegmentedControlVariant } from './types';
 export { default as SegmentedControl } from './SegmentedControl.component';
+export { type SegmentedControlProps } from './types';

package/dist/Common/SegmentedControl/types.d.ts

@@ -1,25 +1,67 @@
-import { OptionType } from '../Types';
+import { TooltipProps } from '../Tooltip';
+import { IconsProps, SelectPickerOptionType } from '../../Shared/Components';
 import { ComponentSizeType } from '../../Shared/constants';
-import { ReactNode } from 'react';
-export declare enum SegmentedControlVariant {
-    GRAY_ON_WHITE = "gui-yaml-switch",
-    WHITE_ON_GRAY = "gui-yaml-switch-window-bg"
-}
-export interface SegmentedControlProps {
-    tabs: OptionType<string, ReactNode>[];
-    initialTab: string;
-    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+import { RefObject } from 'react';
+type SegmentTooltipProps = Omit<TooltipProps, 'alwaysShowTippyOnHover' | 'showOnTruncate' | 'shortcutKeyCombo' | 'placement'>;
+export type SegmentType = Pick<SelectPickerOptionType, 'value'> & {
+    /**
+     * If true, the segment will be in error state with error icon
+     */
+    isError?: boolean;
+} & (({
+    /**
+     * Label for the segment
+     *
+     * Note: Either of label or icon is required
+     */
+    label: SelectPickerOptionType['label'];
+    /**
+     * Icon for the segment
+     *
+     * Note: Either of label or icon is required
+     */
+    icon?: IconsProps['name'];
+    /**
+     * Tooltip props for the segment
+     *
+     * Note: Required if only icon is provided
+     */
+    tooltipProps?: SegmentTooltipProps;
+    ariaLabel?: never;
+} & Pick<SelectPickerOptionType, 'label'>) | {
+    label?: never;
+    tooltipProps: SegmentTooltipProps;
+    icon: IconsProps['name'];
+    /**
+     * Aria label for the segment
+     */
+    ariaLabel: string;
+});
+export type SegmentedControlProps = {
+    /**
+     * List of segments to be displayed
+     */
+    segments: SegmentType[];
     name: string;
-    tooltips?: string[];
+    size?: Extract<ComponentSizeType, ComponentSizeType.xs | ComponentSizeType.small | ComponentSizeType.medium>;
+    fullWidth?: boolean;
     disabled?: boolean;
-    rootClassName?: string;
-    variant?: SegmentedControlVariant;
+} & ({
+    value?: never;
     /**
-     * @default ComponentSizeType.medium
+     * On change handler for the component
      */
-    size?: ComponentSizeType.medium | ComponentSizeType.large;
+    onChange?: (selectedSegment: SegmentType) => void;
+} | {
     /**
-     * @default false
+     * If defined, the component is controlled and onChange needs to be handled by the parent
      */
-    isControlled?: boolean;
+    value: SegmentType['value'];
+    onChange: (selectedSegment: SegmentType) => void;
+});
+export interface SegmentProps extends Required<Pick<SegmentedControlProps, 'name' | 'onChange' | 'fullWidth' | 'size' | 'disabled'>> {
+    isSelected: boolean;
+    segment: SegmentType;
+    selectedSegmentRef: RefObject<HTMLDivElement> | undefined;
 }
+export {};

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

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

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

@@ -0,0 +1,3 @@
+import { InternalTablePropsWithWrappers } from './types';
+declare const InternalTable: ({ filtersVariant, filterData, rows, getRows, columns, ViewWrapper, resizableConfig, emptyStateConfig, additionalProps, configurableColumns, filter, setVisibleColumns, visibleColumns, stylesConfig, loading, bulkSelectionConfig, bulkSelectionReturnValue, handleClearBulkSelection, handleToggleBulkSelectionOnRow, paginationVariant, RowActionsOnHoverComponent, }: InternalTablePropsWithWrappers) => JSX.Element;
+export default InternalTable;

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

@@ -0,0 +1,3 @@
+import { TableProps } from './types';
+declare const TableWrapper: (tableProps: TableProps) => JSX.Element;
+export default TableWrapper;

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

@@ -0,0 +1,3 @@
+import { UseResizableTableConfigWrapperProps } from './types';
+declare const UseResizableTableConfigWrapper: ({ children, columns }: UseResizableTableConfigWrapperProps) => import('react').ReactElement<import('./types').InternalTableProps, string | import('react').JSXElementConstructor<any>>;
+export default UseResizableTableConfigWrapper;

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

@@ -0,0 +1,3 @@
+import { FiltersTypeEnum, FilterWrapperProps } from './types';
+declare const UseStateFilterWrapper: ({ children, additionalFilterProps }: FilterWrapperProps<FiltersTypeEnum.STATE>) => import('react').ReactElement<import('./types').InternalTableProps, string | import('react').JSXElementConstructor<any>>;
+export default UseStateFilterWrapper;

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

@@ -0,0 +1,3 @@
+import { FiltersTypeEnum, FilterWrapperProps } from './types';
+declare const UseUrlFilterWrapper: ({ children, additionalFilterProps }: FilterWrapperProps<FiltersTypeEnum.URL>) => import('react').ReactElement<import('./types').InternalTableProps, string | import('react').JSXElementConstructor<any>>;
+export default UseUrlFilterWrapper;

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

@@ -0,0 +1,5 @@
+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;

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

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

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

@@ -0,0 +1,202 @@
+import { Dispatch, FunctionComponent, ReactElement, SetStateAction } from 'react';
+import { SortableTableHeaderCellProps, useResizableTableConfig } from '../../../Common/SortableTableHeaderCell';
+import { UseStateFiltersProps, UseStateFiltersReturnType, UseUrlFiltersProps } from '../../../Common/Hooks';
+import { GenericEmptyStateType } from '../../../Common/index';
+import { GenericFilterEmptyStateProps } from '@Common/EmptyState/types';
+import { useBulkSelection, UseBulkSelectionProps } from '../BulkSelection';
+export interface UseFiltersReturnType extends UseStateFiltersReturnType<string> {
+}
+export declare enum SignalEnum {
+    ENTER_PRESSED = "enter-pressed",
+    DELETE_PRESSED = "delete-pressed",
+    ESCAPE_PRESSED = "escape-pressed",
+    OPEN_CONTEXT_MENU = "open-context-menu",
+    /** TODO: Not yet implemented */
+    BULK_SELECTION_CHANGED = "bulk-selection-changed",
+    ACTIVE_ROW_CHANGED = "active-row-changed",
+    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;
+};
+interface AdditionalProps {
+    [key: string]: unknown;
+}
+type RowType = {
+    id: string;
+    data: Record<string, unknown>;
+};
+export type RowsType = RowType[];
+export interface CellComponentProps extends Pick<BaseColumnType, 'field'>, AdditionalProps {
+    signals: SignalsType;
+    value: unknown;
+    row: RowType;
+    filterData: UseFiltersReturnType;
+    isRowActive: boolean;
+}
+export type Column = Pick<SortableTableHeaderCellProps, 'showTippyOnTruncate'> & BaseColumnType & {
+    CellComponent?: FunctionComponent<CellComponentProps>;
+} & ({
+    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;
+});
+type BulkSelectionConfigType = Pick<UseBulkSelectionProps<unknown>, 'getSelectAllDialogStatus'> & {
+    /** Make sure to wrap it in useCallback */
+    onBulkSelectionChanged: (selectedRows: RowsType) => void;
+    BulkActionsComponent: FunctionComponent<{}>;
+};
+export declare enum PaginationEnum {
+    PAGINATED = "paginated",
+    INFINITE = "infinite",
+    NOT_PAGINATED = "not-paginated"
+}
+export declare enum FiltersTypeEnum {
+    STATE = "state",
+    URL = "url",
+    NONE = "none"
+}
+export interface ConfigurableColumnsType {
+    allColumns: Column[];
+    visibleColumns: Column[];
+    setVisibleColumns: Dispatch<SetStateAction<ConfigurableColumnsType['visibleColumns']>>;
+}
+interface GetRowsProps extends Pick<UseFiltersReturnType, 'offset' | 'pageSize' | 'searchKey' | 'sortBy' | 'sortOrder'> {
+}
+type AdditionalFilterPropsType<T extends Exclude<FiltersTypeEnum, FiltersTypeEnum.NONE>> = T extends FiltersTypeEnum.URL ? Pick<UseUrlFiltersProps<string, unknown>, 'parseSearchParams' | 'localStorageKey' | 'redirectionMethod' | 'initialSortKey'> : Pick<UseStateFiltersProps<string>, 'initialSortKey'>;
+export type InternalTableProps = Record<'filterData', UseFiltersReturnType> & Record<'resizableConfig', ReturnType<typeof useResizableTableConfig>> & Required<Pick<ConfigurableColumnsType, 'visibleColumns' | 'setVisibleColumns'>> & {
+    id: string;
+    loading?: boolean;
+    paginationVariant: PaginationEnum;
+    /**
+     * 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[];
+    /** If bulk selections are not a concern omit this prop */
+    bulkSelectionConfig?: BulkSelectionConfigType;
+    emptyStateConfig: {
+        noRowsConfig: Omit<GenericEmptyStateType, 'children'>;
+        noRowsForFilterConfig?: Pick<GenericFilterEmptyStateProps, 'title' | 'subTitle'> & {
+            clearFilters: () => void;
+        };
+    };
+    /**
+     * 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
+     */
+    configurableColumns?: boolean;
+    visibleRowsNumberRef: React.MutableRefObject<number>;
+    activeRowIndex: number;
+    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.
+     */
+    RowActionsOnHoverComponent?: FunctionComponent<{
+        row: RowsType[number];
+    }>;
+    bulkSelectionReturnValue: ReturnType<typeof useBulkSelection> | null;
+    handleClearBulkSelection: () => void;
+    handleToggleBulkSelectionOnRow: (row: RowsType[number]) => void;
+    bulkSelectedRowIdsRef: React.MutableRefObject<string[]>;
+    activeRowRef: React.MutableRefObject<RowsType[number] | null>;
+} & ({
+    /**
+     * Direct rows data for frontend-only datasets like resource browser.
+     */
+    rows: RowsType;
+    /**
+     * 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) => Promise<RowsType>;
+}) & ({
+    filtersVariant: FiltersTypeEnum.URL;
+    /**
+     * props for useUrlFilters/useStateFilters hooks
+     */
+    additionalFilterProps?: AdditionalFilterPropsType<FiltersTypeEnum.URL>;
+    /**
+     * 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: (row: RowsType[number], filterData: UseFiltersReturnType) => boolean;
+} | {
+    filtersVariant: FiltersTypeEnum.STATE;
+    additionalFilterProps?: AdditionalFilterPropsType<FiltersTypeEnum.STATE>;
+    filter: (row: RowsType[number], filterData: UseFiltersReturnType) => boolean;
+} | {
+    filtersVariant: FiltersTypeEnum.NONE;
+    additionalFilterProps?: never;
+    filter?: never;
+});
+export interface WrapperProps {
+    children: ReactElement<InternalTableProps>;
+}
+export interface ViewWrapperProps extends Pick<UseFiltersReturnType, 'offset' | 'handleSearch' | 'searchKey' | 'sortBy' | 'sortOrder' | 'clearFilters'>, AdditionalProps, Partial<ConfigurableColumnsType>, WrapperProps {
+    areRowsLoading: boolean;
+}
+interface WrappersType {
+    ViewWrapper?: FunctionComponent<ViewWrapperProps>;
+}
+export type InternalTablePropsWithWrappers = InternalTableProps & WrappersType;
+export type TableProps = Pick<InternalTableProps, 'additionalFilterProps' | 'bulkSelectionConfig' | 'configurableColumns' | 'emptyStateConfig' | 'filtersVariant' | 'filter' | 'additionalProps' | 'columns' | 'getRows' | 'rows' | 'paginationVariant' | 'stylesConfig' | 'id' | 'RowActionsOnHoverComponent' | 'loading'> & WrappersType;
+export interface FilterWrapperProps<T extends Exclude<FiltersTypeEnum, FiltersTypeEnum.NONE>> extends WrapperProps {
+    additionalFilterProps?: AdditionalFilterPropsType<T>;
+}
+export interface UseResizableTableConfigWrapperProps extends WrapperProps {
+    columns: TableProps['columns'];
+}
+export interface BulkSelectionActionWidgetProps extends Pick<BulkSelectionConfigType, 'BulkActionsComponent'> {
+    count: number;
+    handleClearBulkSelection: () => void;
+    parentRef: React.RefObject<HTMLDivElement>;
+}
+export type ConfigurableColumnsConfigType = Record<string, ConfigurableColumnsType['visibleColumns']>;
+export {};

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

@@ -0,0 +1,6 @@
+import { InternalTablePropsWithWrappers, RowsType } from './types';
+declare const useTableWithKeyboardShortcuts: ({ bulkSelectionConfig, handleToggleBulkSelectionOnRow, bulkSelectionReturnValue, }: Pick<InternalTablePropsWithWrappers, "bulkSelectionConfig" | "bulkSelectionReturnValue" | "handleToggleBulkSelectionOnRow">, visibleRows: RowsType) => {
+    activeRowIndex: number;
+    setActiveRowIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+};
+export default useTableWithKeyboardShortcuts;

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

@@ -0,0 +1,7 @@
+import { FunctionComponent } from 'react';
+import { Column, ConfigurableColumnsType, FiltersTypeEnum, TableProps, UseFiltersReturnType, WrapperProps } from './types';
+export declare const searchAndSortRows: (rows: TableProps["rows"], filter: TableProps["filter"], filterData: UseFiltersReturnType, comparator?: Column["comparator"]) => import('./types').RowsType;
+export declare const getFilterWrapperComponent: (filtersVariant: FiltersTypeEnum) => FunctionComponent<WrapperProps>;
+export declare const getVisibleColumnsFromLocalStorage: ({ allColumns, id, }: Pick<ConfigurableColumnsType, "allColumns"> & Pick<TableProps, "id">) => Column[];
+export declare const setVisibleColumnsToLocalStorage: ({ id, visibleColumns, }: Pick<ConfigurableColumnsType, "visibleColumns"> & Pick<TableProps, "id">) => void;
+export declare const getVisibleColumns: ({ configurableColumns, columns, id, }: Pick<TableProps, "configurableColumns" | "columns" | "id">) => Column[];

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

@@ -69,4 +69,5 @@ export * from './CustomInput';
 export * from './InfoBlock';
 export * from './CodeEditorWrapper';
 export * from './SSOProviderIcon';
+export * from './Table';
 export * from './Confetti';

package/dist/Shared/types.d.ts

@@ -1,6 +1,6 @@
 import { Dayjs } from 'dayjs';
 import { APIOptions, ApprovalConfigDataType } from '../Common/Types';
-import { OptionType, CommonNodeAttr, VulnerabilityType, DeploymentAppTypes, ServerErrors, SortingParams, TriggerBlockType, ValueConstraintType, VariableType, RefVariableType, PluginType } from '../Common';
+import { OptionType, CommonNodeAttr, VulnerabilityType, DeploymentAppTypes, ServerErrors, SortingParams, TriggerBlockType, ValueConstraintType, VariableType, RefVariableType, PluginType, SegmentedControlProps } from '../Common';
 import { BASE_CONFIGURATION_ENV_ID, EnvironmentTypeEnum, PatchOperationType } from './constants';
 import { SelectPickerOptionType } from './Components';
 export declare enum EnvType {
@@ -598,7 +598,7 @@ export declare enum ConfigurationType {
     GUI = "GUI",
     YAML = "YAML"
 }
-export declare const CONFIGURATION_TYPE_OPTIONS: OptionType<ConfigurationType, ConfigurationType>[];
+export declare const CONFIGURATION_TYPE_OPTIONS: SegmentedControlProps['segments'];
 export interface BaseURLParams {
     appId: string;
     envId: string;