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

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,68 @@ 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
+     */
+    onReset?: () => void;
+    /**
+     * Show count of active filters in header
+     */
+    showActiveFilterCount?: boolean;
+    /**
+     * Additional CSS class name
      */
-    onFiltersReordered?: (newOrder: ReadonlyArray<FilterDefinition<Q>>) => void;
+    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 CellEditInfo<TData extends RowData = unknown, CellValue = unknown> extends CellIdentifier {
+    newValue: CellValue;
+    oldValue: CellValue;
+    originalRowData: TData;
+}
+type EditMode = {
+    type: "always";
+    isActive: true;
+} | {
+    type: "manual";
+    isActive: boolean;
+    setActive: (value: boolean) => void;
+};
+interface EditableConfig<TData extends RowData = unknown, CellValue = unknown> {
+    cellEdits: Record<string, CellEditInfo<TData, CellValue>>;
+    onCellEdit: (cellId: string, info: CellEditInfo<TData, CellValue>) => void;
+    onSubmitEdits?: () => Promise<boolean>;
+    clearEdits: () => void;
+    editMode: EditMode;
 }
-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 +482,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 +510,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 +537,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 +555,33 @@ 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;
+    /**
+     * Controls the edit mode behavior of the table.
+     * - "always": Editable cells are immediately in edit mode on row clicked.
+     * - "manual": User can toggle edit mode on/off via the Edit Table button.
+     *
+     * @default "manual"
+     */
+    editMode?: "always" | "manual";
     /**
      * The default order by clause to sort the objects in the table.
      * If provided without orderBy prop, the sorting is uncontrolled.
@@ -269,11 +611,26 @@ 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 info An object containing details about the cell that was edited,
+     * including the rowId, columnId, new and old values, and the row data before the edit
+     */
+    onCellValueChanged?: (info: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>) => void;
+    /**
+     * If provided, the button Submit Edits will be shown in the table
+     *
+     * @param edits an array of edit info containing details about the edited cells
+     * including the rowId, columnId, new and old values, and the row data before the edit
+     * @return a promise that resolves to true if the edits were successfully submitted
+     */
+    onSubmitEdits?: (edits: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>[]) => Promise<boolean>;
+    /**
+     * 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 +651,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 +693,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 +716,44 @@ 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, editMode, ...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, info: CellEditInfo<TData, unknown>) => void;
+        cellEdits?: Record<string, CellEditInfo<TData, unknown>>;
+        isInEditMode?: boolean;
+    }
+}
 interface BaseTableProps<TData extends RowData> {
     table: Table<TData>;
     isLoading?: boolean;
@@ -356,7 +763,25 @@ interface BaseTableProps<TData extends RowData> {
     renderCellContextMenu?: (row: TData, cell: Cell<TData, unknown>) => React__default.ReactNode;
     className?: string;
     error?: Error;
+    headerMenuFeatureFlags?: HeaderMenuFeatureFlags;
+    editableConfig?: EditableConfig<TData, unknown>;
+}
+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 CellEditInfo, 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 };