@osdk/react-components 0.1.0 → 0.2.0-beta.10

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,17 +267,109 @@ 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;
+}
 
+/**
+ * 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
      */
     objectSet: ObjectSet<Q>;
+    /**
+     * Optional title to display in the filter list header
+     */
+    title?: string;
+    /**
+     * Optional icon to display next to the title
+     */
+    titleIcon?: React__default.ReactNode;
     /**
      * 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 +390,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,25 +403,52 @@ 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
      *
      * @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>) => void;
     /**
-     * Called when filters are reordered
-     * If provided, the filter list becomes sortable
-     *
-     * @param newOrder The updated filter definitions in new order
+     * Show reset filters button in header
+     */
+    showResetButton?: boolean;
+    /**
+     * Called when reset button is clicked
      */
-    onFiltersReordered?: (newOrder: ReadonlyArray<FilterDefinition<Q>>) => void;
+    onReset?: () => void;
+    /**
+     * Show count of active filters in header
+     */
+    showActiveFilterCount?: boolean;
+    /**
+     * Additional CSS class name
+     */
+    className?: string;
+    /**
+     * Custom render function for the "Add filter" button.
+     * When not provided, a default button is shown if onFilterAdded is set.
+     */
+    renderAddFilterButton?: () => React__default.ReactNode;
+}
+
+declare function FilterList<Q extends ObjectTypeDefinition>(props: FilterListProps<Q>): React__default.ReactElement;
+
+interface ColumnOption {
+    id: string;
+    name: string;
+    canSort: boolean;
+}
+interface CellIdentifier {
+    rowId: string;
+    columnId: string;
+}
+interface CellValueState<TData extends RowData = unknown> {
+    newValue: TData;
+    oldValue: TData;
 }
-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>;
@@ -191,7 +466,22 @@ type ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record
     resizable?: boolean;
     orderable?: boolean;
     filterable?: boolean;
+    editable?: 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,12 +494,22 @@ 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>> {
     /**
-     * The object type of the object
+     * The object or interface type of the object
+     * If objectSet is not provided, objects will be fetched based on this type.
      */
     objectType: Q;
+    /**
+     * The set of objects to show in the table.
+     * If provided and the objectType is not an interface, the table will use objectSet to fetch objects instead of fetching based on objectType.
+     */
+    objectSet?: ObjectSet<Q>;
+    objectSetOptions?: ObjectSetOptions<Q>;
     /**
      * Ordered list of column definitions to show in the table
      *
@@ -221,7 +521,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 +539,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 +587,24 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
         direction: "asc" | "desc";
     }>) => void;
     /**
-     * Called when the visible columns change.
+     * Called after the value of a cell is edited and committed by the user.
+     *
+     * @param cell The cell that was edited, identified by its row and column IDs
+     * @param state The new and old values of the cell
+     */
+    onCellValueChanged?: (cell: CellIdentifier, state: CellValueState) => void;
+    /**
+     * If provided, the button Submit Edits will be shown in the table
+     *
+     * @param edits a map of cellId (stringified CellIdentifier) to the new and old values of the cell
+     */
+    onSubmitEdits?: (edits: Record<string, CellValueState>) => Promise<void>;
+    /**
+     * 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 +625,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.
      *
@@ -336,6 +667,20 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
     rowHeight?: number;
     className?: string;
 }
+interface ObjectSetOptions<Q extends ObjectOrInterfaceDefinition> {
+    /**
+     * Object sets to union with
+     */
+    union?: ObjectSet<Q>[];
+    /**
+     * Object sets to intersect with
+     */
+    intersect?: ObjectSet<Q>[];
+    /**
+     * Object sets to subtract from
+     */
+    subtract?: ObjectSet<Q>[];
+}
 
 /**
  * ObjectTable - A headless table component for displaying OSDK object sets
@@ -345,8 +690,48 @@ 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, objectSet, columnDefinitions, filter, objectSetOptions, orderBy, defaultOrderBy, onOrderByChanged, onColumnsPinnedChanged, onColumnResize, onRowSelection, renderCellContextMenu, selectionMode, selectedRows, onColumnVisibilityChanged, onCellValueChanged, onSubmitEdits, enableOrdering, enableColumnPinning, enableColumnResizing, enableColumnConfig, ...props }: ObjectTableProps<Q, RDPs, FunctionColumns>): React__default.ReactElement;
 
+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 = unknown, TValue = unknown> {
+        columnName?: string;
+        isVisible?: boolean;
+        editable?: boolean;
+        dataType?: string;
+    }
+    interface TableMeta<TData extends RowData = unknown> {
+        onCellEdit?: (cellId: string, state: CellValueState) => void;
+        cellEdits?: Record<string, CellValueState>;
+    }
+}
+interface EditableConfig {
+    onSubmitEdits?: () => Promise<void>;
+    clearEdits?: () => void;
+    cellEdits?: Record<string, CellValueState>;
+}
 interface BaseTableProps<TData extends RowData> {
     table: Table<TData>;
     isLoading?: boolean;
@@ -356,7 +741,25 @@ interface BaseTableProps<TData extends RowData> {
     renderCellContextMenu?: (row: TData, cell: Cell<TData, unknown>) => React__default.ReactNode;
     className?: string;
     error?: Error;
+    headerMenuFeatureFlags?: HeaderMenuFeatureFlags;
+    editableConfig?: EditableConfig;
+}
+declare function BaseTable<TData extends RowData>({ table, isLoading, fetchNextPage, onRowClick, rowHeight, renderCellContextMenu, className, error, headerMenuFeatureFlags, editableConfig, }: 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, type CellIdentifier, type CellValueState, ColumnConfigDialog, type ColumnConfigDialogProps, type ColumnConfigOptions, type ColumnDefinition, type ColumnDefinitionLocator, type FilterComponentType, type FilterDefinitionUnion, FilterList, type FilterListItemProps, type FilterListProps, type FilterState, ObjectTable, type ObjectTableProps, type PropertyFilterDefinition };