@osdk/react-components 0.43.0 → 0.43.1-main-eab07502700f00fae33f4d3d60a4e457d68f5e69

package/build/types/object-table/ObjectTableApi.d.ts

@@ -207,6 +207,12 @@ export interface ObjectTableProps<
 	* Use objectType-based fetching if you need those.
 	*/
 	objectSet?: ObjectSet<Q>;
+	/**
+	* Ordered list of column definitions to show in the table
+	*
+	* If not provided, all of the properties of the object type will be shown in default order.
+	*/
+	columnDefinitions?: Array<ColumnDefinition<Q, RDPs, FunctionColumns>>;
 	objectSetOptions?: ObjectSetOptions<Q>;
 	/**
 	* Minimum time between fetch requests in milliseconds.
@@ -236,22 +242,16 @@ export interface ObjectTableProps<
 	*/
 	pageSize?: number;
 	/**
-	* Ordered list of column definitions to show in the table
-	*
-	* If not provided, all of the properties of the object type will be shown in default order.
-	*/
-	columnDefinitions?: Array<ColumnDefinition<Q, RDPs, FunctionColumns>>;
-	/**
 	* The current where clause to filter the objects in the table.
 	* If provided, the filter is controlled.
 	*/
 	filter?: WhereClause<Q, RDPs>;
 	/**
-	* Whether the table is sortable by the user.
+	* Whether the column configuration dialog for column visibility and ordering is available to the user.
 	*
 	* @default true
 	*/
-	enableOrdering?: boolean;
+	enableColumnConfig?: boolean;
 	/**
 	* Whether columns can be pinned by the user.
 	*
@@ -265,29 +265,50 @@ export interface ObjectTableProps<
 	*/
 	enableColumnResizing?: boolean;
 	/**
-	* Whether the column configuration dialog for column visibility and ordering is available to the user.
+	* Called when the column visibility or ordering changed.
 	*
-	* @default true
+	* If provided, the table will allow the user to show/hide columns.
+	*
+	* @param newStates The columns sorted in their display order in the table and their visibility state.
 	*/
-	enableColumnConfig?: boolean;
+	onColumnVisibilityChanged?: (newStates: Array<{
+		columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns
+		isVisible: boolean
+	}>) => void;
 	/**
-	* 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.
+	* Called when the pinned columns change.
 	*
-	* @default "manual"
+	* If provided, the table will allow the user to pin/unpin columns.
+	*
+	* @param newStates The new list of column pin states
 	*/
-	editMode?: "always" | "manual";
+	onColumnsPinnedChanged?: (newStates: Array<{
+		columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns
+		pinned: "left" | "right" | "none"
+	}>) => void;
 	/**
-	* Whether to render the bottom edit footer that hosts the
-	* "Edit Table" / "Cancel" / "Submit Edits" buttons and the edit-state
-	* indicators (modification count, validation errors).
+	* Called when a column is resized.
 	*
-	* @default true whenever the table has at least one column declared
-	* editable (i.e. any column with `editable: true` or `editable: (object) => boolean`).
-	* When `false`, the "Edit Table" and "Submit Edits" buttons will not be shown.
+	* @param columnId The ID of the resized column
+	* @param newWidth The new width of the column. When newWidth = null, the column size is reset.
 	*/
-	showEditFooter?: boolean;
+	onColumnResize?: (columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns, newWidth: number | null) => void;
+	/**
+	* Called when a column header is clicked.
+	*
+	* The columnId matches the `locator.id` configured on the column definition.
+	* The dropdown menu trigger is excluded — clicking the chevron opens the
+	* header menu instead of firing this callback.
+	*
+	* @param columnId The id of the clicked column
+	*/
+	onColumnHeaderClick?: (columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns) => void;
+	/**
+	* Whether the table is sortable by the user.
+	*
+	* @default true
+	*/
+	enableOrdering?: boolean;
 	/**
 	* The default order by clause to sort the objects in the table.
 	* If provided without orderBy prop, the sorting is uncontrolled.
@@ -317,55 +338,31 @@ export interface ObjectTableProps<
 		direction: "asc" | "desc"
 	}>) => void;
 	/**
-	* 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 "Submit Edits" button will be shown in the edit footer.
-	*
-	* @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.
+	* Selection mode for the table rows.
 	*
-	* If provided, the table will allow the user to show/hide columns.
+	* If multiple, a checkbox will be shown for each row to allow selecting multiple rows
+	* as well as a top-level checkbox in the header to select all rows.
 	*
-	* @param newStates The columns sorted in their display order in the table and their visibility state.
+	* @default "none"
 	*/
-	onColumnVisibilityChanged?: (newStates: Array<{
-		columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns
-		isVisible: boolean
-	}>) => void;
+	selectionMode?: "single" | "multiple" | "none";
 	/**
-	* Called when the pinned columns change.
-	*
-	* If provided, the table will allow the user to pin/unpin columns.
-	*
-	* @param newStates The new list of column pin states
+	* The currently selected rows in the table.
+	* If provided, the row selection is controlled.
 	*/
-	onColumnsPinnedChanged?: (newStates: Array<{
-		columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns
-		pinned: "left" | "right" | "none"
-	}>) => void;
+	selectedRows?: PrimaryKeyType<Q>[];
 	/**
-	* Called when a column is resized.
-	*
-	* @param columnId The ID of the resized column
-	* @param newWidth The new width of the column. When newWidth = null, the column size is reset.
+	* Indicates whether all rows are selected in controlled mode.
+	* When true, the table will show all rows as selected regardless of the selectedRows array.
 	*/
-	onColumnResize?: (columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns, newWidth: number | null) => void;
+	isAllSelected?: boolean;
 	/**
-	* Called when a row is clicked.
+	* Called when the row selection changes, with a {@link RowSelectionChange}
+	* payload describing the new state.
 	*
-	* @param object The object representing the clicked row
+	* @param change The new selection state. See {@link RowSelectionChange}.
 	*/
-	onRowClick?: (object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => void;
+	onRowSelectionChanged?: (change: RowSelectionChange<Q, RDPs>) => void;
 	/**
 	* The primary key of the row to render as visually focused (the
 	* "last interacted" row). When provided, focus state is controlled by
@@ -387,58 +384,61 @@ export interface ObjectTableProps<
 	*/
 	onFocusedRowChanged?: (row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs> | null) => void;
 	/**
-	* Called when a column header is clicked.
-	*
-	* The columnId matches the `locator.id` configured on the column definition.
-	* The dropdown menu trigger is excluded — clicking the chevron opens the
-	* header menu instead of firing this callback.
+	* 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.
 	*
-	* @param columnId The id of the clicked column
+	* @default "manual"
 	*/
-	onColumnHeaderClick?: (columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns) => void;
+	editMode?: "always" | "manual";
 	/**
-	* Selection mode for the table rows.
-	*
-	* If multiple, a checkbox will be shown for each row to allow selecting multiple rows
-	* as well as a top-level checkbox in the header to select all rows.
+	* Whether to render the bottom edit footer that hosts the
+	* "Edit Table" / "Cancel" / "Submit Edits" buttons and the edit-state
+	* indicators (modification count, validation errors).
 	*
-	* @default "none"
+	* @default true whenever the table has at least one column declared
+	* editable (i.e. any column with `editable: true` or `editable: (object) => boolean`).
+	* When `false`, the "Edit Table" and "Submit Edits" buttons will not be shown.
 	*/
-	selectionMode?: "single" | "multiple" | "none";
+	showEditFooter?: boolean;
 	/**
-	* The currently selected rows in the table.
-	* If provided, the row selection is controlled.
+	* 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
 	*/
-	selectedRows?: PrimaryKeyType<Q>[];
+	onCellValueChanged?: (info: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>) => void;
 	/**
-	* Indicates whether all rows are selected in controlled mode.
-	* When true, the table will show all rows as selected regardless of the selectedRows array.
+	* If provided, the "Submit Edits" button will be shown in the edit footer.
+	*
+	* @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
 	*/
-	isAllSelected?: boolean;
+	onSubmitEdits?: (edits: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>[]) => Promise<boolean>;
 	/**
-	* Called when the row selection changes, with a {@link RowSelectionChange}
-	* payload describing the new state.
+	* Called when a row is clicked.
 	*
-	* @param change The new selection state. See {@link RowSelectionChange}.
+	* @param object The object representing the clicked row
 	*/
-	onRowSelectionChanged?: (change: RowSelectionChange<Q, RDPs>) => void;
+	onRowClick?: (object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => void;
 	/**
 	* If provided, will render this context menu when right clicking on a cell
 	*/
 	renderCellContextMenu?: (row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, cellValue: unknown) => React.ReactNode;
 	/**
-	* Render override for the empty state. Called when the table has no
-	* rows and no error. When omitted, a default "No Data" indicator is
-	* rendered.
-	*/
-	renderEmptyState?: () => React.ReactNode;
-	/**
 	* The height of each row in pixels.
 	*
 	* @default 40
 	*/
 	rowHeight?: number;
 	/**
+	* Render override for the empty state. Called when the table has no
+	* rows and no error. When omitted, a default "No Data" indicator is
+	* rendered.
+	*/
+	renderEmptyState?: () => React.ReactNode;
+	/**
 	* Returns extra HTML attributes (typically `data-*`) to apply to each
 	* row element. Use this to drive conditional row styling
 	*/

package/build/types/object-table/ObjectTableApi.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAgBA,cACE,qBACA,iBACA,6BACA,WACA,MACA,gBACA,cACA,iBACA,mBACA,mBACK,WAAY;AACnB,cAAc,0BAA0B,yBAA0B;AAClE,iBAAiB,WAAW,OAAQ;AAEpC,cAAc,yBAAyB,wBAAyB;AAChE,cAAc,cAAc,uBAAuB,kBAAmB;AAEtE,cAAc,uBAAuB;AAErC,YAAY;CACV,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;IAK5D,yBAAyB,GAAG,MAAM,mBAClC,yBAAyB,GAAG,MAAM;UAE5B;CACR,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;EAI9D;;;;;;CAMA,SAAS,wBAAwB,GAAG,MAAM;;;;CAK1C;;;;CAKA,SAAS,SAAS,UAAU;CAC5B;CACA;CACA;CACA;CACA;;;;;;;;;;;;;;CAeA,cACEA,QAAQ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI,OAChEC,SAAS,wBAAwB,GAAG,MAAM,qBACvC,MAAM;;;;;;;;;;CAWX;;;;;CAMA,qBAAqB,MAAM;AAC5B;UAES;CACR,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;UAItD,uBAAuB,GAAG,MAAM,iBAAiB;;;;;CAKzD,UACI,SAEED,QAAQ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;;;;;;CActE,kBAAkB,gBAChB,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;CAS1D,gBAAgBE,mBAAmB;AACpC;;;;;UAMS;CACR,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;UAItD,uBAAuB,GAAG,MAAM,iBAAiB;CACzD,WAAW;AACZ;AAED,YAAY,uBAAuB,UAAU,mBAC3C,oBAAoB,GAAG,sBAAsB,oCAEzC,mBAAmB,oBAAoB,GAAG;AAEhD,iBAAiB,sBAAsB,UAAU,6BAA6B;CAC5E,MAAM;CACN,IAAI,aAAa;AAClB;;;;;UAMS;CACR,UAAU;CACV,aAAa,eAAe;CAC5B,wBAAwB,eAAe,gBAAgB,CAAE;CACzD,gBAAgB;EAChB;;;;;CAKA,MAAM;CACN,IAAI;CACJ,iBAAiB,gBAAgB;;;;;;CAOjC,oBACEC,WAAW,UAAU,GAAG,UACrB,uBAAuB,gBAAgB;;;;;;CAO5C,SACEH,QAAQ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;CASlE,YAAYI;;;;;;;;CASZ;;;;;;;CAQA;AACD;;;;;AAMD,YAAY;CACV,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;UAItD,8BAA8B,IACpC,gBAAgB,kBACd,4BAA4B,GAAG,MAAM,iBAAiB;AAI5D,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB;EACjD;CACA,MAAM;CACN,UAAU;CACV,SAAS,gBAAgB,QAAQ,GAAG,WAAW;AAChD;AAED,iBAAiB,oBAAoB;CACnC,MAAM;CACN;AACD;AAED,YAAY;CACV,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;IAK5D,sBAAsB,KACtB,sBAAsB,GAAG,MAAM,mBAC/B,iBAAiB,GAAG,QACpB;AAEJ,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB;CACjD,wBAAwB,eAAe,gBAAgB,CAAE,MAAK;EAI9D;;;;;CAKA,YAAY;;;;;;;;;;CAWZ,YAAY,UAAU;CAEtB,mBAAmB,iBAAiB;;;;;;;;CASpC;;;;;;;;;;;;;CAcA;;;;;;CAOA;;;;;;CAOA,oBAAoB,MAAM,iBAAiB,GAAG,MAAM;;;;;CAMpD,SAAS,YAAY,GAAG;;;;;;CAOxB;;;;;;CAOA;;;;;;CAOA;;;;;;CAOA;;;;;;;;CASA,WAAW,WAAW;;;;;;;;;;CAWtB;;;;;;CAOA,iBAAiB,MAAM;EACrB,UAAU,aAAa,WAAW;EAClC,WAAW,QAAQ;CACpB;;;;;;CAOD,UAAU,MAAM;EACd,UAAU,aAAa,WAAW;EAClC,WAAW,QAAQ;CACpB;;;;;;;CAQD,oBACEC,YAAY,MAAM;EAChB,UAAU,aAAa,WAAW;EAClC,WAAW,QAAQ;CACpB;;;;;;;CASH,sBACEC,MAAM,aACJ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;;CAY5D,iBACEC,OAAO,aACL,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI,sBAGvD;;;;;;;;CASL,6BACEC,WAAW,MAAM;EACf,UAAU,aAAa,WAAW,aAAa;EAC/C;CACD;;;;;;;;CAUH,0BACEC,WAAW,MAAM;EACf,UAAU,aAAa,WAAW,aAAa;EAC/C,QAAQ,SAAS,UAAU;CAC5B;;;;;;;CASH,kBACEC,UAAU,aAAa,WAAW,aAAa,iBAC/CC;;;;;;CAQF,cACEX,QAAQ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;;;;;CAalE,aAAa,eAAe;;;;;;;;;CAU5B,uBACEY,KAAK,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;;;;CAY/D,uBACEF,UAAU,aAAa,WAAW,aAAa;;;;;;;;;CAWjD,gBAAgB,WAAW,aAAa;;;;;CAMxC,eAAe,eAAe;;;;;CAM9B;;;;;;;CAQA,yBAAyBG,QAAQ,mBAAmB,GAAG;;;;CAIvD,yBACEC,KAAK,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI,OAC7DC,uBACG,MAAM;;;;;;CAOX,yBAAyB,MAAM;;;;;;CAO/B;;;;;CAMA,oBACEf,QAAQ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI,UAC7D;;;;;;;CAQL,WAAW,MAAM,IAAI,kBAAkB,GAAG;CAE1C;;;;;;;;CASA,SAAS,QAAQ;AAClB;;;;;AAMD,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB;EACjD;;;;;;;;;;;;;;;;;;;;;;;CAuBA,cACEgB,UAAU,+BACP,QAAQ,oBAAoB,GAAG;AACrC;;;;AAKD,iBAAiB,2BAA2B;;;;;;;;CAQ1C;AACD;;;;;AAMD,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB;EACjD;CACA,SAAS;CACT,MAAM,mBAAmB,GAAG;;;;;;CAM5B;AACD;;;;AAKD,iBAAiB,sBAAsB;;CAErC;;CAEA;AACD;;;;AAKD,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB;EACjD;;CAEA;;CAEA,QAAQ,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;CAMhE,WAAWC;AACZ;;;;;;AAOD,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB;EACjD;;;;;;;CAOA,cAAc,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;;;;;CAStE;;;;;;;;;;;;;;;;CAiBA,WAAW,UAAU,GAAG;AACzB;AAED,iBAAiB,iBAAiB,UAAU,6BAA6B;;;;CAIvE,QAAQ,UAAU;;;;CAKlB,YAAY,UAAU;;;;CAKtB,WAAW,UAAU;AACtB","names":["object: Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>","locator: ColumnDefinitionLocator<Q, RDPs, FunctionColumns>","value: unknown","objectSet: ObjectSet<Q, RDPs>","cellData?: unknown","newOrderBy: Array<{\n      property: PropertyKeys<Q> | keyof RDPs;\n      direction: \"asc\" | \"desc\";\n    }>","info: CellEditInfo<\n      Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>,\n      unknown\n    >","edits: CellEditInfo<\n      Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>,\n      unknown\n    >[]","newStates: Array<{\n      columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns;\n      isVisible: boolean;\n    }>","newStates: Array<{\n      columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns;\n      pinned: \"left\" | \"right\" | \"none\";\n    }>","columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns","newWidth: number | null","row: Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs> | null","change: RowSelectionChange<Q, RDPs>","row: Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>","cellValue: unknown","options?: ObjectTableSnapshotOptions","columnId: string"],"sources":["../../../src/object-table/ObjectTableApi.ts"],"version":3,"file":"ObjectTableApi.d.ts"}
+{"mappings":"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","names":["object: Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>","locator: ColumnDefinitionLocator<Q, RDPs, FunctionColumns>","value: unknown","objectSet: ObjectSet<Q, RDPs>","cellData?: unknown","newStates: Array<{\n      columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns;\n      isVisible: boolean;\n    }>","newStates: Array<{\n      columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns;\n      pinned: \"left\" | \"right\" | \"none\";\n    }>","columnId: PropertyKeys<Q> | keyof RDPs | keyof FunctionColumns","newWidth: number | null","newOrderBy: Array<{\n      property: PropertyKeys<Q> | keyof RDPs;\n      direction: \"asc\" | \"desc\";\n    }>","change: RowSelectionChange<Q, RDPs>","row: Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs> | null","info: CellEditInfo<\n      Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>,\n      unknown\n    >","edits: CellEditInfo<\n      Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>,\n      unknown\n    >[]","row: Osdk.Instance<Q, \"$allBaseProperties\", PropertyKeys<Q>, RDPs>","cellValue: unknown","options?: ObjectTableSnapshotOptions","columnId: string"],"sources":["../../../src/object-table/ObjectTableApi.ts"],"version":3,"file":"ObjectTableApi.d.ts"}

package/docs/ObjectTable.md

@@ -82,37 +82,37 @@ Type parameters: `Q extends ObjectOrInterfaceDefinition`, `RDPs extends Record<s
 | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `objectType`                | `Q`                                                                                                                                      | **Required.** The object or interface type of the object If objectSet is not provided, objects will be fetched based on this type.                                                                                                                                                                                                                                                                                                                                             |
 | `objectSet`                 | `ObjectSet<Q>`                                                                                                                           | The set of objects to show in the table. If provided, the table fetches through this object set instead of fetching based on objectType. Supported for both object and interface types.<br /><br />For an interface object set, rows expose the interface's declared properties; the underlying concrete object's non-interface properties are not loaded. Use objectType-based fetching if you need those.                                                                    |
+| `columnDefinitions`         | `Array<ColumnDefinition<Q, RDPs, FunctionColumns>>`                                                                                      | Ordered list of column definitions to show in the table<br /><br />If not provided, all of the properties of the object type will be shown in default order.                                                                                                                                                                                                                                                                                                                   |
 | `objectSetOptions`          | `ObjectSetOptions<Q>`                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `dedupeIntervalMs`          | `number`                                                                                                                                 | Minimum time between fetch requests in milliseconds. Increasing this value reduces redundant network calls when the same data is requested multiple times in quick succession. Defaults to `60_000 1 minute`.                                                                                                                                                                                                                                                                  |
 | `streamUpdates`             | `boolean`                                                                                                                                | Enable streaming updates via websocket subscription. When true, the table will automatically update when matching objects are added, updated, or removed in Foundry.<br /><br />Limitations: `streamUpdates` cannot be used together with `pivotTo` or `withProperties`. The server does not support websocket subscriptions for link-traversal or derived-property queries. Those queries still fetch data normally but won't receive real-time updates. Defaults to `false`. |
 | `pageSize`                  | `number`                                                                                                                                 | Number of objects to fetch per page. Defaults to `50`.                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `columnDefinitions`         | `Array<ColumnDefinition<Q, RDPs, FunctionColumns>>`                                                                                      | Ordered list of column definitions to show in the table<br /><br />If not provided, all of the properties of the object type will be shown in default order.                                                                                                                                                                                                                                                                                                                   |
 | `filter`                    | `WhereClause<Q, RDPs>`                                                                                                                   | The current where clause to filter the objects in the table. If provided, the filter is controlled.                                                                                                                                                                                                                                                                                                                                                                            |
-| `enableOrdering`            | `boolean`                                                                                                                                | Whether the table is sortable by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `enableColumnConfig`        | `boolean`                                                                                                                                | Whether the column configuration dialog for column visibility and ordering is available to the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                       |
 | `enableColumnPinning`       | `boolean`                                                                                                                                | Whether columns can be pinned by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `enableColumnResizing`      | `boolean`                                                                                                                                | Whether columns can be resized by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `enableColumnConfig`        | `boolean`                                                                                                                                | Whether the column configuration dialog for column visibility and ordering is available to the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                       |
-| `editMode`                  | `"always" \| "manual"`                                                                                                                   | 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. Defaults to `"manual"`.                                                                                                                                                                                                                                                          |
-| `showEditFooter`            | `boolean`                                                                                                                                | Whether to render the bottom edit footer that hosts the "Edit Table" / "Cancel" / "Submit Edits" buttons and the edit-state indicators (modification count, validation errors). Defaults to true whenever the table has at least one column declared editable (i.e. any column with `editable: true` or `editable: (object) => boolean`). When `false`, the "Edit Table" and "Submit Edits" buttons will not be shown.                                                         |
-| `defaultOrderBy`            | `Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>`                                                        | The default order by clause to sort the objects in the table. If provided without orderBy prop, the sorting is uncontrolled. If both orderBy and defaultOrderBy are provided, orderBy takes precedence.                                                                                                                                                                                                                                                                        |
-| `orderBy`                   | `Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>`                                                        | The current order by clause to sort the objects in the table. If provided, the sorting is controlled. If both orderBy and defaultOrderBy are provided, orderBy takes precedence.                                                                                                                                                                                                                                                                                               |
-| `onOrderByChanged`          | `(newOrderBy: Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>) => void`                                  | Called when the order by clause is changed. Required when sorting is controlled.                                                                                                                                                                                                                                                                                                                                                                                               |
-| `onCellValueChanged`        | `(info: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>) => void`                                   | Called after the value of a cell is edited and committed by the user.                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `onSubmitEdits`             | `(edits: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>[]) => Promise<boolean>`                    | If provided, the "Submit Edits" button will be shown in the edit footer.                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `onColumnVisibilityChanged` | `(newStates: Array<{ columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns; isVisible: boolean; }>) => void`                  | Called when the column visibility or ordering changed.<br /><br />If provided, the table will allow the user to show/hide columns.                                                                                                                                                                                                                                                                                                                                             |
 | `onColumnsPinnedChanged`    | `(newStates: Array<{ columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns; pinned: "left" \| "right" \| "none"; }>) => void` | Called when the pinned columns change.<br /><br />If provided, the table will allow the user to pin/unpin columns.                                                                                                                                                                                                                                                                                                                                                             |
 | `onColumnResize`            | `(columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns, newWidth: number \| null) => void`                                   | Called when a column is resized.                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `onRowClick`                | `(object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => void`                                                        | Called when a row is clicked.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `focusedRow`                | `PrimaryKeyType<Q> \| null`                                                                                                              | The primary key of the row to render as visually focused (the "last interacted" row). When provided, focus state is controlled by the caller.<br /><br />Stored as a primary key rather than a full object so the focus does not go stale when the underlying row data changes.<br /><br />Pass `null` to render no row as focused.                                                                                                                                            |
-| `onFocusedRowChanged`       | `(row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs> \| null) => void`                                                   | Called when the focused row changes — fires in both controlled and uncontrolled modes so callers can observe focus without taking it over.                                                                                                                                                                                                                                                                                                                                     |
 | `onColumnHeaderClick`       | `(columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns) => void`                                                             | Called when a column header is clicked.<br /><br />The columnId matches the `locator.id` configured on the column definition. The dropdown menu trigger is excluded — clicking the chevron opens the header menu instead of firing this callback.                                                                                                                                                                                                                              |
+| `enableOrdering`            | `boolean`                                                                                                                                | Whether the table is sortable by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `defaultOrderBy`            | `Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>`                                                        | The default order by clause to sort the objects in the table. If provided without orderBy prop, the sorting is uncontrolled. If both orderBy and defaultOrderBy are provided, orderBy takes precedence.                                                                                                                                                                                                                                                                        |
+| `orderBy`                   | `Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>`                                                        | The current order by clause to sort the objects in the table. If provided, the sorting is controlled. If both orderBy and defaultOrderBy are provided, orderBy takes precedence.                                                                                                                                                                                                                                                                                               |
+| `onOrderByChanged`          | `(newOrderBy: Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>) => void`                                  | Called when the order by clause is changed. Required when sorting is controlled.                                                                                                                                                                                                                                                                                                                                                                                               |
 | `selectionMode`             | `"single" \| "multiple" \| "none"`                                                                                                       | Selection mode for the table rows.<br /><br />If multiple, a checkbox will be shown for each row to allow selecting multiple rows as well as a top-level checkbox in the header to select all rows. Defaults to `"none"`.                                                                                                                                                                                                                                                      |
 | `selectedRows`              | `PrimaryKeyType<Q>[]`                                                                                                                    | The currently selected rows in the table. If provided, the row selection is controlled.                                                                                                                                                                                                                                                                                                                                                                                        |
 | `isAllSelected`             | `boolean`                                                                                                                                | Indicates whether all rows are selected in controlled mode. When true, the table will show all rows as selected regardless of the selectedRows array.                                                                                                                                                                                                                                                                                                                          |
 | `onRowSelectionChanged`     | `(change: RowSelectionChange<Q, RDPs>) => void`                                                                                          | Called when the row selection changes, with a `RowSelectionChange` payload describing the new state.                                                                                                                                                                                                                                                                                                                                                                           |
+| `focusedRow`                | `PrimaryKeyType<Q> \| null`                                                                                                              | The primary key of the row to render as visually focused (the "last interacted" row). When provided, focus state is controlled by the caller.<br /><br />Stored as a primary key rather than a full object so the focus does not go stale when the underlying row data changes.<br /><br />Pass `null` to render no row as focused.                                                                                                                                            |
+| `onFocusedRowChanged`       | `(row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs> \| null) => void`                                                   | Called when the focused row changes — fires in both controlled and uncontrolled modes so callers can observe focus without taking it over.                                                                                                                                                                                                                                                                                                                                     |
+| `editMode`                  | `"always" \| "manual"`                                                                                                                   | 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. Defaults to `"manual"`.                                                                                                                                                                                                                                                          |
+| `showEditFooter`            | `boolean`                                                                                                                                | Whether to render the bottom edit footer that hosts the "Edit Table" / "Cancel" / "Submit Edits" buttons and the edit-state indicators (modification count, validation errors). Defaults to true whenever the table has at least one column declared editable (i.e. any column with `editable: true` or `editable: (object) => boolean`). When `false`, the "Edit Table" and "Submit Edits" buttons will not be shown.                                                         |
+| `onCellValueChanged`        | `(info: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>) => void`                                   | Called after the value of a cell is edited and committed by the user.                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `onSubmitEdits`             | `(edits: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>[]) => Promise<boolean>`                    | If provided, the "Submit Edits" button will be shown in the edit footer.                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `onRowClick`                | `(object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => void`                                                        | Called when a row is clicked.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `renderCellContextMenu`     | `(row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, cellValue: unknown) => React.ReactNode`                            | If provided, will render this context menu when right clicking on a cell                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `renderEmptyState`          | `() => React.ReactNode`                                                                                                                  | Render override for the empty state. Called when the table has no rows and no error. When omitted, a default "No Data" indicator is rendered.                                                                                                                                                                                                                                                                                                                                  |
 | `rowHeight`                 | `number`                                                                                                                                 | The height of each row in pixels. Defaults to `40`.                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `renderEmptyState`          | `() => React.ReactNode`                                                                                                                  | Render override for the empty state. Called when the table has no rows and no error. When omitted, a default "No Data" indicator is rendered.                                                                                                                                                                                                                                                                                                                                  |
 | `getRowAttributes`          | `(object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => Record<string, string \| undefined>`                         | Returns extra HTML attributes (typically `data-*`) to apply to each row element. Use this to drive conditional row styling                                                                                                                                                                                                                                                                                                                                                     |
 | `tableRef`                  | `React.Ref<ObjectTableHandle<Q, RDPs>>`                                                                                                  | Imperative handle for programmatic table actions. Pass a ref (`useRef<ObjectTableHandle<Q, RDPs>>(null)`) to call `ObjectTableHandle` methods such as `ObjectTableHandle.getSnapshot`.                                                                                                                                                                                                                                                                                         |
 | `className`                 | `string`                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

package/docs/ObjectTableOverview.md

@@ -0,0 +1,131 @@
+---
+title: ObjectTable
+description: An OSDK-aware data table for ontology objects. Renders rows from an object type, ObjectSet, or interface, with built-in column configuration, selection, sorting, pinning, resizing, and inline editing.
+---
+
+> **Beta** — exported from `@osdk/react-components/experimental/object-table`.
+
+## Usage
+
+ObjectTable fetches its own data. Wrap your app in `OsdkProvider` and import the package styles once (see [Prerequisites](./Prerequisites.md) for the `@layer` order), then pass an object type — columns, sorting, filtering, and selection are wired up out of the box.
+
+> **Note** — `@my/osdk` is a placeholder for **your generated SDK package** (e.g. `@your-app/sdk`). Replace it with the actual package name in your project.
+
+```tsx
+import { Office } from "@my/osdk";
+import { ObjectTable } from "@osdk/react-components/experimental/object-table";
+
+function OfficesPage() {
+  return <ObjectTable objectType={Office} />;
+}
+```
+
+## Props
+
+This table is generated from the `ObjectTableProps` interface in [`ObjectTableApi.ts`](https://github.com/palantir/osdk-ts/blob/main/packages/react-components/src/object-table/ObjectTableApi.ts) — edit the JSDoc there, not this table. It lists the props declared directly on `ObjectTableProps`; for the nested `ColumnDefinition`, `ObjectSetOptions`, and editor-config shapes, see the [full ObjectTable reference](https://github.com/palantir/osdk-ts/blob/main/packages/react-components/docs/ObjectTable.md).
+
+<!-- AUTOGEN:props START src=src/object-table/ObjectTableApi.ts interface=ObjectTableProps — generated by scripts/gen-props.mjs; run `pnpm --filter @osdk/react-components gen-props` -->
+
+Type parameters: `Q extends ObjectOrInterfaceDefinition`, `RDPs extends Record<string, SimplePropertyDef> = Record<string, never>`, `FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>`
+
+| Name                        | Type                                                                                                                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `objectType`                | `Q`                                                                                                                                      | **Required.** The object or interface type of the object If objectSet is not provided, objects will be fetched based on this type.                                                                                                                                                                                                                                                                                                                                             |
+| `objectSet`                 | `ObjectSet<Q>`                                                                                                                           | The set of objects to show in the table. If provided, the table fetches through this object set instead of fetching based on objectType. Supported for both object and interface types.<br /><br />For an interface object set, rows expose the interface's declared properties; the underlying concrete object's non-interface properties are not loaded. Use objectType-based fetching if you need those.                                                                    |
+| `columnDefinitions`         | `Array<ColumnDefinition<Q, RDPs, FunctionColumns>>`                                                                                      | Ordered list of column definitions to show in the table<br /><br />If not provided, all of the properties of the object type will be shown in default order.                                                                                                                                                                                                                                                                                                                   |
+| `objectSetOptions`          | `ObjectSetOptions<Q>`                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `dedupeIntervalMs`          | `number`                                                                                                                                 | Minimum time between fetch requests in milliseconds. Increasing this value reduces redundant network calls when the same data is requested multiple times in quick succession. Defaults to `60_000 1 minute`.                                                                                                                                                                                                                                                                  |
+| `streamUpdates`             | `boolean`                                                                                                                                | Enable streaming updates via websocket subscription. When true, the table will automatically update when matching objects are added, updated, or removed in Foundry.<br /><br />Limitations: `streamUpdates` cannot be used together with `pivotTo` or `withProperties`. The server does not support websocket subscriptions for link-traversal or derived-property queries. Those queries still fetch data normally but won't receive real-time updates. Defaults to `false`. |
+| `pageSize`                  | `number`                                                                                                                                 | Number of objects to fetch per page. Defaults to `50`.                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `filter`                    | `WhereClause<Q, RDPs>`                                                                                                                   | The current where clause to filter the objects in the table. If provided, the filter is controlled.                                                                                                                                                                                                                                                                                                                                                                            |
+| `enableColumnConfig`        | `boolean`                                                                                                                                | Whether the column configuration dialog for column visibility and ordering is available to the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                       |
+| `enableColumnPinning`       | `boolean`                                                                                                                                | Whether columns can be pinned by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `enableColumnResizing`      | `boolean`                                                                                                                                | Whether columns can be resized by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `onColumnVisibilityChanged` | `(newStates: Array<{ columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns; isVisible: boolean; }>) => void`                  | Called when the column visibility or ordering changed.<br /><br />If provided, the table will allow the user to show/hide columns.                                                                                                                                                                                                                                                                                                                                             |
+| `onColumnsPinnedChanged`    | `(newStates: Array<{ columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns; pinned: "left" \| "right" \| "none"; }>) => void` | Called when the pinned columns change.<br /><br />If provided, the table will allow the user to pin/unpin columns.                                                                                                                                                                                                                                                                                                                                                             |
+| `onColumnResize`            | `(columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns, newWidth: number \| null) => void`                                   | Called when a column is resized.                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `onColumnHeaderClick`       | `(columnId: PropertyKeys<Q> \| keyof RDPs \| keyof FunctionColumns) => void`                                                             | Called when a column header is clicked.<br /><br />The columnId matches the `locator.id` configured on the column definition. The dropdown menu trigger is excluded — clicking the chevron opens the header menu instead of firing this callback.                                                                                                                                                                                                                              |
+| `enableOrdering`            | `boolean`                                                                                                                                | Whether the table is sortable by the user. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `defaultOrderBy`            | `Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>`                                                        | The default order by clause to sort the objects in the table. If provided without orderBy prop, the sorting is uncontrolled. If both orderBy and defaultOrderBy are provided, orderBy takes precedence.                                                                                                                                                                                                                                                                        |
+| `orderBy`                   | `Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>`                                                        | The current order by clause to sort the objects in the table. If provided, the sorting is controlled. If both orderBy and defaultOrderBy are provided, orderBy takes precedence.                                                                                                                                                                                                                                                                                               |
+| `onOrderByChanged`          | `(newOrderBy: Array<{ property: PropertyKeys<Q> \| keyof RDPs; direction: "asc" \| "desc"; }>) => void`                                  | Called when the order by clause is changed. Required when sorting is controlled.                                                                                                                                                                                                                                                                                                                                                                                               |
+| `selectionMode`             | `"single" \| "multiple" \| "none"`                                                                                                       | Selection mode for the table rows.<br /><br />If multiple, a checkbox will be shown for each row to allow selecting multiple rows as well as a top-level checkbox in the header to select all rows. Defaults to `"none"`.                                                                                                                                                                                                                                                      |
+| `selectedRows`              | `PrimaryKeyType<Q>[]`                                                                                                                    | The currently selected rows in the table. If provided, the row selection is controlled.                                                                                                                                                                                                                                                                                                                                                                                        |
+| `isAllSelected`             | `boolean`                                                                                                                                | Indicates whether all rows are selected in controlled mode. When true, the table will show all rows as selected regardless of the selectedRows array.                                                                                                                                                                                                                                                                                                                          |
+| `onRowSelectionChanged`     | `(change: RowSelectionChange<Q, RDPs>) => void`                                                                                          | Called when the row selection changes, with a `RowSelectionChange` payload describing the new state.                                                                                                                                                                                                                                                                                                                                                                           |
+| `focusedRow`                | `PrimaryKeyType<Q> \| null`                                                                                                              | The primary key of the row to render as visually focused (the "last interacted" row). When provided, focus state is controlled by the caller.<br /><br />Stored as a primary key rather than a full object so the focus does not go stale when the underlying row data changes.<br /><br />Pass `null` to render no row as focused.                                                                                                                                            |
+| `onFocusedRowChanged`       | `(row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs> \| null) => void`                                                   | Called when the focused row changes — fires in both controlled and uncontrolled modes so callers can observe focus without taking it over.                                                                                                                                                                                                                                                                                                                                     |
+| `editMode`                  | `"always" \| "manual"`                                                                                                                   | 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. Defaults to `"manual"`.                                                                                                                                                                                                                                                          |
+| `showEditFooter`            | `boolean`                                                                                                                                | Whether to render the bottom edit footer that hosts the "Edit Table" / "Cancel" / "Submit Edits" buttons and the edit-state indicators (modification count, validation errors). Defaults to true whenever the table has at least one column declared editable (i.e. any column with `editable: true` or `editable: (object) => boolean`). When `false`, the "Edit Table" and "Submit Edits" buttons will not be shown.                                                         |
+| `onCellValueChanged`        | `(info: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>) => void`                                   | Called after the value of a cell is edited and committed by the user.                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `onSubmitEdits`             | `(edits: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>[]) => Promise<boolean>`                    | If provided, the "Submit Edits" button will be shown in the edit footer.                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `onRowClick`                | `(object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => void`                                                        | Called when a row is clicked.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `renderCellContextMenu`     | `(row: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, cellValue: unknown) => React.ReactNode`                            | If provided, will render this context menu when right clicking on a cell                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `rowHeight`                 | `number`                                                                                                                                 | The height of each row in pixels. Defaults to `40`.                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `renderEmptyState`          | `() => React.ReactNode`                                                                                                                  | Render override for the empty state. Called when the table has no rows and no error. When omitted, a default "No Data" indicator is rendered.                                                                                                                                                                                                                                                                                                                                  |
+| `getRowAttributes`          | `(object: Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>) => Record<string, string \| undefined>`                         | Returns extra HTML attributes (typically `data-*`) to apply to each row element. Use this to drive conditional row styling                                                                                                                                                                                                                                                                                                                                                     |
+| `tableRef`                  | `React.Ref<ObjectTableHandle<Q, RDPs>>`                                                                                                  | Imperative handle for programmatic table actions. Pass a ref (`useRef<ObjectTableHandle<Q, RDPs>>(null)`) to call `ObjectTableHandle` methods such as `ObjectTableHandle.getSnapshot`.                                                                                                                                                                                                                                                                                         |
+| `className`                 | `string`                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `labels`                    | `Partial<ObjectTableLabels>`                                                                                                             | Overrides for the table's user-facing strings. Provide any subset; unset keys fall back to the built-in English defaults. Use this to localize the table or adjust wording. See `ObjectTableLabels`. Defaults to `undefined (built-in English strings)`.                                                                                                                                                                                                                       |
+
+<!-- AUTOGEN:props END -->
+
+## Style API
+
+The ObjectTable emits a stable set of `data-*` attributes on its rendered DOM and exposes every visual property through `--osdk-table-*` CSS variables. Together they let you override appearance via the table's `className` (or any ancestor) without forking the component.
+
+> **Class names are internal.** ObjectTable uses CSS Modules, so its class names are hashed at build time and are **not** part of the public API. Style states and elements by targeting the documented `data-*` attributes and CSS variables below — the only consumer-facing class name is the one you pass via the `className` prop. Token defaults live in `src/tokens/component-tokens/table.css`; the `--osdk-*` values they reference are defined in `src/tokens/base-tokens/base.css`.
+
+| Element                | Data attributes                                                                                                                                                            | CSS variables                                                                                                                                                                                                                                                                                                                                                                  |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `<thead>` (header row) | `data-resizing` — `true` \| `false`; set while a column is being resized.                                                                                                  | `--osdk-table-header-height`<br /> `--osdk-table-header-bg`<br /> `--osdk-table-header-fontWeight`<br /> `--osdk-table-header-fontSize`<br /> `--osdk-table-header-color`<br /> `--osdk-table-header-divider`<br /> `--osdk-table-resizer-color-hover`<br /> `--osdk-table-resizer-color-active`                                                                               |
+| `<th>` (header cell)   | `data-pinned` — `left` \| `right` \| `false`.                                                                                                                              | `--osdk-table-pinned-column-border`<br /> `--osdk-table-header-menu-padding`<br /> `--osdk-table-header-menu-bg`<br /> `--osdk-table-header-menu-bg-hover`<br /> `--osdk-table-header-menu-bg-active`<br /> `--osdk-table-header-menu-border`<br /> `--osdk-table-header-menu-color`<br /> `--osdk-table-header-menu-color-active`<br /> `--osdk-table-header-menu-icon-color` |
+| `<tr>` (body row)      | `data-selected` — `true` \| `false`<br /> `data-focused` — `true` \| `false`<br /> `data-row-parity` — `even` \| `odd`<br />plus any custom attrs from `getRowAttributes`. | `--osdk-table-row-bg-default`<br /> `--osdk-table-row-bg-alternate`<br /> `--osdk-table-row-bg-hover`<br /> `--osdk-table-row-bg-active`<br /> `--osdk-table-row-border-color-hover`<br /> `--osdk-table-row-border-color-active`<br /> `--osdk-table-row-divider`                                                                                                             |
+| `<td>` (body cell)     | `data-pinned` — `left` \| `right` \| `false`<br /> `data-editable` — `true` \| (absent).                                                                                   | `--osdk-table-cell-padding`<br /> `--osdk-table-cell-fontSize`<br /> `--osdk-table-cell-color`<br /> `--osdk-table-cell-divider`<br /> `--osdk-table-cell-editable-border`<br /> `--osdk-table-cell-edited-border`<br /> `--osdk-table-cell-edited-border-error`<br /> `--osdk-table-cell-input-bg`                                                                            |
+| Edit footer container  | —                                                                                                                                                                          | `--osdk-table-edit-container-padding`<br /> `--osdk-table-edit-container-min-height`                                                                                                                                                                                                                                                                                           |
+| Column config dialog   | —                                                                                                                                                                          | `--osdk-table-column-config-dialog-min-width`<br /> `--osdk-table-column-config-dialog-min-height`<br /> `--osdk-table-column-config-visible-columns-bg`                                                                                                                                                                                                                       |
+| Skeleton loading rows  | —                                                                                                                                                                          | `--osdk-table-skeleton-color-from`<br /> `--osdk-table-skeleton-color-to`                                                                                                                                                                                                                                                                                                      |
+| Shared border tokens   | —                                                                                                                                                                          | `--osdk-table-border`<br /> `--osdk-table-border-color`<br /> `--osdk-table-border-width`                                                                                                                                                                                                                                                                                      |
+
+## Advanced
+
+`ObjectTable` is the OSDK-aware component most consumers should use. For cases where you need to bring your own data fetching or assemble the table from smaller pieces, the package also exports the OSDK-agnostic base component, the individual building blocks, and the headless hooks that back them. All are available from `@osdk/react-components/experimental/object-table`.
+
+### Base component
+
+The base component contains all interactions and styling but does no data fetching — feed it primitive props from your own data source.
+
+| Export      | Description                                                                                                                                                                                                   |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `BaseTable` | OSDK-agnostic table that renders rows, columns, selection, sorting, pinning, resizing, and inline editing from primitive props. Does no fetching — wire it up with your own data source (or the hooks below). |
+
+### Building blocks
+
+Standalone sub-components used internally by `ObjectTable`, exported so you can compose them into a custom table.
+
+| Export                  | Description                                                                              |
+| ----------------------- | ---------------------------------------------------------------------------------------- |
+| `ColumnConfigDialog`    | Dialog for toggling column visibility and reordering columns.                            |
+| `MultiColumnSortDialog` | Dialog for building a multi-column sort order.                                           |
+| `LoadingCell`           | Skeleton loading cell that renders a full `<td>` element — use in a custom row renderer. |
+| `LoadingCellContent`    | Skeleton loading content only (no `<td>` wrapper) — use inside an existing cell.         |
+
+### Hooks
+
+Headless hooks holding the table's data and interaction logic. Reach for them when you're building your own TanStack React Table instance and custom table components and want to reuse ObjectTable's data fetching and state logic.
+
+| Export                   | Description                                                                                                                                                                               |
+| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `useObjectTableData`     | Fetches table rows (OSDK-aware). Wraps `useObjectSet`/`useOsdkObjects` depending on whether an `objectSet` is provided, and applies derived-property (RDP) locators via `withProperties`. |
+| `useFunctionColumnsData` | Resolves values for function-backed (query) columns for the loaded rows (OSDK-aware).                                                                                                     |
+| `useColumnDefs`          | Builds the tanstack-table column definitions from the object/interface type and column definitions.                                                                                       |
+| `useSelectionColumn`     | Builds the leading selection (checkbox) column for multi-select tables.                                                                                                                   |
+| `useColumnPinning`       | Manages pinned (left/right) column state, controlled or uncontrolled.                                                                                                                     |
+| `useColumnResize`        | Manages per-column widths and resize interactions.                                                                                                                                        |
+| `useColumnVisibility`    | Manages column visibility and ordering state.                                                                                                                                             |
+| `useFocusedRow`          | Manages the "last interacted" focused row, controlled or uncontrolled.                                                                                                                    |
+| `useRowSelection`        | Manages row selection state (single/multiple), controlled or uncontrolled.                                                                                                                |
+| `useTableSorting`        | Manages sort (`orderBy`) state, controlled or uncontrolled.                                                                                                                               |
+| `useEditableTable`       | Manages inline edit state: tracked edits, validation, and the submit lifecycle.                                                                                                           |
+| `useObjectTableSnapshot` | Builds the `ObjectTableHandle` exposed via `tableRef`, whose `getSnapshot` paginates the object set and resolves column values for export.                                                |
+| `useCellContextMenu`     | Manages the right-click cell context-menu open state and position.                                                                                                                        |