backend.ai-ui 0.0.1 → 25.16.0

package/dist/common-CMrtHk6c.js.map

@@ -1 +1 @@
-{"version":3,"file":"common-CMrtHk6c.js","sources":["../../../node_modules/.pnpm/rc-picker@4.11.3_date-fns@3.6.0_dayjs@1.11.13_react-dom@19.0.0_react@19.0.0__react@19.0.0/node_modules/rc-picker/es/locale/common.js"],"sourcesContent":["export var commonLocale = {\n  yearFormat: 'YYYY',\n  dayFormat: 'D',\n  cellMeridiemFormat: 'A',\n  monthBeforeYear: true\n};"],"names":["commonLocale"],"mappings":"AAAU,IAACA,IAAe;AAAA,EACxB,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,oBAAoB;AAAA,EACpB,iBAAiB;AACnB;","x_google_ignoreList":[0]}
+{"version":3,"file":"common-CMrtHk6c.js","sources":["../../../node_modules/.pnpm/rc-picker@4.11.3_date-fns@3.6.0_dayjs@1.11.18_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/rc-picker/es/locale/common.js"],"sourcesContent":["export var commonLocale = {\n  yearFormat: 'YYYY',\n  dayFormat: 'D',\n  cellMeridiemFormat: 'A',\n  monthBeforeYear: true\n};"],"names":["commonLocale"],"mappings":"AAAU,IAACA,IAAe;AAAA,EACxB,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,oBAAoB;AAAA,EACpB,iBAAiB;AACnB;","x_google_ignoreList":[0]}

package/dist/components/BAIAlertIconWithTooltip.d.ts

@@ -0,0 +1,9 @@
+import { TooltipPropsWithTitle } from 'antd/es/tooltip';
+import { CircleAlertIcon } from 'lucide-react';
+import { default as React } from 'react';
+interface BAIAlertIconWithTooltipProps extends Omit<TooltipPropsWithTitle, 'children'> {
+    iconProps?: React.ComponentProps<typeof CircleAlertIcon>;
+    type?: 'warning' | 'error';
+}
+declare const BAIAlertIconWithTooltip: ({ iconProps, type, ...tooltipProps }: BAIAlertIconWithTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export default BAIAlertIconWithTooltip;

package/dist/components/BAIBackButton.d.ts

@@ -0,0 +1,7 @@
+import { NavigateOptions, To } from 'react-router-dom';
+export interface BAIBackButtonProps {
+    to: To;
+    options?: NavigateOptions;
+}
+declare const BAIBackButton: ({ to, options }: BAIBackButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default BAIBackButton;

package/dist/components/BAIBoardItemTitle.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface BAIBoardItemTitleProps {
+    title: React.ReactNode | string;
+    tooltip?: React.ReactNode;
+    extra?: React.ReactNode;
+    style?: React.CSSProperties;
+}
+declare const BAIBoardItemTitle: React.FC<BAIBoardItemTitleProps>;
+export default BAIBoardItemTitle;

package/dist/components/BAICard.d.ts

@@ -1,12 +1,63 @@
 import { CardProps } from 'antd';
 import { default as React, ReactNode } from 'react';
+/**
+ * Props interface for BAICard component.
+ * Extends Ant Design Card props with additional Backend.AI-specific customizations.
+ */
 export interface BAICardProps extends Omit<CardProps, 'extra'> {
+    /** Visual status of the card affecting border color and extra button icons */
     status?: 'success' | 'error' | 'warning' | 'default';
+    /** Custom content to display in the header area */
     extra?: ReactNode;
+    /** Title for the extra button that appears in the header */
     extraButtonTitle?: string | ReactNode;
+    /** Show header divider. Automatically enabled when tabList is specified */
     showDivider?: boolean;
+    /** Callback function triggered when the extra button is clicked */
     onClickExtraButton?: () => void;
-    ref?: React.LegacyRef<HTMLDivElement> | undefined;
+    /** React ref for the card container */
+    ref?: React.Ref<HTMLDivElement> | undefined;
 }
+/**
+ * BAICard component - Enhanced Ant Design Card with Backend.AI-specific features.
+ *
+ * Provides a flexible card interface with status-based styling, customizable headers,
+ * and integrated action buttons. Supports all standard Ant Design Card features
+ * while adding Backend.AI design system enhancements.
+ *
+ * @param props - BAICardProps configuration object
+ * @returns React functional component
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <BAICard title="Basic Card">
+ *   <p>Card content goes here</p>
+ * </BAICard>
+ *
+ * // With status and extra button
+ * <BAICard
+ *   title="Error Card"
+ *   status="error"
+ *   extraButtonTitle="Fix Error"
+ *   onClickExtraButton={() => handleError()}
+ * >
+ *   <p>Error details...</p>
+ * </BAICard>
+ *
+ * // With tabs
+ * <BAICard
+ *   title="Tabbed Card"
+ *   tabList={[
+ *     { key: 'tab1', label: 'Tab 1' },
+ *     { key: 'tab2', label: 'Tab 2' }
+ *   ]}
+ *   activeTabKey="tab1"
+ *   onTabChange={(key) => setActiveTab(key)}
+ * >
+ *   <p>Tab content...</p>
+ * </BAICard>
+ * ```
+ */
 declare const BAICard: React.FC<BAICardProps>;
 export default BAICard;

package/dist/components/BAIConfirmModalWithInput.d.ts

@@ -0,0 +1,11 @@
+import { BAIModalProps } from './BAIModal';
+import { default as React } from 'react';
+export interface BAIConfirmModalWithInputProps extends Omit<BAIModalProps, 'icon' | 'okButtonProps'> {
+    confirmText: string;
+    content: React.ReactNode;
+    title: React.ReactNode;
+    icon?: React.ReactNode;
+    okButtonProps?: Omit<BAIModalProps['okButtonProps'], 'disabled' | 'danger'>;
+}
+declare const BAIConfirmModalWithInput: React.FC<BAIConfirmModalWithInputProps>;
+export default BAIConfirmModalWithInput;

package/dist/components/{Flex.d.ts → BAIFlex.d.ts}

@@ -1,12 +1,12 @@
 import { default as React, PropsWithChildren } from 'react';
 type GapSize = number | 'xxs' | 'xs' | 'sm' | 'ms' | 'md' | 'lg' | 'xl' | 'xxl';
-type GapProp = GapSize | [GapSize, GapSize];
-export interface FlexProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'dir'>, PropsWithChildren {
+type GapProp = GapSize | [GapSize | undefined, GapSize | undefined];
+export interface BAIFlexProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'dir'>, PropsWithChildren {
     direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
     wrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
     justify?: 'start' | 'end' | 'center' | 'between' | 'around';
     align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
     gap?: GapProp;
 }
-declare const Flex: React.ForwardRefExoticComponent<FlexProps & React.RefAttributes<HTMLDivElement>>;
-export default Flex;
+declare const BAIFlex: React.ForwardRefExoticComponent<BAIFlexProps & React.RefAttributes<HTMLDivElement>>;
+export default BAIFlex;

package/dist/components/BAIGraphQLPropertyFilter.d.ts

@@ -0,0 +1,76 @@
+import { default as BAIFlex } from './BAIFlex';
+import { AutoCompleteProps } from 'antd';
+import { default as React, ComponentProps } from 'react';
+export type StringFilter = {
+    contains?: string | null;
+    startsWith?: string | null;
+    endsWith?: string | null;
+    equals?: string | null;
+    notEquals?: string | null;
+    iContains?: string | null;
+    iStartsWith?: string | null;
+    iEndsWith?: string | null;
+    iEquals?: string | null;
+    iNotEquals?: string | null;
+};
+export type NumberFilter = {
+    equals?: number | null;
+    notEquals?: number | null;
+    greaterThan?: number | null;
+    greaterOrEqual?: number | null;
+    lessThan?: number | null;
+    lessOrEqual?: number | null;
+    in?: number[] | null;
+    notIn?: number[] | null;
+};
+export type BooleanFilter = boolean;
+export type EnumFilter<T = string> = {
+    equals?: T | null;
+    notEquals?: T | null;
+    in?: T[] | null;
+    notIn?: T[] | null;
+};
+export type BaseFilter<T = any> = {
+    AND?: T[] | T | null;
+    OR?: T[] | T | null;
+    NOT?: T | null;
+};
+export type GraphQLFilter = BaseFilter & {
+    [key: string]: any;
+};
+export type FilterPropertyType = 'string' | 'number' | 'boolean' | 'enum';
+export type FilterOperator = 'contains' | 'startsWith' | 'endsWith' | 'equals' | 'notEquals' | 'iContains' | 'iStartsWith' | 'iEndsWith' | 'iEquals' | 'iNotEquals' | 'greaterThan' | 'greaterOrEqual' | 'lessThan' | 'lessOrEqual' | 'in' | 'notIn' | (string & NonNullable<unknown>);
+type BaseFilterProperty = {
+    key: string;
+    propertyLabel: string;
+    type: FilterPropertyType;
+    operators?: FilterOperator[];
+    options?: AutoCompleteProps['options'];
+    strictSelection?: boolean;
+    rule?: {
+        message: string;
+        validate: (value: any) => boolean;
+    };
+    valueMode?: 'scalar' | 'operator';
+    implicitOperator?: FilterOperator;
+};
+export type FilterProperty = BaseFilterProperty & ({
+    fixedOperator: FilterOperator;
+    defaultOperator?: never;
+} | {
+    defaultOperator?: FilterOperator;
+    fixedOperator?: never;
+} | {
+    defaultOperator?: never;
+    fixedOperator?: never;
+});
+export interface BAIGraphQLPropertyFilterProps extends Omit<ComponentProps<typeof BAIFlex>, 'value' | 'onChange' | 'defaultValue'> {
+    value?: GraphQLFilter;
+    onChange?: (value: GraphQLFilter | undefined) => void;
+    defaultValue?: GraphQLFilter;
+    filterProperties: Array<FilterProperty>;
+    loading?: boolean;
+    combinationMode?: 'AND' | 'OR';
+}
+declare const BAIGraphQLPropertyFilter: React.FC<BAIGraphQLPropertyFilterProps>;
+export default BAIGraphQLPropertyFilter;

package/dist/components/BAIImportFromHuggingFaceModal.d.ts

@@ -0,0 +1,6 @@
+import { ModalProps } from 'antd';
+export interface BAIImportFromHuggingFaceModalProps extends Omit<ModalProps, 'onOk'> {
+    onOk: (e: React.MouseEvent<HTMLElement>, artifactId: string) => void;
+}
+declare const BAIImportFromHuggingFaceModal: ({ onOk, onCancel, ...modalProps }: BAIImportFromHuggingFaceModalProps) => import("react/jsx-runtime").JSX.Element;
+export default BAIImportFromHuggingFaceModal;

package/dist/components/BAILink.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { LinkProps } from 'react-router-dom';
+export interface BAILinkProps extends Omit<LinkProps, 'to'> {
+    type?: 'hover' | 'disabled' | undefined;
+    to?: LinkProps['to'];
+    icon?: React.ReactNode;
+    ellipsis?: boolean | {
+        tooltip?: string;
+    };
+    children?: string | React.ReactNode;
+}
+declare const BAILink: React.FC<BAILinkProps>;
+export default BAILink;

package/dist/components/BAIModal.d.ts

@@ -0,0 +1,8 @@
+import { ModalProps } from 'antd';
+import { default as React } from 'react';
+export declare const DEFAULT_BAI_MODAL_Z_INDEX = 1001;
+export interface BAIModalProps extends ModalProps {
+    draggable?: boolean;
+}
+declare const BAIModal: React.FC<BAIModalProps>;
+export default BAIModal;

package/dist/components/BAINotificationItem.d.ts

@@ -0,0 +1,17 @@
+import { default as React, ReactNode } from 'react';
+export interface NotificationItemTemplateStyles {
+    title?: React.CSSProperties;
+    description?: React.CSSProperties;
+    action?: React.CSSProperties;
+    footer?: React.CSSProperties;
+}
+export interface NotificationItemTemplateProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    footer?: ReactNode;
+    styles?: NotificationItemTemplateStyles;
+}
+declare const NotificationItemTemplate: React.FC<NotificationItemTemplateProps>;
+export { NotificationItemTemplate };
+export default NotificationItemTemplate;

package/dist/components/BAIPropertyFilter.d.ts

@@ -0,0 +1,99 @@
+import { default as BAIFlex } from './BAIFlex';
+import { AutoCompleteProps } from 'antd';
+import { default as React, ComponentProps } from 'react';
+export type FilterProperty = {
+    key: string;
+    defaultOperator?: string;
+    propertyLabel: string;
+    type: 'string' | 'boolean';
+    options?: AutoCompleteProps['options'];
+    strictSelection?: boolean;
+    rule?: {
+        message: string;
+        validate: (value: string) => boolean;
+    };
+};
+export interface BAIPropertyFilterProps extends Omit<ComponentProps<typeof BAIFlex>, 'value' | 'onChange'> {
+    value?: string;
+    onChange?: (value: string) => void;
+    defaultValue?: string;
+    filterProperties: Array<FilterProperty>;
+    loading?: boolean;
+}
+export declare function mergeFilterValues(filterStrings: Array<string | undefined | null>, operator?: string): string | undefined;
+/**
+ * Parses the filter value and returns an object containing the property, operator, and value.
+ * @param filter - The filter string to parse.
+ * @returns An object containing the parsed property, operator, and value.
+ */
+export declare function parseFilterValue(filter: string): {
+    property: string;
+    operator: string;
+    value: string;
+};
+/**
+ * BAIPropertyFilter component - Advanced property filtering interface for Backend.AI applications.
+ *
+ * Provides a sophisticated filtering interface for constructing complex filter queries with support for:
+ * - Multiple property types (string and boolean) with type-specific operators
+ * - Dynamic query building through a visual interface
+ * - Autocomplete support with predefined options and suggestions
+ * - Custom validation rules for property values
+ * - Backend.AI query filter minilang compatibility
+ *
+ * The component generates filter query strings compatible with Backend.AI's query system,
+ * enabling powerful data filtering capabilities across the platform.
+ *
+ * @param props - BAIPropertyFilterProps configuration object
+ * @returns React functional component
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with string and boolean properties
+ * <BAIPropertyFilter
+ *   filterProperties={[
+ *     {
+ *       key: 'name',
+ *       propertyLabel: 'Name',
+ *       type: 'string',
+ *       defaultOperator: 'ilike',
+ *     },
+ *     {
+ *       key: 'active',
+ *       propertyLabel: 'Active Status',
+ *       type: 'boolean',
+ *     },
+ *   ]}
+ *   value="name ilike %test% & active == true"
+ *   onChange={(value) => setFilterValue(value)}
+ * />
+ *
+ * // With custom validation and options
+ * <BAIPropertyFilter
+ *   filterProperties={[
+ *     {
+ *       key: 'email',
+ *       propertyLabel: 'Email',
+ *       type: 'string',
+ *       rule: {
+ *         message: 'Please enter a valid email address',
+ *         validate: (value) => /\S+@\S+\.\S+/.test(value),
+ *       },
+ *     },
+ *     {
+ *       key: 'status',
+ *       propertyLabel: 'Status',
+ *       type: 'string',
+ *       options: [
+ *         { label: 'Active', value: 'active' },
+ *         { label: 'Inactive', value: 'inactive' },
+ *       ],
+ *       strictSelection: true,
+ *     },
+ *   ]}
+ *   onChange={handleFilterChange}
+ * />
+ * ```
+ */
+declare const BAIPropertyFilter: React.FC<BAIPropertyFilterProps>;
+export default BAIPropertyFilter;

package/dist/components/BAIRowWrapWithDividers.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+export interface BAIRowWrapWithDividersProps {
+    children: React.ReactNode;
+    wrap?: boolean;
+    rowGap?: number | string;
+    columnGap?: number | string;
+    dividerWidth?: number;
+    dividerColor?: string;
+    /** Top/bottom inset of the vertical divider. Does not affect container size. */
+    dividerInset?: number;
+    itemStyle?: React.CSSProperties;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Wraps like flex-wrap and draws vertical dividers only between items on the same row.
+ * dividerInset shortens only the divider line without changing the container padding.
+ */
+declare const BAIRowWrapWithDividers: React.FC<BAIRowWrapWithDividersProps>;
+export default BAIRowWrapWithDividers;

package/dist/components/BAISelect.d.ts

@@ -0,0 +1,18 @@
+import { Select, SelectProps } from 'antd';
+import { BaseOptionType, DefaultOptionType } from 'antd/es/select';
+import { GetRef } from 'antd/lib';
+import { default as React } from 'react';
+export interface BAISelectProps<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType> extends SelectProps<ValueType, OptionType> {
+    ref?: React.RefObject<GetRef<typeof Select<ValueType, OptionType>> | null>;
+    ghost?: boolean;
+    autoSelectOption?: boolean | ((options: SelectProps<ValueType, OptionType>['options']) => ValueType);
+    tooltip?: string;
+    atBottomThreshold?: number;
+    atBottomStateChange?: (atBottom: boolean) => void;
+    bottomLoading?: boolean;
+    footer?: React.ReactNode;
+    endReached?: () => void;
+}
+declare function BAISelect<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>({ ref, autoSelectOption, ghost, tooltip, atBottomThreshold, atBottomStateChange, footer, endReached, // Destructure the new prop
+...selectProps }: BAISelectProps<ValueType, OptionType>): React.ReactElement;
+export default BAISelect;

package/dist/components/BAIStatistic.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+export interface BAIStatisticProps {
+    title: string;
+    current?: number;
+    total?: number;
+    unit?: string;
+    precision?: number;
+    infinityDisplay?: string;
+    showProgress?: boolean;
+    progressSteps?: number;
+}
+declare const BAIStatistic: React.FC<BAIStatisticProps>;
+export default BAIStatistic;

package/dist/components/BAITag.d.ts

@@ -0,0 +1,6 @@
+import { TagProps } from 'antd/lib/tag';
+import { default as React } from 'react';
+interface BAITagProps extends TagProps {
+}
+declare const BAITag: React.FC<BAITagProps>;
+export default BAITag;

package/dist/components/BAIText.d.ts

@@ -0,0 +1,7 @@
+import { TextProps as AntdTextProps } from 'antd/es/typography/Text';
+import { default as React } from 'react';
+export interface BAITextProps extends AntdTextProps {
+    monospace?: boolean;
+}
+declare const BAIText: React.FC<BAITextProps>;
+export default BAIText;

package/dist/components/BAIUnmountAfterClose.d.ts

@@ -0,0 +1,26 @@
+import { DrawerProps, ModalProps } from 'antd';
+import { default as React } from 'react';
+interface BAIUnmountModalAfterCloseProps {
+    children: React.ReactElement<ModalProps | DrawerProps>;
+}
+/**
+ * A React component that conditionally unmounts its child modal or drawer component
+ * after it has been closed, preserving exit animations.
+ *
+ * This component expects a single child element (such as a Modal or Drawer) with an `open` prop.
+ * It manages an internal mount state to ensure the child remains mounted during exit animations,
+ * and only unmounts after the close animation completes.
+ *
+ * The component intercepts the child's `afterClose` (for Modal) and `afterOpenChange` (for Drawer)
+ * callbacks to update its internal state, while preserving any original callbacks provided.
+ *
+ * @param {BAIUnmountModalAfterCloseProps} props - The props containing a single child element.
+ * @returns {React.ReactElement | null} The cloned child element with enhanced unmounting logic, or null if unmounted.
+ *
+ * @example
+ * <UnmountAfterClose>
+ *   <Modal open={isOpen} afterClose={handleAfterClose} />
+ * </UnmountAfterClose>
+ */
+declare const BAIUnmountAfterClose: React.FC<BAIUnmountModalAfterCloseProps>;
+export default BAIUnmountAfterClose;

package/dist/components/ResourceStatistics.d.ts

@@ -0,0 +1,57 @@
+import { default as React } from 'react';
+interface ResourceData {
+    cpu: {
+        using: {
+            current: number;
+            total?: number;
+        };
+        remaining: {
+            current: number;
+            total?: number;
+        };
+        metadata: {
+            title: string;
+            displayUnit: string;
+        };
+    } | null;
+    memory: {
+        using: {
+            current: number;
+            total?: number;
+        };
+        remaining: {
+            current: number;
+            total?: number;
+        };
+        metadata: {
+            title: string;
+            displayUnit: string;
+        };
+    } | null;
+    accelerators: Array<{
+        key: string;
+        using: {
+            current: number;
+            total?: number;
+        };
+        remaining: {
+            current: number;
+            total?: number;
+        };
+        metadata: {
+            title: string;
+            displayUnit: string;
+        };
+    }>;
+}
+interface ResourceStatisticsProps {
+    resourceData: ResourceData;
+    displayType: 'using' | 'remaining';
+    showProgress?: boolean;
+    precision?: number;
+    progressSteps?: number;
+}
+export declare const processMemoryValue: (value: any, displayUnit: string) => number;
+export declare const convertToNumber: (value: any) => number;
+declare const ResourceStatistics: React.FC<ResourceStatisticsProps>;
+export default ResourceStatistics;

package/dist/components/Table/BAIPaginationInfoText.d.ts

@@ -0,0 +1,7 @@
+export interface PaginationInfoTextProps {
+    start: number;
+    end: number;
+    total: number;
+}
+declare const BAIPaginationInfoText: ({ start, end, total, }: PaginationInfoTextProps) => string;
+export default BAIPaginationInfoText;

package/dist/components/Table/BAITable.d.ts

@@ -0,0 +1,133 @@
+import { TablePaginationConfig, TableProps } from 'antd';
+import { AnyObject } from 'antd/es/_util/type';
+import { ColumnType } from 'antd/es/table';
+import { ReactNode } from 'react';
+/**
+ * Configuration interface for BAITable pagination
+ * Extends Ant Design's TablePaginationConfig but omits 'position' property
+ */
+interface BAITablePaginationConfig extends Omit<TablePaginationConfig, 'position'> {
+    /** Additional content to display in the pagination area */
+    extraContent?: ReactNode;
+}
+/**
+ * Column override properties that can be customized
+ * Used to override default column behavior like visibility
+ */
+export interface BAITableColumnOverrideItem {
+    /** Override the default visibility of a column */
+    hidden?: boolean;
+}
+/**
+ * Record type mapping column keys to their override configurations
+ */
+export type BAITableColumnOverrideRecord = Record<string, BAITableColumnOverrideItem>;
+/**
+ * Configuration for table settings including column overrides
+ * Supports controllable column visibility and customization
+ */
+export interface BAITableSettings {
+    /** Current column property overrides that differ from defaults (controllable) */
+    columnOverrides?: Record<string, BAITableColumnOverrideItem>;
+    /** Default column overrides to use initially */
+    defaultColumnOverrides?: Record<string, BAITableColumnOverrideItem>;
+    /** Callback function called when column overrides change */
+    onColumnOverridesChange?: (overrides: Record<string, BAITableColumnOverrideItem>) => void;
+}
+/**
+ * Extended column type for BAITable with additional properties
+ * Extends Ant Design's ColumnType with custom BAI-specific features
+ */
+export interface BAIColumnType<RecordType = any> extends ColumnType<RecordType> {
+    /** Whether this column should be hidden by default */
+    defaultHidden?: boolean;
+    /** Whether this column is required and cannot be hidden by users */
+    required?: boolean;
+}
+/**
+ * Array type for BAI table columns
+ */
+export type BAIColumnsType<RecordType = any> = BAIColumnType<RecordType>[];
+/**
+ * Utility function to determine if a column should be visible
+ * Takes into account required columns, overrides, and default visibility
+ *
+ * @param column - The column configuration
+ * @param columnKey - The unique key for the column
+ * @param overrides - Column override settings
+ * @returns Whether the column should be visible
+ */
+export declare const isColumnVisible: (column: BAIColumnType<any>, columnKey: string, overrides?: Record<string, BAITableColumnOverrideItem>) => boolean;
+/**
+ * Filters columns to return only visible ones based on overrides
+ *
+ * @param columns - Array of column configurations
+ * @param overrides - Column override settings
+ * @returns Filtered array of visible columns
+ */
+export declare const getVisibleColumns: (columns: BAIColumnsType, overrides?: Record<string, BAITableColumnOverrideItem>) => BAIColumnsType;
+/**
+ * Restores a specific column to its default settings by removing its override
+ *
+ * @param overrides - Current column overrides
+ * @param columnKey - Key of the column to restore
+ * @returns New overrides object without the specified column override
+ */
+export declare const restoreColumnToDefault: (overrides: Record<string, BAITableColumnOverrideItem>, columnKey: string) => Record<string, BAITableColumnOverrideItem>;
+/**
+ * Restores all columns to their default settings by clearing all overrides
+ *
+ * @returns Empty overrides object
+ */
+export declare const restoreAllColumnsToDefault: () => Record<string, BAITableColumnOverrideItem>;
+type BAITableBaseProps<RecordType> = Omit<TableProps<RecordType>, 'onChange'>;
+/**
+ * Props interface for BAITable component
+ * Extends Ant Design's TableProps with additional BAI-specific features
+ */
+export interface BAITableProps<RecordType extends AnyObject> extends BAITableBaseProps<RecordType> {
+    /** Pagination configuration or false to disable pagination */
+    pagination?: false | BAITablePaginationConfig;
+    /** Whether columns should be resizable */
+    resizable?: boolean;
+    /** Current sort order string (e.g., 'name' or '-name' for descending) */
+    order?: string;
+    /** Callback function called when sort order changes */
+    onChangeOrder?: (order?: string) => void;
+    /** Table settings including column visibility controls */
+    tableSettings?: BAITableSettings;
+    /** Array of column configurations using BAIColumnType */
+    columns?: BAIColumnsType<RecordType>;
+}
+/**
+ * BAITable - Enhanced table component with column management and sorting
+ *
+ * A comprehensive table component that extends Ant Design's Table with:
+ * - Column visibility controls with settings modal
+ * - Resizable columns support
+ * - Enhanced sorting with order string support
+ * - Persistent column overrides
+ * - Custom pagination layout
+ *
+ * @param props - BAITableProps configuration
+ * @returns React element
+ *
+ * @example
+ * ```tsx
+ * const columns = [
+ *   { title: 'Name', dataIndex: 'name', key: 'name' },
+ *   { title: 'Age', dataIndex: 'age', key: 'age', defaultHidden: true }
+ * ];
+ *
+ * <BAITable
+ *   columns={columns}
+ *   dataSource={data}
+ *   tableSettings={{
+ *     columnOverrides: {},
+ *     onColumnOverridesChange: setColumnOverrides
+ *   }}
+ * />
+ * ```
+ */
+declare const BAITable: <RecordType extends object = any>({ resizable, columns, components, loading, order, onChangeOrder, tableSettings, ...tableProps }: BAITableProps<RecordType>) => React.ReactElement;
+export default BAITable;