@osdk/react-components 0.2.0-beta.2 → 0.2.0-beta.21

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 * 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 { ObjectTypeDefinition, ObjectSet, WhereClause, PropertyKeys, LinkNames, LinkedType, WirePropertyTypes, CompileTimeMetadata, ObjectOrInterfaceDefinition, SimplePropertyDef, QueryDefinition, QueryMetadata, Osdk, DerivedProperty, PrimaryKeyType, Media } from '@osdk/api';
+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,152 @@ 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];
+    /**
+     * Maps filter values to colors for visual differentiation.
+     * Used by CHECKBOX_LIST (color dots) and LISTOGRAM (per-row bar colors).
+     */
+    colorMap?: Record<string, string>;
+    /**
+     * Configuration for LISTOGRAM display mode.
+     * Only applies when filterComponent is "LISTOGRAM".
+     */
+    listogramConfig?: {
+        displayMode?: "full" | "count" | "minimal";
+        maxVisibleItems?: number;
+    };
+    /**
+     * 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;
+}
+
+type RenderFilterInput<D> = (props: {
+    definition: D;
+    filterKey: string;
+    filterState: FilterState | undefined;
+    onFilterStateChanged: (state: FilterState) => void;
+}) => React__default.ReactNode;
+interface BaseFilterListProps<D> {
+    filterDefinitions?: Array<D>;
+    filterStates: Map<string, FilterState>;
+    onFilterStateChanged: (filterKey: string, state: FilterState) => void;
+    renderInput: RenderFilterInput<D>;
+    getFilterKey: (definition: D) => string;
+    getFilterLabel: (definition: D) => string;
+    activeFilterCount: number;
+    onReset?: () => void;
+    onFilterAdded?: () => void;
+    onFilterRemoved?: (filterKey: string) => void;
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    title?: string;
+    titleIcon?: React__default.ReactNode;
+    showResetButton?: boolean;
+    showActiveFilterCount?: boolean;
+    enableSorting?: boolean;
+    className?: string;
+    renderAddFilterButton?: () => React__default.ReactNode;
+}
+
+declare function BaseFilterList<D>(props: BaseFilterListProps<D>): React__default.ReactElement;
 
+/**
+ * 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,38 +433,126 @@ 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;
+    /**
+     * Controls how filter visibility (add/remove) is managed.
+     *
+     * - `"controlled"` (default): The consumer manages which filters are
+     *   visible via `filterDefinitions`. Filters with `isVisible: false` are
+     *   excluded from the rendered list.
+     * - `"uncontrolled"`: FilterList manages visibility internally. An "Add
+     *   filter" popover is rendered for filters with `isVisible: false`, and
+     *   each visible filter shows a remove button.
+     *
+     * @default "controlled"
+     */
+    addFilterMode?: "controlled" | "uncontrolled";
     /**
-     * Called when a filter is added
-     * If provided, user will be allowed to add filters
+     * Called when a filter is added (shown).
+     *
+     * In uncontrolled mode, this fires when a user selects a hidden filter
+     * from the "Add filter" popover.
      *
      * @param filterKey The key of the added filter
-     * @param newDefinitions The filter list with the new filter added
+     * @param newDefinitions The current filter definitions array
      */
-    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
+     * Called when a filter is removed (hidden).
+     *
+     * In uncontrolled mode, this fires as a notification after the filter
+     * is hidden internally.
      *
      * @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
+     * Enable drag-and-drop reordering of filters.
+     * When true, drag handles are rendered and filters can be reordered.
+     * Reorder state is managed internally; consumers who need to track order
+     * should use controlled filterDefinitions.
+     */
+    enableSorting?: boolean;
+    /**
+     * Whether the filter list panel is collapsed
+     */
+    collapsed?: boolean;
+    /**
+     * Called when the collapsed state changes
+     */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /**
+     * Initial filter states for hydrating from external storage.
+     * These states are merged over definition defaults on mount.
+     * Use onFilterStateChanged to persist state changes externally.
+     */
+    initialFilterStates?: Map<string, FilterState>;
+    /**
+     * Show reset filters button in header
+     */
+    showResetButton?: boolean;
+    /**
+     * Called when reset button is clicked
+     */
+    onReset?: () => void;
+    /**
+     * Show count of active filters in header
      */
-    onFiltersReordered?: (newOrder: ReadonlyArray<FilterDefinition<Q>>) => void;
+    showActiveFilterCount?: boolean;
+    /**
+     * Additional CSS class name
+     */
+    className?: string;
+    /**
+     * Custom render function for the "Add filter" button.
+     * Only used in controlled mode. In uncontrolled mode, the built-in
+     * AddFilterPopover is rendered automatically.
+     */
+    renderAddFilterButton?: () => React__default.ReactNode;
+}
+
+declare function FilterList<Q extends ObjectTypeDefinition>(props: FilterListProps<Q>): React__default.ReactElement;
+
+declare function serializeFilterStates(states: Map<string, FilterState>): string;
+declare function deserializeFilterStates(json: string): Map<string, FilterState>;
+
+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 | null;
+    oldValue: CellValue | null;
+    originalRowData: TData;
+}
+type EditModeState = {
+    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;
+    editModeState: EditModeState;
+    onCellValidationError: (cellId: string, error: string) => void;
+    validationErrors: Map<string, string>;
+    clearCellValidationError: (cellId: string) => void;
 }
-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,25 +570,86 @@ type ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record
     resizable?: boolean;
     orderable?: boolean;
     filterable?: boolean;
+    editable?: boolean;
+    /**
+     * Additional function to validate the cell value during edit
+     *
+     * @param value the current cell value
+     * @returns a promise that resolves to an error message string if validation fails, or undefined if validation succeeds
+     */
+    validateEdit?: (value: unknown) => Promise<string | undefined>;
     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>> = {
+type ExtractQueryParameters<TQueryDef extends QueryDefinition> = TQueryDef["__DefinitionMetadata"] extends QueryMetadata ? TQueryDef["__DefinitionMetadata"]["parameters"] : never;
+interface PropertyColumnLocator<Q extends ObjectOrInterfaceDefinition> {
     type: "property";
     id: PropertyKeys<Q>;
-} | {
+}
+interface FunctionColumnLocator<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>> {
+    /**
+     * This is equivalent to workshop's function-backed columns.
+     * The function needs to meet the specifications stated in https://www.palantir.com/docs/foundry/workshop/widgets-object-table/#function-backed-columns
+     */
     type: "function";
     id: keyof FunctionColumns;
-} | {
+    queryDefinition: FunctionColumns[keyof FunctionColumns];
+    /**
+     * The function will be called with the current object set to get the input parameters for the function query.
+     * @param objectSet - The current object set.
+     * @returns - The function's input parameters including the object set.
+     */
+    getFunctionParams: (objectSet: ObjectSet<Q>) => ExtractQueryParameters<FunctionColumns[keyof FunctionColumns]>;
+    /**
+     * Function to generate keys for looking up results in the FunctionsMap.
+     * @param object - The object instance
+     * @returns - The key to use for looking up this object's result in the FunctionsMap
+     */
+    getKey: (object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => string;
+    /**
+     * Function to extract the cell value from the raw cell data returned by the function.
+     * This is useful when functions return custom types with multiple properties.
+     * @param cellData - The raw data returned by the function for this object
+     * @returns - The value to display in the cell
+     */
+    getValue?: (cellData: unknown) => unknown;
+}
+interface RdpColumnLocator<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>> {
     type: "rdp";
     id: keyof RDPs;
     creator: DerivedProperty.Creator<Q, RDPs[keyof RDPs]>;
-};
+}
+interface CustomColumnLocator {
+    type: "custom";
+    id: string;
+}
+type ColumnDefinitionLocator<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>> = PropertyColumnLocator<Q> | FunctionColumnLocator<Q, RDPs, FunctionColumns> | RdpColumnLocator<Q, RDPs> | CustomColumnLocator;
 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 +661,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 +679,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 +735,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 +775,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.
      *
@@ -317,13 +798,19 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
      * If provided, the row selection is controlled.
      */
     selectedRows?: PrimaryKeyType<Q>[];
+    /**
+     * Indicates whether all rows are selected in controlled mode.
+     * When true, the table will show all rows as selected regardless of the selectedRows array.
+     */
+    isAllSelected?: boolean;
     /**
      * Called when the row selection changes.
      * Required when row selection is controlled.
      *
      * @param selectedRowIds The primary keys of currently selected rows
+     * @param isSelectAll Whether the change was triggered by a "select all" action. Defaults to false
      */
-    onRowSelection?: (selectedRowIds: PrimaryKeyType<Q>[]) => void;
+    onRowSelection?: (selectedRowIds: PrimaryKeyType<Q>[], isSelectAll?: boolean) => void;
     /**
      * If provided, will render this context menu when right clicking on a cell
      */
@@ -336,17 +823,64 @@ 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
- *
- * @example
- * ```tsx
- * <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, isAllSelected: isAllSelectedProp, 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;
+        isAsyncColumn?: boolean;
+        isVisible?: boolean;
+        editable?: boolean;
+        dataType?: string;
+        validateEdit?: (value: unknown) => Promise<string | undefined>;
+    }
+    interface TableMeta<TData extends RowData = unknown> {
+        onCellEdit?: (cellId: string, info: CellEditInfo<TData, unknown>) => void;
+        onCellValidationError?: (cellId: string, error: string) => void;
+        clearCellValidationError?: (cellId: string) => void;
+        cellEdits?: Record<string, CellEditInfo<TData, unknown>>;
+        isInEditMode?: boolean;
+        validationErrors?: Map<string, string>;
+    }
+}
 interface BaseTableProps<TData extends RowData> {
     table: Table<TData>;
     isLoading?: boolean;
@@ -356,7 +890,78 @@ 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 ColumnConfigDialog({ isOpen, onClose, columnOptions, currentVisibility, currentColumnOrder, onApply, isValidConfig, }: ColumnConfigDialogProps): React__default.ReactElement | null;
+
+/** The visual style of an annotation rendered on the PDF. */
+type AnnotationType = "highlight" | "underline" | "comment" | "pin";
+/** A single annotation positioned on a specific page of the PDF. */
+interface PdfAnnotation {
+    /** Unique identifier for this annotation */
+    id: string;
+    /** The type of annotation to render */
+    type: AnnotationType;
+    /** Page number (1-indexed) */
+    page: number;
+    /** Coordinates in PDF points (origin: bottom-left of page) */
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Optional label or tooltip text */
+    label?: string;
+    /** Optional color override (CSS color string) */
+    color?: string;
+}
+/** Props for the {@link PdfViewer} component. */
+interface PdfViewerProps {
+    /** PDF source — URL string or ArrayBuffer */
+    src: string | ArrayBuffer;
+    /** Annotations to overlay on the PDF, keyed by page number (1-indexed) */
+    annotations?: Record<number, PdfAnnotation[]>;
+    /**
+     * Callback fired when an annotation is clicked.
+     *
+     * @param annotation - The annotation that was clicked
+     * @returns void
+     */
+    onAnnotationClick?: (annotation: PdfAnnotation) => void;
+    /** Initial page number (1-indexed, default 1) */
+    initialPage?: number;
+    /** Initial zoom scale (default 1.0) */
+    initialScale?: number;
+    /** Whether the sidebar is initially open (default false) */
+    initialSidebarOpen?: boolean;
+    /** Additional CSS class name for the root element */
+    className?: string;
+}
+
+declare function BasePdfViewer({ src, annotations, onAnnotationClick, initialPage, initialScale, initialSidebarOpen, className, }: PdfViewerProps): React__default.ReactElement;
+
+interface PdfRendererProps extends Omit<PdfViewerProps, "src"> {
+    /** The Media object to fetch PDF contents from */
+    media: Media;
 }
-declare function BaseTable<TData extends RowData>({ table, isLoading, fetchNextPage, onRowClick, rowHeight, renderCellContextMenu, className, error, }: BaseTableProps<TData>): ReactElement;
+declare function PdfRenderer({ media, className, ...pdfViewerProps }: PdfRendererProps): React__default.ReactElement;
 
-export { BaseTable, type BaseTableProps, type ColumnDefinition, type ColumnDefinitionLocator, type FilterListItemProps, type FilterListProps, ObjectTable, type ObjectTableProps };
+export { type AnnotationType, BaseFilterList, type BaseFilterListProps, BasePdfViewer, BaseTable, type BaseTableProps, type CellEditInfo, ColumnConfigDialog, type ColumnConfigDialogProps, type ColumnConfigOptions, type ColumnDefinition, type ColumnDefinitionLocator, type CustomColumnLocator, type FilterComponentType, type FilterDefinitionUnion, FilterList, type FilterListItemProps, type FilterListProps, type FilterState, type FunctionColumnLocator, ObjectTable, type ObjectTableProps, type PdfAnnotation, PdfRenderer, type PdfRendererProps, type PdfViewerProps, type PropertyColumnLocator, type PropertyFilterDefinition, type RdpColumnLocator, type RenderFilterInput, deserializeFilterStates, serializeFilterStates };