@osdk/react-components 0.2.0-beta.1 → 0.2.0-beta.3

package/build/cjs/public/experimental.d.cts

@@ -1,55 +1,201 @@
-import { ObjectTypeDefinition, PropertyKeys, WirePropertyTypes, CompileTimeMetadata, ObjectSet, WhereClause, ObjectOrInterfaceDefinition, SimplePropertyDef, QueryDefinition, DerivedProperty, Osdk, PrimaryKeyType } from '@osdk/api';
+import { ObjectTypeDefinition, ObjectSet, WhereClause, PropertyKeys, LinkNames, LinkedType, WirePropertyTypes, CompileTimeMetadata, ObjectOrInterfaceDefinition, SimplePropertyDef, QueryDefinition, DerivedProperty, Osdk, PrimaryKeyType } from '@osdk/api';
 import * as React from 'react';
-import React__default, { ReactElement } from 'react';
-import { RowData, Table, Cell } from '@tanstack/react-table';
+import React__default, { ReactNode, ReactElement } from 'react';
+import { RowData, Table, Cell, VisibilityState, ColumnOrderState } from '@tanstack/react-table';
 
 /**
- * Props for a single filter list item component
+ * State for custom filter
  */
-interface FilterListItemProps<Q extends ObjectTypeDefinition, K extends PropertyKeys<Q> = PropertyKeys<Q>, C extends ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>> = ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>>> extends FilterDefinition<Q, K, C> {
+interface CustomFilterState<T = Record<string, unknown>> extends BaseFilterState {
+    type: "custom";
+    customState: T;
+}
+/**
+ * Props passed to custom filter input renderer
+ */
+interface CustomFilterInputRendererProps<Q extends ObjectTypeDefinition, State extends BaseFilterState> {
     objectSet: ObjectSet<Q>;
+    filterState: State;
+    onFilterStateChanged: (newState: State) => void;
+}
+/**
+ * Props passed to custom filter item renderer
+ * Includes full item context in addition to input renderer props
+ */
+interface CustomFilterItemRendererProps<Q extends ObjectTypeDefinition, State extends BaseFilterState> extends CustomFilterInputRendererProps<Q, State> {
+    label: string;
+    onRemove?: () => void;
+}
+/**
+ * Filter definition for custom filters
+ * Provides full control over rendering and filter logic
+ */
+interface CustomFilterDefinition<Q extends ObjectTypeDefinition, State extends BaseFilterState = CustomFilterState> {
+    type: "CUSTOM";
     /**
-     * Called when the state of the filter changes.
-     * Required in controlled mode.
+     * Optional unique identifier for stable keying across filter reorders.
+     * If provided, takes precedence over `key` for state keying.
      */
-    onFilterStateChanged: (state: FilterStateByComponentType[C]) => void;
-    onFilterRemoved?: (key: PropertyKeys<Q>) => void;
+    id?: string;
+    /**
+     * Unique key for this custom filter
+     */
+    key: string;
+    label?: string;
+    filterComponent: "CUSTOM";
+    filterState: State;
+    defaultFilterState?: State;
+    /**
+     * Render the input portion of the filter
+     * Used when rendering within a filter item wrapper
+     */
+    renderInput?: (props: CustomFilterInputRendererProps<Q, State>) => ReactNode;
+    /**
+     * Render the complete filter item
+     * Used when you need full control over the item appearance
+     */
+    renderItem?: (props: CustomFilterItemRendererProps<Q, State>) => ReactNode;
+    /**
+     * Convert filter state to a WhereClause for filtering
+     * Required for the filter to affect the object set
+     */
+    toWhereClause: (state: State) => WhereClause<Q> | undefined;
+    /**
+     * Controls whether this filter is rendered.
+     * When false, the filter is hidden but its state is preserved.
+     * @default true
+     */
+    isVisible?: boolean;
 }
+
 /**
- * A filter definition specifies configuration for a single filter
- *
- * The component type C must be compatible with the property type derived from the key.
- * For example, boolean properties can only use LISTOGRAM,
- * while string properties can use LISTOGRAM, TEXT_TAGS, or CONTAINS_TEXT.
+ * Keys of string properties on an object type
  */
-interface FilterDefinition<Q extends ObjectTypeDefinition, K extends PropertyKeys<Q> = PropertyKeys<Q>, C extends ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>> = ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>>> {
+type StringPropertyKeys<Q extends ObjectTypeDefinition> = PropertyKeys.Filtered<Q, "string">;
+/**
+ * State for keyword search filter
+ */
+interface KeywordSearchFilterState extends BaseFilterState {
+    type: "keywordSearch";
+    searchTerm: string;
     /**
-     * The property key to filter on
+     * How multiple terms are combined
+     * - "AND": All terms must match
+     * - "OR": Any term must match
      */
-    key: K;
+    operator: "AND" | "OR";
+}
+/**
+ * Filter definition for keyword search across string properties
+ */
+interface KeywordSearchFilterDefinition<Q extends ObjectTypeDefinition, K extends StringPropertyKeys<Q> = StringPropertyKeys<Q>> {
+    type: "KEYWORD_SEARCH";
     /**
-     * Display label for the filter
+     * Optional unique identifier for stable keying across filter reorders.
+     */
+    id?: string;
+    /**
+     * Properties to search within
+     * - "all": Search all string properties
+     * - K[]: Search specific string properties
      */
+    properties: "all" | K[];
     label?: string;
     /**
-     * The filter component type to render
-     * Must be compatible with the property type derived from the key, see ValidComponentsForPropertyType
+     * Controlled state for the filter.
+     * When provided, the filter becomes controlled and changes should be
+     * handled via onFilterStateChanged callback.
      */
-    filterComponent: C;
+    filterState?: KeywordSearchFilterState;
     /**
-     * The current state of the filter.
-     * If provided, the filter is controlled.
+     * Default state for uncontrolled mode.
+     * Used when filterState is not provided.
      */
-    filterState: FilterStateByComponentType[C];
+    defaultFilterState?: KeywordSearchFilterState;
+    /**
+     * Controls whether this filter is rendered.
+     * When false, the filter is hidden but its state is preserved.
+     * @default true
+     */
+    isVisible?: boolean;
 }
+
+/**
+ * State for "has link" filter
+ */
+interface HasLinkFilterState extends BaseFilterState {
+    type: "hasLink";
+    hasLink: boolean;
+}
+/**
+ * State for linked property filter
+ * Wraps the filter state of the linked property
+ */
+interface LinkedPropertyFilterState<S extends FilterState = FilterState> extends BaseFilterState {
+    type: "linkedProperty";
+    linkedFilterState: S;
+}
+/**
+ * Filter definition for "Has Link" filter
+ * Filters objects based on whether they have any linked objects of the specified type
+ */
+interface HasLinkFilterDefinition<Q extends ObjectTypeDefinition, L extends LinkNames<Q> = LinkNames<Q>> {
+    type: "HAS_LINK";
+    /**
+     * Optional unique identifier for stable keying across filter reorders.
+     */
+    id?: string;
+    linkName: L;
+    label?: string;
+    filterState: HasLinkFilterState;
+    defaultFilterState?: HasLinkFilterState;
+    /**
+     * Controls whether this filter is rendered.
+     * When false, the filter is hidden but its state is preserved.
+     * @default true
+     */
+    isVisible?: boolean;
+}
+/**
+ * Filter definition for filtering on a property of linked objects
+ */
+interface LinkedPropertyFilterDefinition<Q extends ObjectTypeDefinition, L extends LinkNames<Q>, LinkedQ extends ObjectTypeDefinition = LinkedType<Q, L>, LinkedK extends PropertyKeys<LinkedQ> = PropertyKeys<LinkedQ>, LinkedC extends ValidComponentsForPropertyType<PropertyTypeFromKey<LinkedQ, LinkedK>> = ValidComponentsForPropertyType<PropertyTypeFromKey<LinkedQ, LinkedK>>> {
+    type: "LINKED_PROPERTY";
+    /**
+     * Optional unique identifier for stable keying across filter reorders.
+     */
+    id?: string;
+    linkName: L;
+    linkedPropertyKey: LinkedK;
+    linkedFilterComponent: LinkedC;
+    linkedFilterState: FilterStateByComponentType[LinkedC];
+    defaultLinkedFilterState?: FilterStateByComponentType[LinkedC];
+    filterState: LinkedPropertyFilterState<FilterStateByComponentType[LinkedC]>;
+    label?: string;
+    /**
+     * Controls whether this filter is rendered.
+     * When false, the filter is hidden but its state is preserved.
+     * @default true
+     */
+    isVisible?: boolean;
+}
+
 /**
  * Helper type to extract the property type from an ObjectTypeDefinition given a property key
  */
 type PropertyTypeFromKey<Q extends ObjectTypeDefinition, K extends PropertyKeys<Q>> = CompileTimeMetadata<Q>["properties"][K]["type"];
+/**
+ * All available filter component types
+ */
+type FilterComponentType = "LISTOGRAM" | "DATE_RANGE" | "NUMBER_RANGE" | "TEXT_TAGS" | "CONTAINS_TEXT" | "SINGLE_SELECT" | "MULTI_SELECT" | "SINGLE_DATE" | "MULTI_DATE" | "TIMELINE" | "CHECKBOX_LIST" | "TOGGLE";
 /**
  * Gets valid component types for a given property type
  */
-type ValidComponentsForPropertyType<P extends WirePropertyTypes> = P extends "boolean" ? "LISTOGRAM" : P extends "string" ? "LISTOGRAM" | "TEXT_TAGS" | "CONTAINS_TEXT" : P extends "datetime" | "timestamp" ? "DATE_RANGE" : P extends "double" | "integer" | "long" | "float" | "short" | "byte" | "decimal" ? "NUMBER_RANGE" : never;
+type ValidComponentsForPropertyType<P extends WirePropertyTypes> = P extends "boolean" ? "LISTOGRAM" | "CHECKBOX_LIST" | "SINGLE_SELECT" | "TOGGLE" : P extends "string" ? "LISTOGRAM" | "TEXT_TAGS" | "CONTAINS_TEXT" | "SINGLE_SELECT" | "MULTI_SELECT" | "CHECKBOX_LIST" : P extends "datetime" | "timestamp" ? "DATE_RANGE" | "SINGLE_DATE" | "MULTI_DATE" | "TIMELINE" : P extends "double" | "integer" | "long" | "float" | "short" | "byte" | "decimal" ? "NUMBER_RANGE" | "SINGLE_SELECT" | "MULTI_SELECT" : never;
+/**
+ * Union of all possible filter states
+ */
+type FilterState = ExactMatchFilterState<string | boolean> | DateRangeFilterState | ContainsTextFilterState | NumberRangeFilterState | SelectFilterState<string | boolean | number> | SelectFilterState<Date> | TimelineFilterState | ToggleFilterState | HasLinkFilterState | LinkedPropertyFilterState | KeywordSearchFilterState | CustomFilterState;
 /**
  * Maps component types to their corresponding state types
  */
@@ -59,8 +205,18 @@ interface FilterStateByComponentType {
     TEXT_TAGS: ExactMatchFilterState<string>;
     CONTAINS_TEXT: ContainsTextFilterState;
     NUMBER_RANGE: NumberRangeFilterState;
+    SINGLE_SELECT: SelectFilterState<string | boolean | number>;
+    MULTI_SELECT: SelectFilterState<string | boolean | number>;
+    SINGLE_DATE: SelectFilterState<Date>;
+    MULTI_DATE: SelectFilterState<Date>;
+    TIMELINE: TimelineFilterState;
+    CHECKBOX_LIST: SelectFilterState<string>;
+    TOGGLE: ToggleFilterState;
 }
-type FilterStateType = "EXACT_MATCH" | "DATE_RANGE" | "NUMBER_RANGE" | "CONTAINS_TEXT";
+/**
+ * All filter state discriminator types
+ */
+type FilterStateType = "EXACT_MATCH" | "DATE_RANGE" | "NUMBER_RANGE" | "CONTAINS_TEXT" | "SELECT" | "TIMELINE" | "TOGGLE" | "hasLink" | "linkedProperty" | "keywordSearch" | "custom";
 /**
  * Base interface for all filter states
  * Contains common properties shared across all filter types
@@ -111,7 +267,130 @@ interface NumberRangeFilterState extends BaseFilterState {
      */
     maxValue?: number;
 }
+/**
+ * Consolidated state type for select-based filters.
+ * Used by SINGLE_SELECT, MULTI_SELECT, SINGLE_DATE, MULTI_DATE, and CHECKBOX_LIST.
+ */
+interface SelectFilterState<T = string | boolean | number | Date> extends BaseFilterState {
+    type: "SELECT";
+    selectedValues: T[];
+}
+interface TimelineFilterState extends BaseFilterState {
+    type: "TIMELINE";
+    startDate?: Date;
+    endDate?: Date;
+    granularity?: "day" | "week" | "month" | "quarter" | "year";
+}
+interface ToggleFilterState extends BaseFilterState {
+    type: "TOGGLE";
+    enabled: boolean;
+}
+/**
+ * A property filter definition specifies configuration for filtering on a single property
+ *
+ * The component type C must be compatible with the property type derived from the key.
+ * For example, boolean properties can only use LISTOGRAM, CHECKBOX_LIST, or SINGLE_SELECT,
+ * while string properties can use LISTOGRAM, TEXT_TAGS, CONTAINS_TEXT, SINGLE_SELECT, MULTI_SELECT, or CHECKBOX_LIST.
+ */
+interface PropertyFilterDefinition<Q extends ObjectTypeDefinition, K extends PropertyKeys<Q> = PropertyKeys<Q>, C extends ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>> = ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>>> {
+    /**
+     * Discriminator for filter definition type
+     */
+    type: "PROPERTY";
+    /**
+     * Optional unique identifier for stable keying across filter reorders.
+     */
+    id?: string;
+    /**
+     * The property key to filter on
+     */
+    key: K;
+    /**
+     * Display label for the filter
+     */
+    label?: string;
+    /**
+     * The filter component type to render
+     * Must be compatible with the property type derived from the key, see ValidComponentsForPropertyType
+     */
+    filterComponent: C;
+    /**
+     * The current state of the filter.
+     * If provided, the filter is controlled.
+     */
+    filterState: FilterStateByComponentType[C];
+    /**
+     * Controls whether this filter is rendered.
+     * When false, the filter is hidden but its state is preserved.
+     * @default true
+     */
+    isVisible?: boolean;
+}
+/**
+ * Props for a single filter list item component.
+ * Extends PropertyFilterDefinition with runtime props for rendering.
+ */
+interface FilterListItemProps<Q extends ObjectTypeDefinition, K extends PropertyKeys<Q> = PropertyKeys<Q>, C extends ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>> = ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>>> extends PropertyFilterDefinition<Q, K, C> {
+    objectSet: ObjectSet<Q>;
+    /**
+     * Called when the state of the filter changes.
+     * Required in controlled mode.
+     */
+    onFilterStateChanged: (state: FilterStateByComponentType[C]) => void;
+    onFilterRemoved?: (key: PropertyKeys<Q>) => void;
+}
 
+/**
+ * Category for organizing filters in the add filter menu
+ */
+type FilterCategory = "ALL_PROPERTIES" | "SINGLE_PROPERTY" | "LINKED_OBJECT";
+/**
+ * Template for a filter that can be added via the add filter menu
+ */
+interface FilterTemplate {
+    /**
+     * Unique identifier for the template
+     */
+    id: string;
+    /**
+     * Display label for the filter
+     */
+    label: string;
+    /**
+     * Property key this filter applies to
+     */
+    key: string;
+    /**
+     * The type of filter component to use
+     */
+    filterComponent: FilterComponentType;
+    /**
+     * Icon to display next to the filter label.
+     * Can be a string (icon name) or a ReactNode for custom icons.
+     */
+    icon: string | ReactNode;
+    /**
+     * Whether multiple instances of this filter can be added
+     */
+    allowMultiple: boolean;
+    /**
+     * Category for grouping in the add filter menu
+     */
+    category: FilterCategory;
+}
+
+/**
+ * Union type of all filter definition types
+ */
+type FilterDefinitionUnion<Q extends ObjectTypeDefinition> = PropertyFilterDefinition<Q> | HasLinkFilterDefinition<Q> | LinkedPropertyFilterDefinition<Q, LinkNames<Q>> | KeywordSearchFilterDefinition<Q> | CustomFilterDefinition<Q>;
+/**
+ * Extract the key from a filter definition union
+ */
+type FilterKey<Q extends ObjectTypeDefinition> = FilterDefinitionUnion<Q> extends infer D ? D extends {
+    key: infer K;
+} ? K : D extends {
+    linkName: infer L;
+} ? L : never : never;
 interface FilterListProps<Q extends ObjectTypeDefinition> {
     /**
      * The set of objects to be filtered
@@ -121,7 +400,7 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
      * The definition for all supported filter items in the list
      * If not supplied, all filterable properties will be available
      */
-    filterDefinitions?: Array<FilterDefinition<Q>>;
+    filterDefinitions?: Array<FilterDefinitionUnion<Q>>;
     /**
      * The current where clause to filter the objectSet.
      * If provided, the filter clause is controlled.
@@ -142,12 +421,12 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
      */
     filterOperator?: "and" | "or";
     /**
-     * Called when filter state change
+     * Called when filter state changes
      *
-     * @param filterKey The key of the updated filter
+     * @param definition The filter definition whose state changed
      * @param newState The updated filter state
      */
-    onFilterStateChanged?: (filterKey: FilterKey<Q>, newState: FilterState<Q>) => void;
+    onFilterStateChanged?: (definition: FilterDefinitionUnion<Q>, newState: FilterState) => void;
     /**
      * Called when a filter is added
      * If provided, user will be allowed to add filters
@@ -155,7 +434,7 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
      * @param filterKey The key of the added filter
      * @param newDefinitions The filter list with the new filter added
      */
-    onFilterAdded?: (filterKey: FilterKey<Q>, newDefinitions: Array<FilterDefinition<Q>>) => void;
+    onFilterAdded?: (filterKey: FilterKey<Q>, newDefinitions: Array<FilterDefinitionUnion<Q>>) => void;
     /**
      * Called when a filter is removed
      * If provided, user will be allowed to remove filters
@@ -163,17 +442,42 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
      * @param filterKey The key of the removed filter
      * @param newDefinitions The updated filter list with the filter removed
      */
-    onFilterRemoved?: (filterKey: FilterKey<Q>, newDefinitions: Array<FilterDefinition<Q>>) => void;
+    onFilterRemoved?: (filterKey: FilterKey<Q>, newDefinitions: Array<FilterDefinitionUnion<Q>>) => void;
     /**
      * Called when filters are reordered
      * If provided, the filter list becomes sortable
      *
      * @param newOrder The updated filter definitions in new order
      */
-    onFiltersReordered?: (newOrder: ReadonlyArray<FilterDefinition<Q>>) => void;
+    onFiltersReordered?: (newOrder: ReadonlyArray<FilterDefinitionUnion<Q>>) => void;
+    /**
+     * Show reset filters button in header
+     */
+    showResetButton?: boolean;
+    /**
+     * Called when reset button is clicked
+     */
+    onReset?: () => void;
+    /**
+     * Available filter templates for the "Add filter" menu.
+     * When provided along with onFilterAdded, clicking the add button
+     * shows a popover with these templates organized by category.
+     */
+    filterTemplates?: FilterTemplate[];
+    /**
+     * Called when a filter template is selected from the add filter menu.
+     * The consumer should create a new filter definition and add it to filterDefinitions.
+     */
+    onFilterTemplateSelected?: (template: FilterTemplate) => void;
+    /**
+     * Show count of active filters in header
+     */
+    showActiveFilterCount?: boolean;
+    /**
+     * Additional CSS class name
+     */
+    className?: string;
 }
-type FilterKey<Q extends ObjectTypeDefinition> = FilterDefinition<Q>["key"];
-type FilterState<Q extends ObjectTypeDefinition> = FilterDefinition<Q>["filterState"];
 
 type ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>> = {
     locator: ColumnDefinitionLocator<Q, RDPs, FunctionColumns>;
@@ -192,6 +496,20 @@ type ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record
     orderable?: boolean;
     filterable?: boolean;
     renderCell?: (object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, locator: ColumnDefinitionLocator<Q, RDPs, FunctionColumns>) => React.ReactNode;
+    /**
+     * If provided, this will be used in the column header.
+     * If both columnName and renderHeader are provided, renderHeader will take precedence in the table header.
+     * columnName will still be used in other parts where the column name is displayed.
+     *
+     * If not provided,
+     * for a property column, the property displayName will be used
+     * for other columns, the id will be used.
+     */
+    columnName?: string;
+    /**
+     * If provided, this will be used to render the header component.
+     * When both columnName and renderHeader are provided, renderHeader will take precedence in the table header.
+     */
     renderHeader?: () => React.ReactNode;
 };
 type ColumnDefinitionLocator<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>> = {
@@ -204,6 +522,9 @@ type ColumnDefinitionLocator<Q extends ObjectOrInterfaceDefinition, RDPs extends
     type: "rdp";
     id: keyof RDPs;
     creator: DerivedProperty.Creator<Q, RDPs[keyof RDPs]>;
+} | {
+    type: "custom";
+    id: string;
 };
 interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>> {
     /**
@@ -221,7 +542,7 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
      *
      * @default true
      */
-    filterable?: boolean;
+    enableFiltering?: boolean;
     /**
      * The current where clause to filter the objects in the table.
      * If provided, the filter is controlled.
@@ -239,7 +560,25 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
      *
      * @default true
      */
-    orderable?: boolean;
+    enableOrdering?: boolean;
+    /**
+     * Whether columns can be pinned by the user.
+     *
+     * @default true
+     */
+    enableColumnPinning?: boolean;
+    /**
+     * Whether columns can be resized by the user.
+     *
+     * @default true
+     */
+    enableColumnResizing?: boolean;
+    /**
+     * Whether the column configuration dialog for column visibility and ordering is available to the user.
+     *
+     * @default true
+     */
+    enableColumnConfig?: boolean;
     /**
      * The default order by clause to sort the objects in the table.
      * If provided without orderBy prop, the sorting is uncontrolled.
@@ -269,11 +608,11 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
         direction: "asc" | "desc";
     }>) => void;
     /**
-     * Called when the visible columns change.
+     * Called when the column visibility or ordering changed.
      *
      * If provided, the table will allow the user to show/hide columns.
      *
-     * @param newStates The new list of column visibility states
+     * @param newStates The columns sorted in their display order in the table and their visibility state.
      */
     onColumnVisibilityChanged?: (newStates: Array<{
         columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns;
@@ -294,9 +633,9 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
      * Called when a column is resized.
      *
      * @param columnId The ID of the resized column
-     * @param newWidth The new width of the column
+     * @param newWidth The new width of the column. When newWidth = null, the column size is reset.
      */
-    onColumnResize?: (columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns, newWidth: number) => void;
+    onColumnResize?: (columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns, newWidth: number | null) => void;
     /**
      * Called when a row is clicked.
      *
@@ -345,8 +684,43 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
  * <ObjectTable objectType={MyObjectType} />
  * ```
  */
-declare function ObjectTable<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>>({ objectType, columnDefinitions, filter, orderBy, defaultOrderBy, onOrderByChanged, onColumnsPinnedChanged, onRowSelection, renderCellContextMenu, selectionMode, selectedRows, ...props }: ObjectTableProps<Q, RDPs, FunctionColumns>): React__default.ReactElement;
+declare function ObjectTable<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>>({ objectType, columnDefinitions, filter, orderBy, defaultOrderBy, onOrderByChanged, onColumnsPinnedChanged, onColumnResize, onRowSelection, renderCellContextMenu, selectionMode, selectedRows, onColumnVisibilityChanged, enableOrdering, enableColumnPinning, enableColumnResizing, enableColumnConfig, ...props }: ObjectTableProps<Q, RDPs, FunctionColumns>): React__default.ReactElement;
+
+interface ColumnOption {
+    id: string;
+    name: string;
+    canSort: boolean;
+}
 
+interface HeaderMenuFeatureFlags {
+    /**
+     * Whether sorting menu items should be shown.
+     * When false, hides "Sort ascending", "Sort descending", "Sort on multiple columns", and "Clear all sorts".
+     */
+    showSortingItems?: boolean;
+    /**
+     * Whether pinning menu items should be shown.
+     * When false, hides "Pin column" and "Unpin Column".
+     */
+    showPinningItems?: boolean;
+    /**
+     * Whether resize menu item should be shown.
+     * When false, hides "Reset Column Size".
+     */
+    showResizeItem?: boolean;
+    /**
+     * Whether column config menu item should be shown.
+     * When false, hides "Configure Columns".
+     */
+    showConfigItem?: boolean;
+}
+
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        columnName?: string;
+        isVisible?: boolean;
+    }
+}
 interface BaseTableProps<TData extends RowData> {
     table: Table<TData>;
     isLoading?: boolean;
@@ -356,7 +730,24 @@ interface BaseTableProps<TData extends RowData> {
     renderCellContextMenu?: (row: TData, cell: Cell<TData, unknown>) => React__default.ReactNode;
     className?: string;
     error?: Error;
+    headerMenuFeatureFlags?: HeaderMenuFeatureFlags;
+}
+declare function BaseTable<TData extends RowData>({ table, isLoading, fetchNextPage, onRowClick, rowHeight, renderCellContextMenu, className, error, headerMenuFeatureFlags, }: BaseTableProps<TData>): ReactElement;
+
+interface ColumnConfig {
+    columnId: string;
+    isVisible: boolean;
+}
+type ColumnConfigOptions = Array<Pick<ColumnOption, "id" | "name">>;
+interface ColumnConfigDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    columnOptions: ColumnConfigOptions;
+    currentVisibility?: VisibilityState;
+    currentColumnOrder?: ColumnOrderState;
+    onApply: (columns: ColumnConfig[]) => void;
+    isValidConfig?: (columns: ColumnConfig[]) => boolean;
 }
-declare function BaseTable<TData extends RowData>({ table, isLoading, fetchNextPage, onRowClick, rowHeight, renderCellContextMenu, className, error, }: BaseTableProps<TData>): ReactElement;
+declare function ColumnConfigDialog({ isOpen, onClose, columnOptions, currentVisibility, currentColumnOrder, onApply, isValidConfig, }: ColumnConfigDialogProps): React__default.ReactElement | null;
 
-export { BaseTable, type BaseTableProps, type ColumnDefinition, type ColumnDefinitionLocator, type FilterListItemProps, type FilterListProps, ObjectTable, type ObjectTableProps };
+export { BaseTable, type BaseTableProps, ColumnConfigDialog, type ColumnConfigDialogProps, type ColumnConfigOptions, type ColumnDefinition, type ColumnDefinitionLocator, type FilterListItemProps, type FilterListProps, ObjectTable, type ObjectTableProps };

package/build/esm/base-components/action-button/ActionButton.js

@@ -0,0 +1,31 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Button } from "@base-ui/react/button";
+import classNames from "classnames";
+import React from "react";
+import styles from "./ActionButton.module.css";
+export function ActionButton({
+  variant = "secondary",
+  className,
+  ...rest
+}) {
+  return /*#__PURE__*/React.createElement(Button, _extends({
+    className: classNames(styles.button, variant === "primary" ? styles.primaryButton : styles.secondaryButton, className)
+  }, rest));
+}
+//# sourceMappingURL=ActionButton.js.map

package/build/esm/base-components/action-button/ActionButton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionButton.js","names":["Button","classNames","React","styles","ActionButton","variant","className","rest","createElement","_extends","button","primaryButton","secondaryButton"],"sources":["ActionButton.tsx"],"sourcesContent":["/*\n * Copyright 2025 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Button } from \"@base-ui/react/button\";\nimport classNames from \"classnames\";\nimport React from \"react\";\nimport styles from \"./ActionButton.module.css\";\n\nexport interface ButtonProps\n  extends React.ButtonHTMLAttributes<HTMLButtonElement>\n{\n  variant?: \"primary\" | \"secondary\";\n}\n\nexport function ActionButton({\n  variant = \"secondary\",\n  className,\n  ...rest\n}: ButtonProps): React.ReactElement {\n  return (\n    <Button\n      className={classNames(\n        styles.button,\n        variant === \"primary\" ? styles.primaryButton : styles.secondaryButton,\n        className,\n      )}\n      {...rest}\n    />\n  );\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,MAAM,QAAQ,uBAAuB;AAC9C,OAAOC,UAAU,MAAM,YAAY;AACnC,OAAOC,KAAK,MAAM,OAAO;AACzB,OAAOC,MAAM,MAAM,2BAA2B;AAQ9C,OAAO,SAASC,YAAYA,CAAC;EAC3BC,OAAO,GAAG,WAAW;EACrBC,SAAS;EACT,GAAGC;AACQ,CAAC,EAAsB;EAClC,oBACEL,KAAA,CAAAM,aAAA,CAACR,MAAM,EAAAS,QAAA;IACLH,SAAS,EAAEL,UAAU,CACnBE,MAAM,CAACO,MAAM,EACbL,OAAO,KAAK,SAAS,GAAGF,MAAM,CAACQ,aAAa,GAAGR,MAAM,CAACS,eAAe,EACrEN,SACF;EAAE,GACEC,IAAI,CACT,CAAC;AAEN","ignoreList":[]}