@osdk/react-components 0.2.0-beta.9 → 0.2.1-main-20260407074313

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

@@ -1,7 +1,11 @@
-import { ObjectTypeDefinition, WhereClause, PropertyKeys, LinkNames, LinkedType, WirePropertyTypes, CompileTimeMetadata, ObjectSet, ObjectOrInterfaceDefinition, SimplePropertyDef, QueryDefinition, DerivedProperty, Osdk, PrimaryKeyType } from '@osdk/api';
 import * as React from 'react';
-import React__default, { ReactNode, ReactElement } from 'react';
+import React__default, { ReactNode, ReactElement, RefObject } from 'react';
+import { ObjectTypeDefinition, ObjectSet, WhereClause, PropertyKeys, LinkNames, LinkedType, WirePropertyTypes, CompileTimeMetadata, ObjectOrInterfaceDefinition, SimplePropertyDef, QueryDefinition, Osdk, DerivedProperty, PrimaryKeyType, Media, ActionDefinition, ActionMetadata, ActionParam, DataValueClientToWire, ActionEditResponse, ActionValidationResponse } from '@osdk/api';
+import { QueryParameterType } from '@osdk/client/unstable-do-not-use';
 import { RowData, Table, Cell, VisibilityState, ColumnOrderState } from '@tanstack/react-table';
+import { PDFDocumentProxy } from 'pdfjs-dist';
+import { PDFViewer, EventBus, PDFFindController } from 'pdfjs-dist/web/pdf_viewer.mjs';
+import { ActionValidationError } from '@osdk/client';
 
 /**
  * State for custom filter
@@ -14,6 +18,7 @@ interface CustomFilterState<T = Record<string, unknown>> extends BaseFilterState
  * Props passed to custom filter input renderer
  */
 interface CustomFilterInputRendererProps<Q extends ObjectTypeDefinition, State extends BaseFilterState> {
+    objectSet: ObjectSet<Q>;
     filterState: State;
     onFilterStateChanged: (newState: State) => void;
 }
@@ -186,11 +191,11 @@ type PropertyTypeFromKey<Q extends ObjectTypeDefinition, K extends PropertyKeys<
 /**
  * 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";
+type FilterComponentType = "LISTOGRAM" | "DATE_RANGE" | "NUMBER_RANGE" | "TEXT_TAGS" | "CONTAINS_TEXT" | "SINGLE_SELECT" | "MULTI_SELECT" | "SINGLE_DATE" | "MULTI_DATE" | "TIMELINE" | "TOGGLE";
 /**
  * Gets valid component types for a given property type
  */
-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;
+type ValidComponentsForPropertyType<P extends WirePropertyTypes> = P extends "boolean" ? "LISTOGRAM" | "SINGLE_SELECT" | "TOGGLE" : P extends "string" ? "LISTOGRAM" | "TEXT_TAGS" | "CONTAINS_TEXT" | "SINGLE_SELECT" | "MULTI_SELECT" : 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
  */
@@ -209,7 +214,6 @@ interface FilterStateByComponentType {
     SINGLE_DATE: SelectFilterState<Date>;
     MULTI_DATE: SelectFilterState<Date>;
     TIMELINE: TimelineFilterState;
-    CHECKBOX_LIST: SelectFilterState<string>;
     TOGGLE: ToggleFilterState;
 }
 /**
@@ -268,7 +272,7 @@ interface NumberRangeFilterState extends BaseFilterState {
 }
 /**
  * Consolidated state type for select-based filters.
- * Used by SINGLE_SELECT, MULTI_SELECT, SINGLE_DATE, MULTI_DATE, and CHECKBOX_LIST.
+ * Used by SINGLE_SELECT, MULTI_SELECT, SINGLE_DATE, and MULTI_DATE.
  */
 interface SelectFilterState<T = string | boolean | number | Date> extends BaseFilterState {
     type: "SELECT";
@@ -288,8 +292,8 @@ interface ToggleFilterState extends BaseFilterState {
  * 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.
+ * For example, boolean properties can only use LISTOGRAM or SINGLE_SELECT,
+ * while string properties can use LISTOGRAM, TEXT_TAGS, CONTAINS_TEXT, SINGLE_SELECT, or MULTI_SELECT.
  */
 interface PropertyFilterDefinition<Q extends ObjectTypeDefinition, K extends PropertyKeys<Q> = PropertyKeys<Q>, C extends ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>> = ValidComponentsForPropertyType<PropertyTypeFromKey<Q, K>>> {
     /**
@@ -318,6 +322,23 @@ interface PropertyFilterDefinition<Q extends ObjectTypeDefinition, K extends Pro
      * If provided, the filter is controlled.
      */
     filterState: FilterStateByComponentType[C];
+    /**
+     * Maps filter values to colors for visual differentiation.
+     * Used by 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";
+        /**
+         * Number of items shown before "View all" link appears
+         * @default 5
+         */
+        maxVisibleItems?: number;
+    };
     /**
      * Controls whether this filter is rendered.
      * When false, the filter is hidden but its state is preserved.
@@ -339,61 +360,39 @@ interface FilterListItemProps<Q extends ObjectTypeDefinition, K extends Property
     onFilterRemoved?: (key: PropertyKeys<Q>) => void;
 }
 
-/**
- * Visual data indicator configuration for filter items
- */
-type FilterDataIndicator = "histogram" | "count" | "none";
-/**
- * Category for organizing filters in the add filter menu
- */
-type FilterCategory = "ALL_PROPERTIES" | "SINGLE_PROPERTY" | "LINKED_OBJECT";
-/**
- * Template for a filter that can be added via the add filter menu
- */
-interface FilterTemplate {
-    /**
-     * Unique identifier for the template
-     */
-    id: string;
-    /**
-     * Display label for the filter
-     */
-    label: string;
-    /**
-     * Property key this filter applies to
-     */
-    key: string;
-    /**
-     * The type of filter component to use
-     */
-    filterComponent: FilterComponentType;
-    /**
-     * Icon to display next to the filter label.
-     * Can be a string (icon name) or a ReactNode for custom icons.
-     */
-    icon: string | ReactNode;
-    /**
-     * Type of data indicator to show (histogram, count, none)
-     */
-    dataIndicator?: FilterDataIndicator;
-    /**
-     * Whether to show a "Select All" option for checkbox lists
-     */
-    showSelectAll?: boolean;
-    /**
-     * Maximum number of visible items before scrolling
-     */
-    maxVisibleItems?: number;
-    /**
-     * Whether multiple instances of this filter can be added
-     */
-    allowMultiple: boolean;
-    /**
-     * Category for grouping in the add filter menu
-     */
-    category: FilterCategory;
+type RenderFilterInput<D> = (props: {
+    definition: D;
+    filterKey: string;
+    filterState: FilterState | undefined;
+    onFilterStateChanged: (state: FilterState) => void;
+    searchQuery?: string;
+    excludeRowOpen?: boolean;
+}) => 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?: React__default.ReactNode;
+    titleIcon?: React__default.ReactNode;
+    showResetButton?: boolean;
+    showActiveFilterCount?: boolean;
+    hasVisibilityChanges?: 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
  */
@@ -414,7 +413,7 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
     /**
      * Optional title to display in the filter list header
      */
-    title?: string;
+    title?: ReactNode;
     /**
      * Optional icon to display next to the title
      */
@@ -431,18 +430,11 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
     filterClause?: WhereClause<Q>;
     /**
      * Called when the filter clause changes.
-     * The filters are joined by the selected filterOperator.
      * Required in controlled mode.
      *
      * @param newClause The updated filter clause
      */
     onFilterClauseChanged?: (newClause: WhereClause<Q>) => void;
-    /**
-     * The logical operator to join multiple filters
-     *
-     * @default "and"
-     */
-    filterOperator?: "and" | "or";
     /**
      * Called when filter state changes
      *
@@ -451,47 +443,66 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
      */
     onFilterStateChanged?: (definition: FilterDefinitionUnion<Q>, newState: FilterState) => void;
     /**
-     * Called when a filter is added
-     * If provided, user will be allowed to add filters
+     * Controls how filter visibility (add/remove) is managed.
+     *
+     * - `"uncontrolled"` (default): FilterList manages visibility internally.
+     *   An "Add filter" popover is rendered for filters with `isVisible: false`,
+     *   and each visible filter shows a remove button.
+     * - `"controlled"`: The consumer manages which filters are visible via
+     *   `filterDefinitions`. Filters with `isVisible: false` are excluded from
+     *   the rendered list.
+     *
+     * @default "uncontrolled"
+     */
+    addFilterMode?: "controlled" | "uncontrolled";
+    /**
+     * 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<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<FilterDefinitionUnion<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.
      */
-    onFiltersReordered?: (newOrder: ReadonlyArray<FilterDefinitionUnion<Q>>) => void;
+    enableSorting?: boolean;
     /**
-     * Show reset filters button in header
+     * Whether the filter list panel is collapsed
      */
-    showResetButton?: boolean;
+    collapsed?: boolean;
     /**
-     * Called when reset button is clicked
+     * Called when the collapsed state changes
      */
-    onReset?: () => void;
+    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>;
     /**
-     * Available filter templates for the "Add filter" menu.
-     * When provided along with onFilterAdded, clicking the add button
-     * shows a popover with these templates organized by category.
+     * Show reset filters button in header
      */
-    filterTemplates?: FilterTemplate[];
+    showResetButton?: boolean;
     /**
-     * Called when a filter template is selected from the add filter menu.
-     * The consumer should create a new filter definition and add it to filterDefinitions.
+     * Called when reset button is clicked
      */
-    onFilterTemplateSelected?: (template: FilterTemplate) => void;
+    onReset?: () => void;
     /**
      * Show count of active filters in header
      */
@@ -502,11 +513,20 @@ interface FilterListProps<Q extends ObjectTypeDefinition> {
     className?: string;
     /**
      * Custom render function for the "Add filter" button.
-     * When not provided, a default button is shown if onFilterAdded is set.
+     *
+     * - In uncontrolled mode: customizes the trigger element for the built-in
+     *   add-filter popover. The popover behavior is handled automatically.
+     * - In controlled mode: replaces the entire add-filter button area.
+     *   The consumer is responsible for all add-filter behavior.
      */
     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;
@@ -516,9 +536,28 @@ interface CellIdentifier {
     rowId: string;
     columnId: string;
 }
-interface CellValueState<TData extends RowData = unknown> {
-    newValue: TData;
-    oldValue: TData;
+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 ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record<string, SimplePropertyDef> = Record<string, never>, FunctionColumns extends Record<string, QueryDefinition<{}>> = Record<string, never>> = {
@@ -538,6 +577,13 @@ type ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record
     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.
@@ -555,20 +601,49 @@ type ColumnDefinition<Q extends ObjectOrInterfaceDefinition, RDPs extends Record
      */
     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<Q extends QueryDefinition> = CompileTimeMetadata<Q>["parameters"] extends Record<string, never> ? undefined : QueryParameterType<CompileTimeMetadata<Q>["parameters"]>;
+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, RDPs>) => 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 or interface type of the object
@@ -629,6 +704,14 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
      * @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.
@@ -660,16 +743,18 @@ interface ObjectTableProps<Q extends ObjectOrInterfaceDefinition, RDPs extends R
     /**
      * Called after the value of a cell is edited and committed by the user.
      *
-     * @param cell The cell that was edited, identified by its row and column IDs
-     * @param state The new and old values of the cell
+     * @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?: (cell: CellIdentifier, state: CellValueState) => void;
+    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 a map of cellId (stringified CellIdentifier) to the new and old values of the cell
+     * @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: Record<string, CellValueState>) => Promise<void>;
+    onSubmitEdits?: (edits: CellEditInfo<Osdk.Instance<Q, "$allBaseProperties", PropertyKeys<Q>, RDPs>, unknown>[]) => Promise<boolean>;
     /**
      * Called when the column visibility or ordering changed.
      *
@@ -719,13 +804,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
      */
@@ -753,15 +844,7 @@ interface ObjectSetOptions<Q extends ObjectOrInterfaceDefinition> {
     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, objectSet, columnDefinitions, filter, objectSetOptions, orderBy, defaultOrderBy, onOrderByChanged, onColumnsPinnedChanged, onColumnResize, onRowSelection, renderCellContextMenu, selectionMode, selectedRows, onColumnVisibilityChanged, onCellValueChanged, onSubmitEdits, enableOrdering, enableColumnPinning, enableColumnResizing, enableColumnConfig, ...props }: ObjectTableProps<Q, RDPs, FunctionColumns>): React__default.ReactElement;
+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 {
     /**
@@ -789,20 +872,21 @@ interface HeaderMenuFeatureFlags {
 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, state: CellValueState) => void;
-        cellEdits?: Record<string, CellValueState>;
+        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 EditableConfig {
-    onSubmitEdits?: () => Promise<void>;
-    clearEdits?: () => void;
-    cellEdits?: Record<string, CellValueState>;
-}
 interface BaseTableProps<TData extends RowData> {
     table: Table<TData>;
     isLoading?: boolean;
@@ -813,7 +897,7 @@ interface BaseTableProps<TData extends RowData> {
     className?: string;
     error?: Error;
     headerMenuFeatureFlags?: HeaderMenuFeatureFlags;
-    editableConfig?: EditableConfig;
+    editableConfig?: EditableConfig<TData, unknown>;
 }
 declare function BaseTable<TData extends RowData>({ table, isLoading, fetchNextPage, onRowClick, rowHeight, renderCellContextMenu, className, error, headerMenuFeatureFlags, editableConfig, }: BaseTableProps<TData>): ReactElement;
 
@@ -833,4 +917,977 @@ interface ColumnConfigDialogProps {
 }
 declare function ColumnConfigDialog({ isOpen, onClose, columnOptions, currentVisibility, currentColumnOrder, onApply, isValidConfig, }: ColumnConfigDialogProps): React__default.ReactElement | null;
 
-export { BaseTable, type BaseTableProps, type CellIdentifier, type CellValueState, ColumnConfigDialog, type ColumnConfigDialogProps, type ColumnConfigOptions, type ColumnDefinition, type ColumnDefinitionLocator, type FilterComponentType, type FilterDefinitionUnion, type FilterListItemProps, type FilterListProps, type FilterState, ObjectTable, type ObjectTableProps, type PropertyFilterDefinition };
+/** Which sidebar panel to display when the sidebar is open. */
+type SidebarMode = "thumbnails" | "outline";
+/** A single item in the PDF document outline (table of contents). */
+interface OutlineItem {
+    title: string;
+    depth: number;
+    pageNumber: number;
+    bold: boolean;
+    italic: boolean;
+}
+/** The visual style of an annotation rendered on the PDF. */
+type AnnotationType = "highlight" | "underline" | "comment" | "pin" | "custom";
+/** A rectangle in PDF coordinate space (origin: bottom-left of page). */
+interface PdfRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Props passed to a custom annotation renderer. */
+interface PdfAnnotationRenderProps {
+    annotation: PdfAnnotation;
+    scale: number;
+    pageHeight: number;
+}
+/** Common fields shared by all annotation types. */
+interface PdfAnnotationBase {
+    /** Unique identifier for this annotation */
+    id: string;
+    /** Page number (1-indexed) */
+    page: number;
+    /** Coordinates in PDF points (origin: bottom-left of page) */
+    rect: PdfRect;
+    /** Additional rects for multi-line text highlights. When present, all rects are rendered. */
+    rects?: PdfRect[];
+    /** Optional label or tooltip text */
+    label?: string;
+    /** Optional color override (CSS color string) */
+    color?: string;
+}
+/** A built-in annotation type (highlight, underline, comment, pin). */
+interface PdfStandardAnnotation extends PdfAnnotationBase {
+    /** The type of annotation to render */
+    type: "highlight" | "underline" | "comment" | "pin";
+}
+/** A custom annotation with a user-provided renderer. */
+interface PdfCustomAnnotation extends PdfAnnotationBase {
+    /** Must be "custom" for custom-rendered annotations */
+    type: "custom";
+    /** Render function for the custom annotation content (required for custom type) */
+    render: (props: PdfAnnotationRenderProps) => React__default.ReactNode;
+}
+/** A single annotation positioned on a specific page of the PDF. */
+type PdfAnnotation = PdfStandardAnnotation | PdfCustomAnnotation;
+/** Result passed to the {@link PdfViewerProps.onDownload} callback. */
+type PdfDownloadResult = {
+    success: true;
+    filename: string;
+} | {
+    success: false;
+    error: Error;
+};
+/** Possible values for a PDF form field. */
+type PdfFormFieldValue = string | boolean | string[];
+/** Data emitted when the user creates a text highlight via the highlight editor. */
+interface PdfTextHighlightEvent {
+    /** Internal PDF.js editor ID. Use with `deleteHighlight` to programmatically remove. */
+    editorId: string;
+    /** Page number (1-indexed) */
+    page: number;
+    /** Bounding rects in PDF coordinate space (bottom-left origin) */
+    rects: PdfRect[];
+    /** The selected text content */
+    selectedText: string;
+    /** Highlight color as CSS color string */
+    color: string;
+}
+/** Imperative handle for programmatic control of a {@link PdfViewer} or {@link BasePdfViewer}. */
+interface PdfViewerHandle {
+    /** Scroll the viewer to the given page number (1-indexed). */
+    scrollToPage: (page: number) => void;
+    /** Programmatically delete a highlight by its `editorId` (from {@link PdfTextHighlightEvent}). */
+    deleteHighlight: (editorId: string) => void;
+}
+/**
+ * Options for {@link usePdfViewerInstance}.
+ * Equivalent to {@link PdfViewerProps} minus the `className` rendering concern.
+ */
+interface PdfViewerInstanceOptions {
+    /** PDF source — URL string or ArrayBuffer */
+    src: string | ArrayBuffer;
+    /** Annotations to overlay on the PDF */
+    annotations?: PdfAnnotation[];
+    /** Callback fired when an annotation is clicked */
+    onAnnotationClick?: (annotation: PdfAnnotation) => void;
+    /** Callback fired when a download completes or fails */
+    onDownload?: (result: PdfDownloadResult) => void;
+    /** Whether the highlight toggle button is shown in the toolbar */
+    highlightEnabled?: boolean;
+    /** Callback fired when the user creates a text highlight */
+    onTextHighlight?: (event: PdfTextHighlightEvent) => void;
+    /** Callback fired when the user deletes a highlight */
+    onHighlightDelete?: (event: PdfTextHighlightEvent) => void;
+    /** Initial form field values keyed by field name */
+    formData?: Record<string, PdfFormFieldValue>;
+    /** Callback fired when the user clicks the save button */
+    onFormSubmit?: (data: Record<string, PdfFormFieldValue>) => void;
+    /** Callback fired when any form field value changes */
+    onFormChange?: (fieldName: string, value: PdfFormFieldValue) => 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;
+    /** Whether the download button is shown in the toolbar */
+    enableDownload?: boolean;
+    /** Which sidebar panel to show: thumbnails or document outline */
+    sidebarMode?: SidebarMode;
+    /** Custom icon components for each outline depth level (0-indexed) */
+    outlineIcons?: Partial<Record<number, React__default.ComponentType>>;
+}
+/** Props for the {@link PdfViewer} component. */
+interface PdfViewerProps {
+    /** PDF source — URL string or ArrayBuffer */
+    src: string | ArrayBuffer;
+    /** Annotations to overlay on the PDF */
+    annotations?: PdfAnnotation[];
+    /**
+     * Callback fired when an annotation is clicked.
+     *
+     * @param annotation - The annotation that was clicked
+     * @returns void
+     */
+    onAnnotationClick?: (annotation: PdfAnnotation) => void;
+    /**
+     * Callback fired when a download completes or fails.
+     *
+     * @param result - The download result indicating success with the filename, or failure with an error
+     * @returns void
+     */
+    onDownload?: (result: PdfDownloadResult) => void;
+    /**
+     * Whether the highlight toggle button is shown in the toolbar.
+     * @default false
+     */
+    enableHighlight?: boolean;
+    /**
+     * Callback fired when the user creates a text highlight.
+     * Only fires when highlight mode is active.
+     *
+     * @param event - The highlight event with page, rects, text, and color
+     * @returns void
+     */
+    onTextHighlight?: (event: PdfTextHighlightEvent) => void;
+    /**
+     * Callback fired when the user deletes a highlight via the PDF.js editor UI.
+     *
+     * @param event - The highlight event that was deleted
+     * @returns void
+     */
+    onHighlightDelete?: (event: PdfTextHighlightEvent) => 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;
+    /**
+     * Whether the download button is shown in the toolbar.
+     * @default false
+     */
+    enableDownload?: boolean;
+    /**
+     * Which sidebar panel to show: thumbnails or document outline.
+     * @default "thumbnails"
+     */
+    sidebarMode?: SidebarMode;
+    /**
+     * Custom icon components for each outline depth level (0-indexed).
+     * Key 0 = top-level items, 1 = first nesting level, etc.
+     * If omitted, no icons are rendered.
+     */
+    outlineIcons?: Partial<Record<number, React__default.ComponentType>>;
+    /**
+     * Initial form field values keyed by field name. Applied when the document loads.
+     * Use this to pre-populate form fields when resuming a previously edited PDF.
+     */
+    formData?: Record<string, PdfFormFieldValue>;
+    /**
+     * Callback fired when the user clicks the save button in the toolbar.
+     * Receives all current form field values keyed by field name.
+     *
+     * @param data - All form field values keyed by field name
+     * @returns void
+     */
+    onFormSubmit?: (data: Record<string, PdfFormFieldValue>) => void;
+    /**
+     * Callback fired when any form field value changes.
+     *
+     * @param fieldName - The name of the field that changed
+     * @param value - The new value
+     * @returns void
+     */
+    onFormChange?: (fieldName: string, value: PdfFormFieldValue) => void;
+    /** Additional CSS class name for the root element */
+    className?: string;
+}
+
+declare const BasePdfViewer: React__default.ForwardRefExoticComponent<PdfViewerProps & React__default.RefAttributes<PdfViewerHandle>>;
+
+interface PdfViewerAnnotationLayerProps {
+    annotations: PdfAnnotation[];
+    pageHeight: number;
+    scale: number;
+    onAnnotationClick?: (annotation: PdfAnnotation) => void;
+}
+declare function PdfViewerAnnotationLayer({ annotations, pageHeight, scale, onAnnotationClick, }: PdfViewerAnnotationLayerProps): React__default.ReactElement;
+
+interface PdfViewerContentProps {
+    /** PDF source — URL string or ArrayBuffer */
+    src: string | ArrayBuffer;
+    /** Annotations to overlay on the PDF */
+    annotations?: PdfAnnotation[];
+    /** Callback fired when an annotation is clicked */
+    onAnnotationClick?: (annotation: PdfAnnotation) => void;
+    /** Initial page number (1-indexed, default 1) */
+    initialPage?: number;
+    /** Initial zoom scale (default 1.0) */
+    initialScale?: number;
+    /** Callback fired when the current page changes during scrolling */
+    onPageChange?: (page: number) => void;
+    /** Callback fired when the zoom scale changes */
+    onScaleChange?: (scale: number) => void;
+    /** Initial form field values keyed by field name. Applied when the document loads. */
+    formData?: Record<string, PdfFormFieldValue>;
+    /** Callback fired when any form field value changes. */
+    onFormChange?: (fieldName: string, value: PdfFormFieldValue) => void;
+    /** Additional CSS class name for the root element */
+    className?: string;
+}
+declare function PdfViewerContent({ src, annotations, onAnnotationClick, initialPage, initialScale, onPageChange: onPageChangeProp, onScaleChange: onScaleChangeProp, formData, onFormChange, className, }: PdfViewerContentProps): React__default.ReactElement;
+
+interface PdfViewerOutlineSidebarProps {
+    outlineItems: OutlineItem[];
+    currentPage: number;
+    onItemClick: (pageNumber: number) => void;
+    sidebarMode: SidebarMode;
+    onSidebarModeChange: (mode: SidebarMode) => void;
+    outlineIcons?: Partial<Record<number, React__default.ComponentType>>;
+}
+declare function PdfViewerOutlineSidebar({ outlineItems, currentPage, onItemClick, sidebarMode, onSidebarModeChange, outlineIcons, }: PdfViewerOutlineSidebarProps): React__default.ReactElement;
+
+interface PdfViewerSearchBarProps {
+    query: string;
+    totalMatches: number;
+    currentMatchIndex: number;
+    onQueryChange: (query: string) => void;
+    onNext: () => void;
+    onPrev: () => void;
+    onClose: () => void;
+}
+declare function PdfViewerSearchBar({ query, totalMatches, currentMatchIndex, onQueryChange, onNext, onPrev, onClose, }: PdfViewerSearchBarProps): React__default.ReactElement;
+
+interface PdfViewerSidebarProps {
+    document: PDFDocumentProxy;
+    numPages: number;
+    currentPage: number;
+    onPageClick: (page: number) => void;
+    sidebarMode: SidebarMode;
+    onSidebarModeChange: (mode: SidebarMode) => void;
+}
+declare function PdfViewerSidebar({ document, numPages, currentPage, onPageClick, sidebarMode, onSidebarModeChange, }: PdfViewerSidebarProps): React__default.ReactElement;
+
+interface PdfViewerToolbarProps {
+    currentPage: number;
+    numPages: number;
+    scale: number;
+    sidebarOpen: boolean;
+    onPageChange: (page: number) => void;
+    onScaleChange: (scale: number) => void;
+    onSearchOpen: () => void;
+    onSidebarToggle: () => void;
+    onDownload: () => void;
+    enableDownload: boolean;
+    onRotateLeft: () => void;
+    onRotateRight: () => void;
+    enableHighlight: boolean;
+    highlightModeActive: boolean;
+    onHighlightToggle: () => void;
+    enableFormSave?: boolean;
+    onFormSave?: () => void;
+}
+declare function PdfViewerToolbar({ currentPage, numPages, scale, sidebarOpen, onPageChange, onScaleChange, onSearchOpen, onSidebarToggle, onDownload, enableDownload, onRotateLeft, onRotateRight, enableHighlight, highlightModeActive, onHighlightToggle, enableFormSave, onFormSave, }: PdfViewerToolbarProps): React__default.ReactElement;
+
+interface AnnotationPortalTarget {
+    pageNumber: number;
+    container: HTMLDivElement;
+    pageHeight: number;
+    scale: number;
+}
+declare function usePdfAnnotationPortals(pdfViewerRef: RefObject<PDFViewer | null>, eventBusRef: RefObject<EventBus | null>, document: PDFDocumentProxy | undefined): AnnotationPortalTarget[];
+
+/**
+ * Groups a flat array of annotations by page number for efficient per-page lookup.
+ */
+declare function usePdfAnnotationsByPage(annotations: PdfAnnotation[]): Record<number, PdfAnnotation[]>;
+
+interface UsePdfDocumentResult {
+    document: PDFDocumentProxy | undefined;
+    numPages: number;
+    loading: boolean;
+    error: Error | undefined;
+}
+declare function usePdfDocument(src: string | ArrayBuffer): UsePdfDocumentResult;
+
+interface UsePdfFormFieldsOptions {
+    pdfViewerRef: RefObject<PDFViewer | null>;
+    eventBusRef: RefObject<EventBus | null>;
+    document: PDFDocumentProxy | undefined;
+    formData?: Record<string, PdfFormFieldValue>;
+    onFormSubmit?: (data: Record<string, PdfFormFieldValue>) => void;
+    onFormChange?: (fieldName: string, value: PdfFormFieldValue) => void;
+}
+interface UsePdfFormFieldsResult {
+    /** Whether the loaded PDF contains interactive form fields. */
+    hasFormFields: boolean;
+    /** Collect all current form field values and invoke onFormSubmit. */
+    submitFormData: () => void;
+}
+/**
+ * Hook that manages interactive PDF form fields.
+ * Builds a field metadata map, pre-populates initial values,
+ * listens for field changes, and collects values on submit.
+ */
+declare function usePdfFormFields({ pdfViewerRef, eventBusRef, document, formData, onFormSubmit, onFormChange, }: UsePdfFormFieldsOptions): UsePdfFormFieldsResult;
+
+interface UsePdfHighlightModeOptions {
+    pdfViewerRef: RefObject<PDFViewer | null>;
+    document: PDFDocumentProxy | undefined;
+    enabled: boolean;
+    onTextHighlight?: (event: PdfTextHighlightEvent) => void;
+    onHighlightDelete?: (event: PdfTextHighlightEvent) => void;
+}
+interface UsePdfHighlightModeResult {
+    highlightModeActive: boolean;
+    toggleHighlightMode: () => void;
+    deleteHighlight: (editorId: string) => void;
+}
+/**
+ * Hook that manages the PDF.js built-in highlight annotation editor mode.
+ * When active, users can select text to create highlights.
+ * A callback fires with the annotation details for persistence.
+ */
+declare function usePdfHighlightMode({ pdfViewerRef, document, enabled, onTextHighlight, onHighlightDelete, }: UsePdfHighlightModeOptions): UsePdfHighlightModeResult;
+
+declare function usePdfOutline(document: PDFDocumentProxy | undefined): OutlineItem[];
+
+interface UsePdfViewerResult {
+    pdfViewerRef: RefObject<PDFViewer | null>;
+    eventBusRef: RefObject<EventBus | null>;
+    findControllerRef: RefObject<PDFFindController | null>;
+}
+declare function usePdfViewer(containerRef: RefObject<HTMLDivElement | null>, viewerRef: RefObject<HTMLDivElement | null>, document: PDFDocumentProxy | undefined, initialScale?: number, initialPage?: number): UsePdfViewerResult;
+
+interface UsePdfViewerSearchResult {
+    query: string;
+    totalMatches: number;
+    currentMatchIndex: number;
+    isSearchOpen: boolean;
+    setQuery: (query: string) => void;
+    nextMatch: () => void;
+    prevMatch: () => void;
+    openSearch: () => void;
+    closeSearch: () => void;
+}
+declare function usePdfViewerSearch(eventBusRef: RefObject<EventBus | null>, findControllerRef: RefObject<PDFFindController | null>, document: PDFDocumentProxy | undefined): UsePdfViewerSearchResult;
+
+interface UsePdfViewerSyncOptions {
+    pdfViewerRef: RefObject<PDFViewer | null>;
+    eventBusRef: RefObject<EventBus | null>;
+    document: PDFDocumentProxy | undefined;
+    scale: number;
+    onScaleChange: (scale: number) => void;
+    onPageChange: (page: number) => void;
+}
+declare function usePdfViewerSync({ pdfViewerRef, eventBusRef, document, scale, onScaleChange, onPageChange, }: UsePdfViewerSyncOptions): {
+    scrollToPage: (page: number) => void;
+};
+
+/** The shape of the value provided by {@link PdfViewerProvider}. */
+interface PdfViewerContextValue {
+    document: PDFDocumentProxy | undefined;
+    numPages: number;
+    loading: boolean;
+    error: Error | undefined;
+    containerRef: RefObject<HTMLDivElement>;
+    viewerRef: RefObject<HTMLDivElement>;
+    currentPage: number;
+    scrollToPage: (page: number) => void;
+    scale: number;
+    setScale: (scale: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    rotation: number;
+    rotateLeft: () => void;
+    rotateRight: () => void;
+    sidebarOpen: boolean;
+    sidebarMode: SidebarMode;
+    setSidebarMode: (mode: SidebarMode) => void;
+    toggleSidebar: () => void;
+    search: UsePdfViewerSearchResult;
+    outlineItems: OutlineItem[];
+    download: (filename?: string) => void;
+    portalTargets: AnnotationPortalTarget[];
+    highlightEnabled: boolean;
+    highlightModeActive: boolean;
+    toggleHighlightMode: () => void;
+    hasFormFields: boolean;
+    submitFormData: () => void;
+    annotations: PdfAnnotation[];
+    annotationsByPage: Record<number, PdfAnnotation[]>;
+    onAnnotationClick: ((annotation: PdfAnnotation) => void) | undefined;
+    enableDownload: boolean;
+    enableFormSave: boolean;
+    outlineIcons: Partial<Record<number, React__default.ComponentType>> | undefined;
+    pdfViewerRef: RefObject<PDFViewer | null>;
+    eventBusRef: RefObject<EventBus | null>;
+    findControllerRef: RefObject<PDFFindController | null>;
+}
+interface PdfViewerProviderProps {
+    value: PdfViewerContextValue;
+    children: React__default.ReactNode;
+}
+/** Provides {@link PdfViewerContextValue} to descendant components. */
+declare function PdfViewerProvider({ value, children }: PdfViewerProviderProps): React__default.ReactElement;
+/**
+ * Returns the nearest {@link PdfViewerContextValue} from a {@link PdfViewerProvider}.
+ * Throws if called outside a provider.
+ */
+declare function usePdfViewerContext(): PdfViewerContextValue;
+/**
+ * Consumer-facing setup hook analogous to react-hook-form's `useForm()`.
+ * Accepts viewer options and returns a {@link PdfViewerContextValue} suitable
+ * for passing to {@link PdfViewerProvider}.
+ */
+declare function usePdfViewerInstance(options: PdfViewerInstanceOptions): PdfViewerContextValue;
+
+interface UsePdfViewerCoreOptions {
+    /** PDF source — URL string or ArrayBuffer */
+    src: string | ArrayBuffer;
+    /** Initial page number (1-indexed, default 1) */
+    initialPage?: number;
+    /** Initial zoom scale (default 1.0) */
+    initialScale?: number;
+}
+interface UsePdfViewerCoreResult {
+    /** The loaded PDF document, or undefined while loading */
+    document: PDFDocumentProxy | undefined;
+    /** Total number of pages in the document */
+    numPages: number;
+    /** Whether the document is currently loading */
+    loading: boolean;
+    /** Error encountered while loading the document */
+    error: Error | undefined;
+    /** Ref to attach to the scroll-container div */
+    containerRef: RefObject<HTMLDivElement>;
+    /** Ref to attach to the inner viewer div (className="pdfViewer") */
+    viewerRef: RefObject<HTMLDivElement>;
+    /** Current page number (1-indexed) */
+    currentPage: number;
+    /** Navigate to a specific page (updates state and scrolls the viewer) */
+    scrollToPage: (page: number) => void;
+    /** Current zoom scale */
+    scale: number;
+    /** Set the zoom scale directly */
+    setScale: (scale: number) => void;
+    /** Portal targets for rendering annotation overlays on each page */
+    portalTargets: AnnotationPortalTarget[];
+    /** Ref to the internal pdfjs PDFViewer instance */
+    pdfViewerRef: RefObject<PDFViewer | null>;
+    /** Ref to the internal pdfjs EventBus instance */
+    eventBusRef: RefObject<EventBus | null>;
+    /** Ref to the internal pdfjs PDFFindController instance */
+    findControllerRef: RefObject<PDFFindController | null>;
+}
+declare function usePdfViewerCore({ src, initialPage, initialScale, }: UsePdfViewerCoreOptions): UsePdfViewerCoreResult;
+
+interface UsePdfViewerStateOptions extends UsePdfViewerCoreOptions {
+    /** Whether the sidebar is initially open (default false) */
+    initialSidebarOpen?: boolean;
+    /** Which sidebar panel to show (default "thumbnails") */
+    sidebarMode?: SidebarMode;
+    /** Callback fired when a download completes or fails */
+    onDownload?: (result: PdfDownloadResult) => void;
+}
+interface UsePdfViewerStateResult extends UsePdfViewerCoreResult {
+    /** Zoom in by one step */
+    zoomIn: () => void;
+    /** Zoom out by one step */
+    zoomOut: () => void;
+    /** Current rotation in degrees (0, 90, 180, 270) */
+    rotation: number;
+    /** Rotate 90 degrees counter-clockwise */
+    rotateLeft: () => void;
+    /** Rotate 90 degrees clockwise */
+    rotateRight: () => void;
+    /** Whether the sidebar panel is open */
+    sidebarOpen: boolean;
+    /** Which sidebar panel is active */
+    sidebarMode: SidebarMode;
+    /** Change the active sidebar panel */
+    setSidebarMode: (mode: SidebarMode) => void;
+    /** Toggle sidebar open/closed */
+    toggleSidebar: () => void;
+    /** Search state and actions */
+    search: UsePdfViewerSearchResult;
+    /** Document outline items (from bookmarks or text extraction) */
+    outlineItems: ReturnType<typeof usePdfOutline>;
+    /** Download the PDF as a file */
+    download: (filename?: string) => void;
+}
+declare function usePdfViewerState({ src, initialPage, initialScale, initialSidebarOpen, sidebarMode: sidebarModeProp, onDownload, }: UsePdfViewerStateOptions): UsePdfViewerStateResult;
+
+interface PdfViewerMediaProps extends Omit<PdfViewerProps, "src"> {
+    /** The Media object to fetch PDF contents from */
+    media: Media;
+}
+declare function PdfViewer({ media, className, ...pdfViewerProps }: PdfViewerMediaProps): React__default.ReactElement;
+
+/**
+ * A form field definition specifies configuration for a single field
+ */
+interface FormFieldDefinition<Q extends ActionDefinition<unknown>, K extends FieldKey<Q> = FieldKey<Q>> {
+    /**
+     * The field's unique key
+     */
+    fieldKey: K;
+    /**
+     * Display label for the field
+     */
+    label: string;
+    /**
+     * Default value of the field
+     */
+    defaultValue?: FieldValueType<Q, K>;
+    /**
+     * The form field component type to render
+     */
+    fieldComponent: ValidFormFieldForPropertyType<FieldDescriptorType<Q, K>>;
+    /**
+     * Whether the field is required
+     */
+    isRequired?: boolean;
+    /**
+     * Placeholder text
+     */
+    placeholder?: string;
+    /**
+     * Additional information to display on this field
+     * The placement of helper text depends on the value of helperTextPlacement prop
+     */
+    helperText?: string;
+    /**
+     * The placement of the helper text either below the field or in a tooltip
+     *
+     * @default "tooltip"
+     */
+    helperTextPlacement?: "bottom" | "tooltip";
+    /**
+     * Whether the field is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * A callback to return a custom error message if validation failed
+     *
+     * @param validationRule the validation rule that failed with the error message
+     * @returns the error message to display
+     */
+    onValidationError?: (error: ValidationError) => string;
+    /**
+     * Additional function to validate the field
+     *
+     * @param value the current field value
+     * @returns a boolean promise indicating whether the value is valid
+     */
+    validate?: (value: FieldValueType<Q, K>) => Promise<boolean>;
+    /**
+     * The component props for the form field
+     * Excludes runtime props (value, onChange) which are managed by ActionForm
+     */
+    fieldComponentProps: Omit<FormFieldPropsByType[ValidFormFieldForPropertyType<FieldDescriptorType<Q, K>>], "value" | "onChange">;
+}
+type ValidationError = {
+    type: ValidationRule;
+    error: string;
+};
+type ValidationRule = "required" | "min" | "max" | "minLength" | "maxLength" | "pattern" | "validate";
+/**
+ * Maps field types to their corresponding props
+ */
+interface FormFieldPropsByType {
+    DATETIME_PICKER: DatetimePickerFieldProps;
+    DROPDOWN: DropdownFieldProps<unknown, boolean>;
+    FILE_PICKER: FilePickerProps;
+    NUMBER_INPUT: NumberInputFieldProps;
+    OBJECT_SET: ObjectSetFieldProps<ObjectTypeDefinition>;
+    RADIO_BUTTONS: RadioButtonsFieldProps<unknown>;
+    TEXT_AREA: TextAreaFieldProps;
+    TEXT_INPUT: TextInputFieldProps;
+    CUSTOM: CustomFieldProps<unknown>;
+}
+/**
+ * Datetime picker field props.
+ *
+ * When `formatDate` is omitted, ISO-like format is used (YYYY-MM-DD / YYYY-MM-DD HH:mm).
+ */
+interface DatetimePickerFieldProps extends BaseFormFieldProps<Date> {
+    /**
+     * The earliest date the user can select.
+     * If provided, this will be added to the field validation.
+     */
+    min?: Date;
+    /**
+     * The latest date the user can select.
+     * If provided, this will be added to the field validation.
+     */
+    max?: Date;
+    /**
+     * Whether to show time picker.
+     */
+    showTime?: boolean;
+    /**
+     * Whether to close the popover after selecting a date.
+     * @default true when `showTime` is false, false when `showTime` is true
+     */
+    closeOnSelection?: boolean;
+    /**
+     * Placeholder text shown when no value is selected.
+     */
+    placeholder?: string;
+    /** Formats a Date for display in the trigger button. */
+    formatDate?: (date: Date) => string;
+}
+/**
+ * Dropdown field props with selectable items
+ */
+interface DropdownFieldProps<V, Multiple extends boolean = false> extends BaseFormFieldProps<Multiple extends true ? V[] : V> {
+    /**
+     * Available items for the dropdown
+     */
+    items: V[];
+    /**
+     * Converts an item to a display string. Defaults to `String()`.
+     */
+    itemToStringLabel?: (item: V) => string;
+    /**
+     * Returns a unique string key for a list item. Used as the React `key`.
+     * Falls back to the item's index when not provided.
+     */
+    itemToKey?: (item: V) => string;
+    /**
+     * Custom equality check for item values. Defaults to `Object.is`.
+     * Required when items are objects to ensure correct selection matching.
+     */
+    isItemEqual?: (a: V, b: V) => boolean;
+    /**
+     * Whether the dropdown allows searching/filtering.
+     * When true, renders a Combobox with a search input.
+     * When false (default), renders a Select dropdown.
+     */
+    isSearchable?: boolean;
+    /**
+     * Placeholder text shown when no value is selected.
+     */
+    placeholder?: string;
+    /**
+     * Whether multiple values can be selected
+     */
+    isMultiple?: Multiple;
+}
+interface FilePickerProps extends BaseFormFieldProps<File | File[]> {
+    /**
+     * Whether multiple files can be selected
+     */
+    isMulti?: boolean;
+    /**
+     * Accepted file types (e.g., "image/*", ".pdf")
+     */
+    accept?: string | string[];
+    /**
+     * Maximum file size in bytes
+     */
+    maxSize?: number;
+    /**
+     * The text displayed when no file is selected.
+     *
+     * @default "No file chosen"
+     */
+    text?: string;
+    /**
+     * The text displayed on the browse button.
+     *
+     * @default "Browse"
+     */
+    buttonText?: string;
+}
+/**
+ * Text area field props
+ */
+interface TextAreaFieldProps extends BaseFormFieldProps<string>, Pick<React__default.TextareaHTMLAttributes<HTMLTextAreaElement>, "rows" | "wrap"
+/**
+ * If provided, this will be added to the field validation
+ */
+ | "minLength"
+/**
+ * If provided, this will be added to the field validation
+ */
+ | "maxLength"> {
+    placeholder?: string;
+}
+interface TextInputFieldProps extends BaseFormFieldProps<string>, Pick<React__default.InputHTMLAttributes<HTMLInputElement>, 
+/**
+ * If provided, this will be added to the field validation
+ */
+"minLength"
+/**
+ * If provided, this will be added to the field validation
+ */
+ | "maxLength"> {
+    placeholder?: string;
+}
+/**
+ * Number input field props
+ */
+interface NumberInputFieldProps extends BaseFormFieldProps<number> {
+    /**
+     * Minimum allowed value.
+     */
+    min?: number;
+    /**
+     * Maximum allowed value.
+     */
+    max?: number;
+    /**
+     * Step increment for the input. Used by the stepper buttons and ArrowUp/ArrowDown keyboard stepping.
+     *
+     * @default 1
+     */
+    step?: number;
+    /**
+     * Placeholder text shown when the input is empty.
+     */
+    placeholder?: string;
+}
+/**
+ * Radio buttons field props
+ */
+interface RadioButtonsFieldProps<V> extends BaseFormFieldProps<V> {
+    /**
+     * Available options for radio buttons.
+     *
+     * Values are compared by reference equality (`===`). When options contain
+     * non-primitive values, pass the same object references for `value` and
+     * the corresponding option entry.
+     */
+    options: Option<V>[];
+}
+/**
+ * Option interface for radio button options
+ */
+interface Option<V> {
+    label: string;
+    value: V;
+}
+/**
+ * Object set field displays the summary of the count of the given object set
+ */
+interface ObjectSetFieldProps<T extends ObjectTypeDefinition> extends BaseFormFieldProps<ObjectSet<T>> {
+}
+/**
+ * Custom field props for user-defined renderers
+ */
+interface CustomFieldProps<V> extends BaseFormFieldProps<V> {
+    /**
+     * Custom renderer function
+     */
+    customRenderer: (props: BaseFormFieldProps<V>) => React__default.ReactNode;
+}
+interface BaseFormFieldProps<V> {
+    /**
+     * The HTML `id` attribute for the field input element.
+     * Used for `<label htmlFor>` association.
+     */
+    id?: string;
+    /**
+     * The value of the form field
+     */
+    value: V | null;
+    /**
+     * Called when the field value changes.
+     *
+     * ActionForm internally wraps this to pass the key to `onFieldValueChange`:
+     * ```
+     * <DropdownField
+     *   {...fieldDef}
+     *   onChange={(value) => onFieldValueChange(fieldDef.key, value)}
+     * />
+     * ```
+     *
+     * @param value The new value of the form field
+     */
+    onChange?: (value: V | null) => void;
+}
+type FieldKey<Q extends ActionDefinition<unknown>> = keyof ActionParameters<Q>;
+/**
+ * Extracts parameters from an ActionDefinition
+ */
+type ActionParameters<Q extends ActionDefinition<unknown>> = CompileTimeMetadata<Q>["parameters"];
+/**
+ * Extracts the value type for a specific parameter
+ *
+ * TODO: Re-use `BaseType`
+ */
+type FieldValueType<Q extends ActionDefinition<unknown>, K extends keyof ActionParameters<Q> = keyof ActionParameters<Q>> = ActionParameters<Q>[K]["type"] extends ActionMetadata.DataType.Object<infer T> ? ActionParam.ObjectType<T> : ActionParameters<Q>[K]["type"] extends ActionMetadata.DataType.ObjectSet<infer T> ? ActionParam.ObjectSetType<T> : ActionParameters<Q>[K]["type"] extends ActionMetadata.DataType.Struct<infer T> ? ActionParam.StructType<T> : ActionParameters<Q>[K]["type"] extends keyof DataValueClientToWire ? DataValueClientToWire[ActionParameters<Q>[K]["type"]] : never;
+/**
+ * Extracts the parameter type descriptor for a specific action parameter.
+ */
+type FieldDescriptorType<Q extends ActionDefinition<unknown> = ActionDefinition<unknown>, K extends keyof ActionParameters<Q> = keyof ActionParameters<Q>> = ActionParameters<Q>[K]["type"];
+/**
+ * Available form field component types
+ */
+type FieldComponent = "DATETIME_PICKER" | "DROPDOWN" | "FILE_PICKER" | "NUMBER_INPUT" | "RADIO_BUTTONS" | "OBJECT_SET" | "TEXT_AREA" | "TEXT_INPUT" | "CUSTOM";
+/**
+ * Describes the data type of a form field, independent of OSDK.
+ * Mirrors ActionMetadata.DataType to keep the rendering layer OSDK-agnostic.
+ */
+type FieldType = "boolean" | "string" | "integer" | "long" | "double" | "datetime" | "timestamp" | "attachment" | "marking" | "mediaReference" | "objectType" | "geoshape" | "geohash" | {
+    type: "object";
+    object: string;
+} | {
+    type: "objectSet";
+    objectSet: string;
+} | {
+    type: "interface";
+    interface: string;
+} | {
+    type: "struct";
+    struct: Record<string, string>;
+};
+/**
+ * An OSDK-agnostic field definition used by BaseForm and FormFieldRenderer.
+ * Contains only the information needed to render a single field — no generics,
+ * no compile-time parameter constraints.
+ *
+ * Implemented as a distributed mapped type: switching on `fieldComponent`
+ * narrows `fieldComponentProps` to the correct props type automatically.
+ */
+type RendererFieldDefinition = {
+    [K in FieldComponent]: {
+        fieldKey: string;
+        fieldComponent: K;
+        fieldType?: FieldType;
+        label: string;
+        defaultValue?: unknown;
+        isRequired?: boolean;
+        placeholder?: string;
+        helperText?: string;
+        helperTextPlacement?: "bottom" | "tooltip";
+        fieldComponentProps: Omit<FormFieldPropsByType[K], "value" | "onChange">;
+    };
+}[FieldComponent];
+/**
+ * Gets valid form field types for a given property type
+ */
+type ValidFormFieldForPropertyType<P extends FieldDescriptorType> = P extends "objectSet" ? "OBJECT_SET" : P extends "object" ? "DROPDOWN" : P extends "mediaReference" | "attachment" ? "FILE_PICKER" : P extends "boolean" ? "RADIO_BUTTONS" | "DROPDOWN" : P extends "string" ? "TEXT_INPUT" | "TEXT_AREA" : P extends "datetime" | "timestamp" ? "DATETIME_PICKER" : P extends "double" | "integer" | "long" | "float" | "short" | "byte" | "decimal" ? "NUMBER_INPUT" : never;
+
+/**
+ * Props for the ActionForm component.
+ *
+ * A discriminated union ensures that controlled mode (formState provided)
+ * always requires onFormStateChange, and uncontrolled mode makes `onFormStateChange` optional
+ */
+type ActionFormProps<Q extends ActionDefinition<unknown>> = (ActionFormConfigProps<Q> & {
+    formState: FormState<Q>;
+    onFormStateChange: (updater: (prevState: FormState<Q>) => FormState<Q>) => void;
+}) | (ActionFormConfigProps<Q> & {
+    formState?: undefined;
+    onFormStateChange?: (updater: (prevState: FormState<Q>) => FormState<Q>) => void;
+});
+interface ActionFormConfigProps<Q extends ActionDefinition<unknown>> extends Pick<BaseFormProps, "formTitle" | "isSubmitDisabled"> {
+    actionDefinition: Q;
+    /**
+     * If not supplied, field definitions are constructed from `ActionParameters`.
+     */
+    formFieldDefinitions?: ReadonlyArray<FormFieldDefinition<Q>>;
+    /**
+     * If supplied, this will override the default submit action
+     * By default, the action's applyAction will be called
+     *
+     * @param formState all field values when onSubmit is called
+     * @param applyAction the function to execute the action
+     * @returns a promise of the submission response
+     */
+    onSubmit?: (formState: FormState<Q>, applyAction: (args: ActionParameters<Q>) => Promise<ActionEditResponse | undefined>) => Promise<unknown> | void;
+    /**
+     * Called when the validation response is returned from a validateOnly submission
+     *
+     * @param results the validation response
+     */
+    onValidationResponse?: (results: ActionValidationResponse) => void;
+    /**
+     * Called when the action is successfully executed from a non-validateOnly submission
+     *
+     * @param results the submission response
+     */
+    onSuccess?: (results: ActionEditResponse | undefined) => void;
+    /**
+     * Called when there is an error in form submission
+     *
+     * @param error the error that occurred
+     */
+    onError?: (error: FormError) => void;
+}
+/**
+ * Form values mapping parameter names to their values
+ */
+type FormState<Q extends ActionDefinition<unknown>> = {
+    [K in FieldKey<Q>]?: FieldValueType<Q, K>;
+};
+/**
+ * Form error discriminated union
+ */
+type FormError = {
+    type: "validation";
+    error: ActionValidationError;
+} | {
+    type: "submission";
+    error: unknown;
+} | {
+    type: "unknown";
+    error: unknown;
+};
+/**
+ * Props for the `BaseForm` component, which renders a form without
+ * OSDK data fetching.
+ *
+ * Uses a discriminated union so that controlled mode (`formState` provided)
+ * always requires `onFieldValueChange`, and uncontrolled mode omits both.
+ * `onSubmit` receives the current form state so callers can access values
+ * even in uncontrolled mode.
+ */
+type BaseFormProps = BaseFormCommonProps & ({
+    formState: Record<string, unknown>;
+    onFieldValueChange: (fieldKey: string, value: unknown) => void;
+} | {
+    formState?: undefined;
+    onFieldValueChange?: (fieldKey: string, value: unknown) => void;
+});
+interface BaseFormCommonProps {
+    formTitle?: string;
+    fieldDefinitions: ReadonlyArray<RendererFieldDefinition>;
+    onSubmit: (formState: Record<string, unknown>) => void;
+    isSubmitDisabled?: boolean;
+    isPending?: boolean;
+    isLoading?: boolean;
+    className?: string;
+}
+
+declare const ActionForm: <Q extends ActionDefinition<unknown>>(props: ActionFormProps<Q>) => React__default.ReactElement;
+
+declare const BaseForm: React__default.FC<BaseFormProps>;
+
+export { ActionForm, type ActionFormProps, type ActionParameters, type AnnotationPortalTarget, type AnnotationType, BaseFilterList, type BaseFilterListProps, BaseForm, type BaseFormFieldProps, type BaseFormProps, BasePdfViewer, BaseTable, type BaseTableProps, type CellEditInfo, ColumnConfigDialog, type ColumnConfigDialogProps, type ColumnConfigOptions, type ColumnDefinition, type ColumnDefinitionLocator, type CustomColumnLocator, type CustomFieldProps, type DatetimePickerFieldProps, type DropdownFieldProps, type FieldComponent, type FieldValueType, type FilePickerProps, type FilterComponentType, type FilterDefinitionUnion, FilterList, type FilterListItemProps, type FilterListProps, type FilterState, type FormError, type FormFieldDefinition, type FormFieldPropsByType, type FormState, type FunctionColumnLocator, type NumberInputFieldProps, type ObjectSetFieldProps, ObjectTable, type ObjectTableProps, type Option, type OutlineItem, type PdfAnnotation, type PdfAnnotationRenderProps, type PdfCustomAnnotation, type PdfDownloadResult, type PdfFormFieldValue, type PdfRect, type PdfTextHighlightEvent, PdfViewer, PdfViewerAnnotationLayer, type PdfViewerAnnotationLayerProps, PdfViewerContent, type PdfViewerContentProps, type PdfViewerContextValue, type PdfViewerHandle, type PdfViewerInstanceOptions, type PdfViewerMediaProps, PdfViewerOutlineSidebar, type PdfViewerOutlineSidebarProps, type PdfViewerProps, PdfViewerProvider, PdfViewerSearchBar, type PdfViewerSearchBarProps, PdfViewerSidebar, type PdfViewerSidebarProps, PdfViewerToolbar, type PdfViewerToolbarProps, type PropertyColumnLocator, type PropertyFilterDefinition, type RadioButtonsFieldProps, type RdpColumnLocator, type RenderFilterInput, type RendererFieldDefinition, type SidebarMode, type TextAreaFieldProps, type TextInputFieldProps, type UsePdfFormFieldsOptions, type UsePdfFormFieldsResult, type UsePdfHighlightModeOptions, type UsePdfHighlightModeResult, type UsePdfViewerCoreOptions, type UsePdfViewerCoreResult, type UsePdfViewerResult, type UsePdfViewerSearchResult, type UsePdfViewerStateOptions, type UsePdfViewerStateResult, deserializeFilterStates, serializeFilterStates, usePdfAnnotationPortals, usePdfAnnotationsByPage, usePdfDocument, usePdfFormFields, usePdfHighlightMode, usePdfOutline, usePdfViewer, usePdfViewerContext, usePdfViewerCore, usePdfViewerInstance, usePdfViewerSearch, usePdfViewerState, usePdfViewerSync };