@servantcdh/ez-planet-labeling 0.1.1 → 0.3.1

package/dist/index.d.ts

@@ -64,6 +64,11 @@ export declare interface BrushGeometry {
     path: string;
 }
 
+declare interface BrushOptions {
+    lineCap: string;
+    lineWidth: number;
+}
+
 declare interface BrushState {
     brush: {
         id: number;
@@ -139,6 +144,18 @@ export { CanvasState_2 as CanvasState }
  */
 export declare const canvasToAnnotations: (objects: LabeledFabricObject[], imageWidth: number, imageHeight: number) => Promise<Annotation[]>;
 
+declare interface ClassificationLabelEntry {
+    tempId: string;
+    labelId: string | null;
+    policyId: string;
+    classIndex: number;
+    className: string;
+    labelValue: unknown;
+    attributeValues?: Record<string, unknown>;
+    color?: string;
+    opacity?: number;
+}
+
 /**
  * Create an HTMLImageElement from a URL.
  */
@@ -198,18 +215,98 @@ declare type FabricCanvas = Canvas & {
  */
 export declare const fabricObjectToAnnotation: (object: LabeledFabricObject, imageWidth: number, imageHeight: number) => Promise<Annotation | null>;
 
+export declare interface FileContent {
+    endpointUrl?: string;
+    fileName?: string;
+    fileType?: string;
+}
+
+export declare interface FileUploadPayload {
+    file: File;
+    policyId: string;
+    contentSetId: string;
+    elementId?: string;
+}
+
 export declare const filledRectTool: () => LabelingTool;
 
+/**
+ * Format a tool name with its shortcut key for display.
+ * e.g. formatShortcutTitle("Selection", "v") → "Selection (V)"
+ */
+export declare function formatShortcutTitle(title: string, shortcutKey: string): string;
+
 export declare const getActiveLabeledObjects: (targetCanvas?: FabricCanvas) => LabeledFabricObject[];
 
 export declare const getCanvasInstance: () => FabricCanvas;
 
 export declare const getCanvasJSON: (targetCanvas?: FabricCanvas) => CanvasJSON;
 
+export declare const getImageToolStore: () => ImageToolState;
+
 export declare const getLabeledObjects: (targetCanvas?: FabricCanvas) => LabeledFabricObject[];
 
+/**
+ * Normalize keyboard event to a shortcut key string.
+ * Handles special cases like backslash.
+ */
+export declare function getLabelingShortcutKey(event: KeyboardEvent): string;
+
 export declare const getToolSelectionStore: () => ToolSelectionState;
 
+export declare const getViewModeStore: () => ViewModeState;
+
+declare type IconSize = 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
+
+declare interface ImageToolState {
+    tool: LabelingTool | null;
+    setTool: (tool: LabelingTool | null) => void;
+    overedUniques: string[];
+    setOveredUniques: (overedUniques: string[]) => void;
+    undoStack: string[];
+    redoStack: string[];
+    setUndoStack: (undoStack: string[]) => void;
+    setRedoStack: (redoStack: string[]) => void;
+    toolHistory: string[];
+}
+
+declare interface IssuePanelState {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+
+declare interface KeyboardShortcutsConfig {
+    viewMode: WorkspaceViewMode;
+    isValidationMode: boolean;
+    setTool: (toolType: ToolType) => void;
+    onUndo?: () => void;
+    onRedo?: () => void;
+    disabled?: boolean;
+}
+
+declare interface LabelBatchState {
+    classificationLabels: ClassificationLabelEntry[];
+    classificationDeletedIds: string[];
+    inserts: LabelInsertData[];
+    updates: LabelUpdateData[];
+    deletes: LabelDeleteData[];
+    labelDataRevision: number;
+    addClassificationLabel: (label: ClassificationLabelEntry) => void;
+    removeClassificationLabel: (tempId: string) => void;
+    removeClassificationLabelById: (labelId: string) => void;
+    clearTemporaryClassificationLabels: () => void;
+    clearPendingChanges: () => void;
+    hasPendingChanges: () => boolean;
+    bumpLabelDataRevision: () => void;
+    reset: () => void;
+}
+
+export declare interface LabelDeleteData {
+    id: string;
+}
+
 declare interface LabeledFabricObject extends FabricObject {
     info?: string;
     unique?: string;
@@ -273,6 +370,36 @@ declare type LabelEventListener = (action: LabelEventType, data?: LabelEventData
 
 declare type LabelEventType = 'load' | 'selected' | 'deleted' | 'zoom' | 'copy' | 'paste' | 'deleteSelected' | 'selectAll' | 'reset' | 'combine' | 'seq' | 'addClass' | 'deleteObjectsOfTool' | 'addObjects' | 'deselectAll' | 'undo' | 'redo' | 'changed' | 'blur' | 'focus' | 'init';
 
+/**
+ * Keyboard shortcut definitions matching portal-iris-web.
+ */
+export declare const LABELING_SHORTCUTS: {
+    readonly common: {
+        readonly selection: "v";
+        readonly layerToggle: "\\";
+        readonly navigationToggle: "g";
+    };
+    readonly image: {
+        readonly boundingBox: "u";
+        readonly pen: "p";
+        readonly brush: "b";
+        readonly magicBrush: "w";
+        readonly superpixel: "x";
+        readonly eraser: "e";
+    };
+    readonly text: {
+        readonly highlighting: "h";
+        readonly autoHighlight: "a";
+    };
+    readonly number: {
+        readonly highlighting: "h";
+    };
+    readonly validation: {
+        readonly rangeSelection: "s";
+        readonly issue: "i";
+    };
+};
+
 export declare function LabelingCanvas({ image, annotations, onChange, readOnly, width, height, }: LabelingCanvasProps): JSX_2.Element;
 
 declare interface LabelingCanvasProps {
@@ -296,7 +423,7 @@ export declare interface LabelingClass {
     group?: string;
 }
 
-declare interface LabelingContextValue {
+export declare interface LabelingContextValue {
     image: string | {
         url: string;
         width: number;
@@ -304,17 +431,30 @@ declare interface LabelingContextValue {
     };
     annotations: Annotation[];
     onChange: (event: CanvasChangeEvent) => void;
+    viewMode: WorkspaceViewMode;
+    onViewModeChange: (mode: WorkspaceViewMode) => void;
+    availableViewModes: WorkspaceViewMode[];
+    textContent?: TextContent;
+    numberContent?: NumberContent;
+    fileContent?: FileContent;
     records: WorkspaceRecord[];
     activeRecordId: string;
     onRecordSelect: (record: WorkspaceRecord) => void;
     classes: LabelingClass[];
+    policies: LabelingPolicy[];
     onClassSelect?: (cls: LabelingClass) => void;
     selectedClassId: string | null;
     setSelectedClassId: (id: string | null) => void;
     selectedAnnotationId: string | null;
     setSelectedAnnotationId: (id: string | null) => void;
-    onSave: (state: CanvasState_2) => void | Promise<void>;
+    onSave: (payload: SavePayload) => void | Promise<void>;
+    onSaveToRecord?: () => void;
+    onFileUpload?: (file: File) => void;
     isSaving: boolean;
+    onNavigateLeft?: () => void;
+    onNavigateRight?: () => void;
+    canNavigateLeft: boolean;
+    canNavigateRight: boolean;
     mode: WorkspaceMode;
     onModeChange?: (mode: WorkspaceMode) => void;
     validationResults: ValidationResult[];
@@ -335,6 +475,18 @@ export declare interface LabelingExtension {
     render: (context: ExtensionContext) => ReactNode;
 }
 
+/**
+ * File labeling section.
+ * Shows file info when a file exists, or an upload area when empty.
+ */
+export declare function LabelingFileSection({ content, readOnly, onFileUpload, }: LabelingFileSectionProps): JSX_2.Element;
+
+declare interface LabelingFileSectionProps {
+    content?: FileContent;
+    readOnly?: boolean;
+    onFileUpload?: (file: File) => void;
+}
+
 export declare function LabelingFloatingToolbar({ items, show, verticalNav, children, }: LabelingFloatingToolbarProps): JSX_2.Element | null;
 
 declare interface LabelingFloatingToolbarProps {
@@ -344,6 +496,17 @@ declare interface LabelingFloatingToolbarProps {
     children?: ReactNode;
 }
 
+export declare function LabelingIcon({ iconType, size, className, style, }: LabelingIconProps): JSX_2.Element | null;
+
+export declare type LabelingIconName = 'icon-selection' | 'icon-borderd-rect' | 'icon-pen' | 'icon-brush' | 'icon-eraser' | 'icon-magic-wand' | 'icon-superpixel' | 'icon-seg-anything' | 'icon-undo' | 'icon-redo' | 'icon-save' | 'icon-down' | 'icon-all-layer' | 'icon-bottom-layer' | 'icon-top-layer' | 'icon-plus' | 'icon-minus' | 'icon-left' | 'icon-right' | 'icon-issue' | 'icon-labeling' | 'icon-validated' | 'icon-cancel' | 'icon-highlight';
+
+declare interface LabelingIconProps {
+    iconType: LabelingIconName;
+    size?: IconSize;
+    className?: string;
+    style?: React.CSSProperties;
+}
+
 export declare function LabelingIndicator({ indicator }: LabelingIndicatorProps): JSX_2.Element | null;
 
 declare interface LabelingIndicatorProps {
@@ -385,7 +548,32 @@ declare interface LabelingNavigationProps {
     hidden?: boolean;
 }
 
-export declare function LabelingProvider({ image, annotations, onChange, records, activeRecordId, onRecordSelect, classes, onClassSelect, onSave, isSaving, mode, onModeChange, validationResults, indicator, extensions, tools, theme, layout, children, }: LabelingProviderProps): JSX_2.Element;
+/**
+ * Number/chart labeling section.
+ * Renders a data table from source data. Chart rendering is delegated to the host
+ * app or a future extension (canvas-based chart is complex and library-dependent).
+ */
+export declare function LabelingNumberSection({ content, readOnly, segments, }: LabelingNumberSectionProps): JSX_2.Element;
+
+declare interface LabelingNumberSectionProps {
+    content?: NumberContent;
+    readOnly?: boolean;
+    segments?: Array<{
+        id: string;
+        start: number;
+        end: number;
+        color: string;
+        opacity?: number;
+    }>;
+}
+
+export declare interface LabelingPolicy {
+    id: string;
+    name: string;
+    classes: LabelingClass[];
+}
+
+export declare function LabelingProvider({ image, annotations, onChange, viewMode: viewModeProp, onViewModeChange: onViewModeChangeProp, availableViewModes, textContent, numberContent, fileContent, records, activeRecordId, onRecordSelect, classes, policies, onClassSelect, onSave, onSaveToRecord, onFileUpload, isSaving, onNavigateLeft, onNavigateRight, canNavigateLeft, canNavigateRight, mode, onModeChange, validationResults, indicator, extensions, tools, theme, layout, children, }: LabelingProviderProps): JSX_2.Element;
 
 declare interface LabelingProviderProps {
     image: string | {
@@ -395,13 +583,26 @@ declare interface LabelingProviderProps {
     };
     annotations: Annotation[];
     onChange: (event: CanvasChangeEvent) => void;
+    viewMode?: WorkspaceViewMode;
+    onViewModeChange?: (mode: WorkspaceViewMode) => void;
+    availableViewModes?: WorkspaceViewMode[];
+    textContent?: TextContent;
+    numberContent?: NumberContent;
+    fileContent?: FileContent;
     records: WorkspaceRecord[];
     activeRecordId: string;
     onRecordSelect: (record: WorkspaceRecord) => void;
     classes: LabelingClass[];
+    policies?: LabelingPolicy[];
     onClassSelect?: (cls: LabelingClass) => void;
-    onSave: (state: CanvasState_2) => void | Promise<void>;
+    onSave: (payload: SavePayload) => void | Promise<void>;
+    onSaveToRecord?: () => void;
+    onFileUpload?: (file: File) => void;
     isSaving?: boolean;
+    onNavigateLeft?: () => void;
+    onNavigateRight?: () => void;
+    canNavigateLeft?: boolean;
+    canNavigateRight?: boolean;
     mode?: WorkspaceMode;
     onModeChange?: (mode: WorkspaceMode) => void;
     validationResults?: ValidationResult[];
@@ -413,6 +614,24 @@ declare interface LabelingProviderProps {
     children: ReactNode;
 }
 
+/**
+ * Text labeling section — renders text content with highlighted segments.
+ * Users can select text to create new segments via mouseup events.
+ */
+export declare function LabelingTextSection({ content, readOnly, segments, }: LabelingTextSectionProps): JSX_2.Element;
+
+declare interface LabelingTextSectionProps {
+    content?: TextContent;
+    readOnly?: boolean;
+    segments?: Array<{
+        id: string;
+        start: number;
+        end: number;
+        color: string;
+        opacity?: number;
+    }>;
+}
+
 export declare interface LabelingTheme {
     primary: string;
     background: string;
@@ -436,30 +655,43 @@ declare interface LabelingTool {
     init: (...args: any[]) => Promise<(() => void) | void | undefined> | (() => void) | void;
 }
 
-export declare function LabelingToolbar({ tools, sections: _sections, onSave, isSaving, onPrev, onNext, hasPrev, hasNext, children, }: LabelingToolbarInternalProps): JSX_2.Element;
+/**
+ * Floating toolbar that renders view-mode-aware tools via useLabelingUIMeta.
+ * Tool set, icons, and behavior all come from the UIMeta hooks.
+ */
+export declare function LabelingToolbar({ children }: LabelingToolbarInternalProps): JSX_2.Element;
 
-declare interface LabelingToolbarInternalProps extends LabelingToolbarProps {
-    tools?: ToolType[];
+declare interface LabelingToolbarInternalProps {
     children?: ReactNode;
 }
 
-export declare interface LabelingToolbarProps {
-    orientation?: 'horizontal' | 'vertical';
-    sections?: ToolbarSection[];
-    onSave?: () => void;
-    isSaving?: boolean;
-    onPrev?: () => void;
-    onNext?: () => void;
-    hasPrev?: boolean;
-    hasNext?: boolean;
+declare interface LabelingUIMetaResult {
+    toolbar: ToolbarItemMeta[];
 }
 
 /**
  * Level 1: All-in-one labeling workspace.
- * Renders Navigation + Toolbar + Canvas + InfoPanel in a single component.
+ * Renders WorkspaceControl + Navigation + WorkspaceSection + FloatingToolbar + InfoPanel.
  */
 export declare function LabelingWorkspace(props: LabelingWorkspaceProps): JSX_2.Element;
 
+export declare function LabelingWorkspaceControl({ viewMode, onViewModeChange, availableViewModes, mode, onModeChange, onSave, onSaveToRecord, isSaving, onNavigateLeft, onNavigateRight, canNavigateLeft, canNavigateRight, }: LabelingWorkspaceControlProps): JSX_2.Element;
+
+declare interface LabelingWorkspaceControlProps {
+    viewMode: WorkspaceViewMode;
+    onViewModeChange?: (mode: WorkspaceViewMode) => void;
+    availableViewModes?: WorkspaceViewMode[];
+    mode?: WorkspaceMode;
+    onModeChange?: (mode: WorkspaceMode) => void;
+    onSave?: () => void;
+    onSaveToRecord?: () => void;
+    isSaving?: boolean;
+    onNavigateLeft?: () => void;
+    onNavigateRight?: () => void;
+    canNavigateLeft?: boolean;
+    canNavigateRight?: boolean;
+}
+
 export declare interface LabelingWorkspaceProps {
     image: string | {
         url: string;
@@ -468,26 +700,90 @@ export declare interface LabelingWorkspaceProps {
     };
     annotations: Annotation[];
     onChange: (event: CanvasChangeEvent) => void;
+    viewMode?: WorkspaceViewMode;
+    onViewModeChange?: (mode: WorkspaceViewMode) => void;
+    availableViewModes?: WorkspaceViewMode[];
+    textContent?: TextContent;
+    numberContent?: NumberContent;
+    fileContent?: FileContent;
     records: WorkspaceRecord[];
     activeRecordId: string;
     onRecordSelect: (record: WorkspaceRecord) => void;
+    onDetailExpand?: (record: WorkspaceRecord, schemaLabel: string) => void;
     totalRecords?: number;
     onPageChange?: (page: number) => void;
     classes: LabelingClass[];
+    policies?: LabelingPolicy[];
     onClassSelect?: (cls: LabelingClass) => void;
-    onSave: (state: CanvasState_2) => void | Promise<void>;
+    onSave: (payload: SavePayload) => void | Promise<void>;
+    onSaveToRecord?: (payload: SaveToRecordPayload) => void | Promise<void>;
+    onFileUpload?: (payload: FileUploadPayload) => void | Promise<void>;
     isSaving?: boolean;
+    onNavigateLeft?: () => void;
+    onNavigateRight?: () => void;
+    canNavigateLeft?: boolean;
+    canNavigateRight?: boolean;
     mode?: WorkspaceMode;
     onModeChange?: (mode: WorkspaceMode) => void;
     validationResults?: ValidationResult[];
     onValidate?: (event: ValidateEvent) => void | Promise<void>;
     onValidationUpdate?: (event: ValidationUpdateEvent) => void | Promise<void>;
     onValidationDelete?: (event: ValidationDeleteEvent) => void | Promise<void>;
+    onSaveValidation?: (payload: SaveValidationPayload) => void | Promise<void>;
     indicator?: WorkspaceIndicator;
     extensions?: LabelingExtension[];
     tools?: ToolType[];
     theme?: Partial<LabelingTheme>;
     layout?: WorkspaceLayout;
+    isDirty?: boolean;
+    dirtyConfirmMessage?: string;
+}
+
+/**
+ * View-mode switching container.
+ * Shows the appropriate content section based on the current view mode.
+ */
+export declare function LabelingWorkspaceSection({ viewMode, image, annotations, onChange, readOnly, textContent, numberContent, fileContent, onFileUpload, children, }: LabelingWorkspaceSectionProps): JSX_2.Element;
+
+declare interface LabelingWorkspaceSectionProps {
+    viewMode: WorkspaceViewMode;
+    image: string | {
+        url: string;
+        width: number;
+        height: number;
+    };
+    annotations: Annotation[];
+    onChange?: (event: CanvasChangeEvent) => void;
+    readOnly?: boolean;
+    textContent?: TextContent;
+    numberContent?: NumberContent;
+    fileContent?: FileContent;
+    onFileUpload?: (file: File) => void;
+    children?: ReactNode;
+}
+
+export declare interface LabelInsertData {
+    policyId: string;
+    classIndex: number;
+    className: string;
+    labelValue: unknown;
+    attributeValues?: Record<string, unknown>;
+}
+
+declare interface LabelSelectionState {
+    selectedClassificationId: string | null;
+    selectedClassificationInfo: SelectedClassificationInfo | null;
+    setSelectedClassificationId: (id: string | null, info?: SelectedClassificationInfo | null) => void;
+}
+
+export declare interface LabelUpdateData extends LabelInsertData {
+    id: string;
+}
+
+declare interface LabelVisibilityState {
+    hiddenClassificationIds: Record<string, boolean>;
+    setClassificationVisibility: (labelId: string, hidden: boolean) => void;
+    reset: () => void;
 }
 
 export declare const LAYER_MODE: Record<string, LayerMode>;
@@ -500,10 +796,79 @@ declare interface LayerModeState {
     cycleMode: () => void;
 }
 
+declare type LayoutDirection = 'horizontal' | 'vertical';
+
 export declare const loadFabric: () => Promise<fabric>;
 
 export declare const magicbrushTool: () => LabelingTool;
 
+export declare interface NavigationCellAccessories {
+    badges?: NavigationCellBadge[];
+    hasIssue?: boolean;
+    hasValidationCompleted?: boolean;
+}
+
+export declare interface NavigationCellBadge {
+    title: string;
+    style: 'primary-light' | 'secondary-light';
+}
+
+export declare interface NavigationDetailData {
+    rows: Record<string, unknown>[];
+    columns?: string[];
+}
+
+export declare interface NavigationSchema {
+    label: string;
+    contentType: string;
+    isRequired: boolean;
+    maxItems?: number | null;
+}
+
+export declare interface NumberContent {
+    mode: 'line' | 'bar';
+    xAxis: {
+        label: string;
+        ticks: unknown[];
+    };
+    yAxis: {
+        label: string;
+        series: unknown[];
+    };
+    source: {
+        rows: unknown[];
+        columns: unknown[];
+    };
+    canRender: boolean;
+}
+
+declare interface NumberLabelingTool {
+    id: 'selection' | 'drag-segment';
+    label: string;
+}
+
+declare interface NumberSegmentSelection {
+    key: string;
+    labelId: string | null;
+    tempId: string | null;
+    start: number;
+    end: number;
+    color?: string;
+    opacity?: number;
+}
+
+declare interface NumberSegmentSelectionState {
+    selectedSegment: NumberSegmentSelection | null;
+    setSelectedSegment: (segment: NumberSegmentSelection | null) => void;
+}
+
+declare interface NumberToolState {
+    tool: NumberLabelingTool | null;
+    setTool: (tool: NumberLabelingTool | null) => void;
+}
+
+export declare type NumberToolType = 'selection' | 'drag-segment';
+
 declare interface OpacityState {
     opacity: number;
     setOpacity: (opacity: number) => void;
@@ -536,6 +901,29 @@ export declare type RecordStatus = 'unlabeled' | 'labeled' | 'validated' | 'issu
 
 export declare const renderAllSafe: (targetCanvas?: FabricCanvas) => void;
 
+export declare interface SavePayload {
+    viewMode: WorkspaceViewMode;
+    inserts: LabelInsertData[];
+    updates: LabelUpdateData[];
+    deletes: LabelDeleteData[];
+    canvasJSON?: object;
+    imageSize?: {
+        width: number;
+        height: number;
+    };
+}
+
+export declare interface SaveToRecordPayload {
+    contentSetId: string;
+    labels: LabelInsertData[];
+}
+
+export declare interface SaveValidationPayload {
+    result: boolean;
+    reason?: string;
+    labelIds: string[];
+}
+
 export declare const segmentAnythingTool: () => LabelingTool;
 
 export declare interface SegmentationGeometry {
@@ -546,6 +934,20 @@ export declare interface SegmentationGeometry {
     vector?: string;
 }
 
+declare interface SelectedClassificationInfo {
+    policyId?: string | null;
+    classIndex?: number | null;
+    className?: string | null;
+    labelId?: string | null;
+    tempId?: string | null;
+    isCanvasFocused?: boolean;
+}
+
+declare interface SelectedObjectsState {
+    objects: LabeledFabricObject[];
+    setObjects: (objects: LabeledFabricObject[]) => void;
+}
+
 export declare const selectionTool: () => LabelingTool;
 
 export declare const setCanvasInstance: (instance: FabricCanvas | null) => void;
@@ -567,6 +969,49 @@ declare interface TemporalHistoryState<T> {
     reset: () => void;
 }
 
+declare interface TextAutoHighlightState {
+    english: boolean;
+    number: boolean;
+    special: boolean;
+    setEnglish: (value: boolean) => void;
+    setNumber: (value: boolean) => void;
+    setSpecial: (value: boolean) => void;
+    reset: () => void;
+}
+
+export declare interface TextContent {
+    value: string;
+    elementId?: string;
+}
+
+declare interface TextLabelingTool {
+    id: 'selection' | 'drag-segment';
+    label: string;
+}
+
+declare interface TextSegmentSelection {
+    key: string;
+    labelId: string | null;
+    tempId: string | null;
+    start: number;
+    end: number;
+    text: string;
+    color?: string;
+    opacity?: number;
+}
+
+declare interface TextSegmentSelectionState {
+    selectedSegment: TextSegmentSelection | null;
+    setSelectedSegment: (segment: TextSegmentSelection | null) => void;
+}
+
+declare interface TextToolState {
+    tool: TextLabelingTool | null;
+    setTool: (tool: TextLabelingTool | null) => void;
+}
+
+export declare type TextToolType = 'selection' | 'drag-segment';
+
 export declare const toHex: (color: string) => {
     hex: string;
     alpha: string;
@@ -601,11 +1046,50 @@ export declare interface ToolbarButtonItem {
     subItems?: ToolbarItem[];
 }
 
+declare interface ToolbarButtonItemMeta {
+    variant: 'button';
+    id?: string;
+    icon: ReactNode;
+    title: string;
+    tooltip?: string;
+    disabled?: boolean;
+    active?: boolean;
+    slim?: boolean;
+    onClick: () => void;
+    subItems?: ToolbarItemMeta[];
+}
+
+export declare interface ToolbarCheckboxItem {
+    variant: 'checkbox';
+    id: string;
+    icon?: ReactNode;
+    title?: string;
+    checked?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+}
+
+declare interface ToolbarCheckboxItemMeta {
+    variant: 'checkbox';
+    id: string;
+    icon?: ReactNode;
+    title: string;
+    checked: boolean;
+    disabled?: boolean;
+    onClick: () => void;
+}
+
 export declare interface ToolbarDividerItem {
     variant: 'divider';
 }
 
-export declare type ToolbarItem = ToolbarButtonItem | ToolbarRadioItem | ToolbarDividerItem;
+declare interface ToolbarDividerItemMeta {
+    variant: 'divider';
+}
+
+export declare type ToolbarItem = ToolbarButtonItem | ToolbarRadioItem | ToolbarCheckboxItem | ToolbarDividerItem;
+
+declare type ToolbarItemMeta = ToolbarRadioItemMeta | ToolbarButtonItemMeta | ToolbarCheckboxItemMeta | ToolbarDividerItemMeta;
 
 export declare interface ToolbarRadioItem {
     variant: 'radio';
@@ -618,6 +1102,19 @@ export declare interface ToolbarRadioItem {
     onClick?: () => void;
 }
 
+declare interface ToolbarRadioItemMeta {
+    variant: 'radio';
+    id: string;
+    name: string;
+    icon: ReactNode;
+    title: string;
+    checked: boolean;
+    disabled?: boolean;
+    isSlim?: boolean;
+    onClick: () => void;
+    subButtonItems?: ToolbarItemMeta[];
+}
+
 export declare type ToolbarSection = 'tools' | 'brush' | 'palette' | 'zoom' | 'history' | 'layers' | 'viewMode' | 'validation' | 'navigation' | 'save';
 
 export declare interface ToolExtension extends LabelingExtension {
@@ -632,6 +1129,19 @@ export declare interface ToolExtension extends LabelingExtension {
     };
 }
 
+declare interface ToolInitConfig {
+    colorCode: string;
+    brush: BrushOptions;
+    imageUrl?: string;
+    magicbrushConfig?: {
+        threshold: number;
+        radius: number;
+    };
+    superpixelConfig?: Record<string, number>;
+    segAnythingCallback?: (payload: any) => void;
+    previousTool?: LabelingTool | null;
+}
+
 declare interface ToolSelectionState {
     tool: LabelingTool | null;
     setTool: (tool: LabelingTool | null) => void;
@@ -643,7 +1153,7 @@ declare interface ToolSelectionState {
     setRedoStack: (redoStack: string[]) => void;
 }
 
-export declare type ToolType = 'selection' | 'brush' | 'blankRect' | 'filledRect' | 'polygon' | 'eraser' | 'magicbrush' | 'superpixel';
+export declare type ToolType = 'selection' | 'brush' | 'blankRect' | 'filledRect' | 'polygon' | 'eraser' | 'magicbrush' | 'superpixel' | 'segAnything';
 
 export declare const toRgba: (hex: string, opacity: number) => string;
 
@@ -688,6 +1198,19 @@ declare interface UseExtensionsOptions {
     setTool: (tool: string) => void;
 }
 
+export declare const useImageToolStore: UseBoundStore<StoreApi<ImageToolState>>;
+
+export declare const useIssuePanelStore: UseBoundStore<StoreApi<IssuePanelState>>;
+
+/**
+ * Registers keyboard shortcuts matching portal-iris-web.
+ * Shortcuts are view-mode-aware: Image mode has brush/eraser keys,
+ * Text mode has highlighting, etc.
+ */
+export declare function useKeyboardShortcuts({ viewMode, isValidationMode, setTool, onUndo, onRedo, disabled, }: KeyboardShortcutsConfig): void;
+
+export declare const useLabelBatchStore: UseBoundStore<StoreApi<LabelBatchState>>;
+
 /**
  * Level 3 headless hook — Direct canvas access.
  *
@@ -747,14 +1270,46 @@ export declare function useLabelingTools(): {
     }) => void;
 };
 
+export declare function useLabelingUIMeta(viewMode: WorkspaceViewMode, isValidationMode: boolean): LabelingUIMetaResult;
+
+export declare const useLabelSelectionStore: UseBoundStore<StoreApi<LabelSelectionState>>;
+
+export declare const useLabelVisibilityStore: UseBoundStore<StoreApi<LabelVisibilityState>>;
+
 export declare const useLayerModeStore: UseBoundStore<StoreApi<LayerModeState>>;
 
+export declare const useNumberSegmentSelectionStore: UseBoundStore<StoreApi<NumberSegmentSelectionState>>;
+
+export declare const useNumberToolStore: UseBoundStore<StoreApi<NumberToolState>>;
+
 export declare const useOpacityStore: UseBoundStore<StoreApi<OpacityState>>;
 
 export declare const usePaletteStore: UseBoundStore<StoreApi<PaletteState>>;
 
+export declare const useSelectedObjectsStore: UseBoundStore<StoreApi<SelectedObjectsState>>;
+
+export declare const useTextAutoHighlightStore: UseBoundStore<StoreApi<TextAutoHighlightState>>;
+
+export declare const useTextSegmentSelectionStore: UseBoundStore<StoreApi<TextSegmentSelectionState>>;
+
+export declare const useTextToolStore: UseBoundStore<StoreApi<TextToolState>>;
+
+/**
+ * Manages tool lifecycle: calls tool.init(config) when the tool changes,
+ * and runs the cleanup function returned by init when unmounting or switching.
+ */
+export declare function useToolInit(currentTool: LabelingTool | null, config: ToolInitConfig): {
+    activeToolId: string | null;
+};
+
 export declare const useToolSelectionStore: UseBoundStore<StoreApi<ToolSelectionState>>;
 
+export declare const useValidationModeStore: UseBoundStore<StoreApi<ValidationModeState>>;
+
+export declare const useViewModeStore: UseBoundStore<StoreApi<ViewModeState>>;
+
+export declare const useWorkspaceLayoutStore: UseBoundStore<StoreApi<WorkspaceLayoutState>>;
+
 export declare const useZoomStore: UseBoundStore<StoreApi<ZoomState>>;
 
 export declare interface ValidateEvent {
@@ -767,6 +1322,12 @@ export declare interface ValidationDeleteEvent {
     ids: string[];
 }
 
+declare interface ValidationModeState {
+    isValidationMode: boolean;
+    setValidationMode: (value: boolean) => void;
+    toggleValidationMode: () => void;
+}
+
 export declare interface ValidationResult {
     id: string;
     annotationId?: string;
@@ -781,6 +1342,13 @@ export declare interface ValidationUpdateEvent {
     reason?: string;
 }
 
+declare interface ViewModeState {
+    mode: WorkspaceViewMode;
+    setMode: (mode: WorkspaceViewMode) => void;
+}
+
+export declare const WORKSPACE_VIEW_MODES: readonly ["Record", "Image", "Text", "Number", "File"];
+
 export declare interface WorkspaceIndicator {
     title: string;
     subtitle?: string;
@@ -796,6 +1364,14 @@ export declare interface WorkspaceLayout {
     toolbar?: 'top' | 'bottom';
 }
 
+declare interface WorkspaceLayoutState {
+    direction: LayoutDirection;
+    active: boolean;
+    setDirection: (direction: LayoutDirection) => void;
+    setActive: (active: boolean) => void;
+    toggleActive: () => void;
+}
+
 export declare type WorkspaceMode = 'labeling' | 'validation' | 'readonly';
 
 export declare interface WorkspaceRecord {
@@ -805,8 +1381,15 @@ export declare interface WorkspaceRecord {
     status?: RecordStatus;
     children?: WorkspaceRecord[];
     meta?: Record<string, unknown>;
+    /** Schema-based table mode */
+    summary?: Record<string, string>;
+    schemas?: NavigationSchema[];
+    accessories?: Record<string, NavigationCellAccessories>;
+    detail?: NavigationDetailData;
 }
 
+export declare type WorkspaceViewMode = 'Record' | 'Image' | 'Text' | 'Number' | 'File';
+
 declare interface ZoomPayload {
     direction: 1 | 0 | -1;
     level: number;