@servantcdh/ez-planet-labeling 0.3.3 → 0.4.0

package/dist/index.d.ts

@@ -1,1440 +1,1031 @@
-import { Canvas } from 'fabric';
-import { fabric } from 'fabric';
-import { FabricObject } from 'fabric';
+import { ComponentProps } from 'react';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import { ReactNode } from 'react';
+import { RefObject } from 'react';
 import { StoreApi } from 'zustand';
-import { TemporalState } from 'zundo';
 import { UseBoundStore } from 'zustand';
 
-export declare interface Annotation {
-    /** Host app assigns this freely (DB PK, UUID, temp ID, etc.) */
-    id: string;
-    type: AnnotationType;
-    label: AnnotationLabel;
-    style: AnnotationStyle;
-    geometry: AnnotationGeometry | null;
-}
-
-export declare type AnnotationGeometry = BoxGeometry | SegmentationGeometry | PolygonGeometry | BrushGeometry | RecognitionGeometry;
-
-export declare interface AnnotationLabel {
-    name: string;
-    index: number;
-}
+/**
+ * Add fabric objects to the canvas.
+ * Extensions call this to render results (polygons, boxes, etc.).
+ */
+export declare function addCanvasObjects(objects: unknown[]): void;
 
-export declare interface AnnotationStyle {
-    color: string;
-    opacity: number;
-    lineColor?: string;
-    lineWidth?: number;
-    zIndex?: number;
+export declare interface ApiResponse<T> {
+    code?: number;
+    message?: string;
+    data: T;
 }
 
 /**
- * Convert an Annotation back to Fabric object options (for canvas loading).
- * This creates the configuration that can be used with Fabric's enlivenObjects.
+ * AsyncData<T> — a lightweight wrapper that mirrors the surface of
+ * react-query's UseQueryResult so that consumer components need zero
+ * changes when we swap the data source from react-query to host-provided
+ * context.
  */
-export declare const annotationToFabricProps: (annotation: Annotation, imageWidth: number, imageHeight: number) => Record<string, unknown>;
-
-export declare type AnnotationType = 'box' | 'segmentation' | 'polygon' | 'brush' | 'classification' | 'recognition';
-
-export declare const basicBrushes: {
-    id: number;
-    lineCap: string;
-    lineWidth: number;
-}[];
-
-export declare const basicColors: string[];
-
-export declare const blankRectTool: () => LabelingTool;
-
-export declare interface BoxGeometry {
-    type: 'box';
-    /** Normalized coordinates (0~1 ratio, image-size independent) */
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+export declare interface AsyncData<T> {
+    data: T | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    error: unknown;
+    refetch: () => void;
+    dataUpdatedAt: number;
 }
 
-export declare interface BrushGeometry {
-    type: 'brush';
-    /** SVG path or fabric path data */
-    path: string;
+declare interface Attribute {
+    name: string;
+    attributeType: "SELECT" | "CHECKBOX" | "TEXT";
+    values: string[];
+    placeholder?: string;
 }
 
-declare interface BrushOptions {
-    lineCap: string;
-    lineWidth: number;
+export declare interface AttributeValue {
+    attributeType?: LabelAttributeType;
+    name?: string;
+    values?: string[];
 }
 
-declare interface BrushState {
-    brush: {
-        id: number;
-        lineCap: string;
-        lineWidth: number;
-    };
-    setBrush: (brush: {
-        id: number;
-        lineCap: string;
-        lineWidth: number;
-    }) => void;
+declare interface AutoLabelingInfo {
+    modelId?: string;
+    externalModelId?: string;
+    scores?: Score[];
+    transactionId?: string;
+    containerId?: string;
+    status?: string;
+    inferenceType?: string;
+    threshold?: number;
 }
 
-export declare const brushTool: () => LabelingTool;
+declare function Badge({ title, size, style }: BagdeType): JSX_2.Element;
 
-export declare type CanvasAction = {
-    type: 'add';
-    annotation: Annotation;
-} | {
-    type: 'update';
-    annotation: Annotation;
-    prev: Annotation;
-} | {
-    type: 'delete';
-    id: string;
-} | {
-    type: 'batch';
-    added: Annotation[];
-    updated: Annotation[];
-    deleted: string[];
-};
+declare type BadgeStyle = ComponentProps<typeof Badge>["style"];
 
-export declare interface CanvasChangeEvent {
-    annotations: Annotation[];
-    action: CanvasAction;
+declare interface BagdeType extends UIType {
+    title: string;
+    style?: "primary" | "secondary" | "accent" | "primary-light" | "secondary-light" | "accent-light" | "blue";
 }
 
-declare interface CanvasExportJSON {
-    version: string;
-    objects: Record<string, unknown>[];
+declare interface BaseInfoDTO {
+    contentSize?: number;
+    contentType?: string;
+    fileFormat?: string[];
+    isRequired?: boolean;
+    isPreset?: boolean;
+    isVisible?: boolean;
+    schemaId?: string;
+    schemaName?: string;
 }
 
-declare interface CanvasJSON {
-    version: string;
-    objects: LabeledFabricObject[];
+declare interface BatchUpdateSummary {
+    deletedCount?: number;
+    insertedCount?: number;
+    updatedCount?: number;
+    totalProcessed?: number;
 }
 
-declare interface CanvasObjectsState {
-    objects: LabeledFabricObject[];
-    setObjects: (objects: LabeledFabricObject[]) => void;
+export declare interface BoxValue {
+    className?: string;
+    classIndex?: number;
+    coord?: number[];
+    color?: string;
+    lineColor?: string;
+    opacity?: number;
+    zindex?: number;
 }
 
-export declare interface CanvasPointerEvent {
-    x: number;
-    y: number;
-    shiftKey: boolean;
-    ctrlKey: boolean;
-    altKey: boolean;
+declare interface BulkLabelCreateRequest {
+    labels: LabelInsertData[];
 }
 
-declare interface CanvasState_2 {
-    annotations: Annotation[];
-    canvasJSON: object;
-    image: {
-        width: number;
-        height: number;
-    };
+declare interface BulkLabelCreateResponse {
+    labelContextId: string;
+    createdLabels: LabelResponse[];
 }
-export { CanvasState_2 as CanvasState }
 
-/**
- * Convert all canvas objects to Annotations.
- */
-export declare const canvasToAnnotations: (objects: LabeledFabricObject[], imageWidth: number, imageHeight: number) => Promise<Annotation[]>;
+declare type ChartPivotMode = (typeof WORKSPACE_CHART_PIVOT_MODE)[keyof typeof WORKSPACE_CHART_PIVOT_MODE];
 
-declare interface ClassificationLabelEntry {
-    tempId: string;
-    labelId: string | null;
-    policyId: string;
-    classIndex: number;
-    className: string;
-    labelValue: unknown;
-    attributeValues?: Record<string, unknown>;
+export declare interface ChartValue {
+    className?: string;
+    classIndex?: number;
+    columnName?: string;
     color?: string;
     opacity?: number;
+    zindex?: number;
 }
 
-/**
- * Create an HTMLImageElement from a URL.
- */
-export declare const createImage: (src: string) => Promise<HTMLImageElement>;
-
-export declare const createTemporalHistoryStore: <T>() => UseBoundStore<Omit<StoreApi<TemporalHistoryState<T>>, "temporal"> & {
-temporal: StoreApi<TemporalState<    {
-snapshot: T | null;
-}>>;
-}>;
-
-/**
- * Crop image data to the bounding box of non-transparent pixels.
- */
-export declare const cropAlphaArea: (imgData: ImageData) => {
-    canvas: HTMLCanvasElement;
-    minX: number;
-    minY: number;
-};
-
-export declare const emitLabelEvent: (action: LabelEventType, data?: LabelEventData) => void;
-
-export declare const ensureCanvas: () => FabricCanvas;
-
-export declare const eraserTool: () => LabelingTool;
-
-export declare const EXCEPTION_TOOLS: string[];
-
-export declare const EXPORT_PROPS: string[];
-
-export declare interface ExtensionContext {
-    image: {
-        url: string;
-        width: number;
-        height: number;
-    };
-    annotations: Annotation[];
-    selectedIds: string[];
-    activeTool: string;
-    addAnnotations: (annotations: Annotation[]) => void;
-    updateAnnotation: (id: string, annotation: Partial<Annotation>) => void;
-    removeAnnotations: (ids: string[]) => void;
-    setTool: (tool: string) => void;
-    canvas: {
-        toJSON: () => object;
-        getImageDataURL: () => string;
-    };
+export declare interface ClassificationValue {
+    classIndex?: number;
+    className?: string;
 }
 
-declare type FabricCanvas = Canvas & {
-    lowerCanvasEl?: HTMLCanvasElement | null;
-    upperCanvasEl?: HTMLCanvasElement | null;
-};
-
-/**
- * Convert a Fabric object to an Annotation.
- */
-export declare const fabricObjectToAnnotation: (object: LabeledFabricObject, imageWidth: number, imageHeight: number) => Promise<Annotation | null>;
-
-export declare interface FileContent {
-    endpointUrl?: string;
-    fileName?: string;
-    fileType?: string;
+declare interface ContentDTO {
+    accountId?: string;
+    contents?: Record<string, Array<Record<string, unknown>>>;
+    contentSetId?: string;
+    createdBy?: string;
+    createdDate?: string;
+    createdId?: string;
+    datasetId?: string;
+    id?: string;
+    modifiedBy?: string;
+    modifiedDate?: string;
+    modifiedId?: string;
+    orgId?: string;
+    summary?: Record<string, number>;
+    transactionId?: string;
+    version?: string | null;
+    zoneId?: string;
 }
 
-export declare interface FileUploadPayload {
-    file: File;
-    policyId: string;
+export declare interface ContentsetStatus {
     contentSetId: string;
-    elementId?: string;
+    totalCount?: number;
+    contentSetStatus?: ContentsetStatusState[];
+    contentsetStatus?: "NONE" | ContentsetStatusState;
+    schemas?: SchemaStatus[];
+    elements?: ElementStatus[];
 }
 
-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 ContentsetStatusResponse {
+    labelContextId: string;
+    datasetId: string;
+    contentSets: ContentsetStatus[];
 }
 
-export declare interface LabelDeleteData {
-    id: string;
-}
+export declare type ContentsetStatusState = "IN_LABELING" | "COMPLETED" | "VALIDATION_COMPLETED" | "VALIDATION_ERROR";
 
-declare interface LabeledFabricObject extends FabricObject {
-    info?: string;
-    unique?: string;
-    hex?: string;
-    alpha?: string;
-    selected?: boolean;
-    class?: string;
-    added?: boolean;
-    index?: number;
-    seq?: number;
-    copied?: boolean;
-    combinded?: boolean;
-    labeler?: string;
-    undo?: boolean;
-    redo?: boolean;
-    passStack?: boolean;
-    replaced?: boolean;
-    removed?: boolean;
-    trueLeft?: number;
-    trueTop?: number;
-    toHex?: string;
-    eraser?: unknown;
-    labelType?: string;
-    labelPayload?: Record<string, unknown>;
-    _objects?: LabeledFabricObject[];
-    labelInsertData?: Record<string, unknown>;
-    [key: string]: unknown;
+declare interface CustomPageWrapper<TItem, TFilter = unknown> {
+    list: TItem[];
+    totalCount: number;
+    filter: TFilter;
 }
 
-declare interface LabelEventData {
-    uniques?: string[];
-    unique?: string;
-    selected?: boolean;
-    objects?: LabeledFabricObject[];
-    info?: string;
-    canvasJSON?: CanvasExportJSON;
-    seq?: Array<{
-        unique: string;
-        seq: number;
-    }>;
-    callback?: (json: CanvasExportJSON | string) => void;
-    direction?: ZoomPayload['direction'];
-    level?: number;
-    onChange?: ZoomPayload['onChange'];
-    class?: string;
-    hex?: string;
-    opacity?: number;
-    onDone?: () => void;
-    imageWidth?: number;
-    imageHeight?: number;
-    action?: string;
-    point?: {
-        x: number;
-        y: number;
-    };
-    labelInsertData?: Record<string, unknown>;
-    [key: string]: unknown;
+export declare interface DatasetApiResponse<T> {
+    code: number;
+    message: string;
+    data: T;
 }
 
-declare type LabelEventListener = (action: LabelEventType, data?: LabelEventData) => void | Promise<void>;
-
-declare type LabelEventType = 'load' | 'selected' | 'deleted' | 'zoom' | 'copy' | 'paste' | 'deleteSelected' | 'selectAll' | 'reset' | 'combine' | 'seq' | 'addClass' | 'deleteObjectsOfTool' | 'addObjects' | 'deselectAll' | 'undo' | 'redo' | 'changed' | 'blur' | 'focus' | 'init';
+export declare type DatasetContentRecord = ContentDTO;
 
-/**
- * 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 interface DatasetContentSearchResponse {
+    filter?: Record<string, unknown>;
+    list: DatasetContentRecord[];
+    totalCount: number;
+}
 
-export declare function LabelingCanvas({ image, annotations, onChange, readOnly, width, height, }: LabelingCanvasProps): JSX_2.Element;
+declare type DatasetContentType = "IMAGE" | "CSV" | "TABLE" | "PDF" | "WORD" | "TABULAR" | "CUSTOM" | (string & {});
 
-declare interface LabelingCanvasProps {
-    image: string | {
-        url: string;
-        width: number;
-        height: number;
-    };
-    annotations: Annotation[];
-    onChange?: (event: CanvasChangeEvent) => void;
-    readOnly?: boolean;
-    width?: number;
-    height?: number;
-}
+declare type DatasetContentVersion = string | null | undefined;
 
-export declare interface LabelingClass {
+export declare interface DatasetDTO {
     id: string;
+    orgId: string;
+    zoneId: string;
+    accountId: string;
+    exist: boolean;
     name: string;
-    color: string;
-    hotkey?: string;
-    group?: string;
+    latestVersion: string;
+    currentVersion: string | null;
+    records: string;
+    versionList: VersionDTO[];
+    isLock: boolean;
+    isEditing: boolean;
+    isArchMode: boolean;
+    tags: string[];
+    schema?: SchemaItemDTO[];
+    importTransactionId?: string;
+    createdId: string;
+    createdBy: string;
+    createdDate: string;
+    modifiedId: string;
+    modifiedBy: string;
+    modifiedDate: string;
+    schemaTypes: DatasetContentType[];
+}
+
+declare interface DetailTableCellSelection {
+    rowIndex: number;
+    columnId: string;
+}
+
+declare interface DetailTableRow {
+    [key: string]: string | undefined;
+    elementId?: string;
 }
 
-export declare interface LabelingContextValue {
-    image: string | {
-        url: string;
-        width: number;
-        height: number;
-    };
-    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: (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[];
-    indicator?: WorkspaceIndicator;
-    extensions: LabelingExtension[];
-    tools: ToolType[];
-    theme?: Partial<LabelingTheme>;
-    layout: WorkspaceLayout;
-    navDirection: 'horizontal' | 'vertical';
-    setNavDirection: (dir: 'horizontal' | 'vertical') => void;
-    navVisible: boolean;
-    setNavVisible: (visible: boolean) => void;
+declare interface ElementStatus {
+    elementId?: string;
+    inLabeling?: boolean;
+    /**
+     * New spec (OAS): elementStatus 배열로 상태를 내려줌
+     * - IN_LABELING / VALIDATION_ERROR / VALIDATION_COMPLETED
+     */
+    elementStatus?: ContentsetStatusState[];
+    policyStatuses?: PolicyLabelStatus[];
 }
 
-export declare interface LabelingExtension {
-    id: string;
-    slot: 'tool' | 'sidePanel' | 'toolbar';
-    render: (context: ExtensionContext) => ReactNode;
-}
+/** An error-state placeholder. */
+export declare function errorData<T>(error: unknown): AsyncData<T>;
 
 /**
- * File labeling section.
- * Shows file info when a file exists, or an upload area when empty.
+ * Context object passed to every extension render function, giving it
+ * access to the current workspace state and canvas interaction.
  */
-export declare function LabelingFileSection({ content, readOnly, onFileUpload, }: LabelingFileSectionProps): JSX_2.Element;
+export declare interface ExtensionRenderContext {
+    /** Currently selected content-set ID (null when nothing is selected). */
+    contentSetId: string | null;
+    /** Active label context ID. */
+    labelContextId: string | null;
+    /** Policy IDs used in the current labeling context. */
+    policyIds: string[];
+    /** Dataset ID. */
+    datasetId: string;
+    /** Dataset version. */
+    datasetVersion: string;
+    /**
+     * Call this after a mutation succeeds so the host can invalidate /
+     * refetch the appropriate caches.
+     */
+    requestDataRefresh: (hint: MutationSuccessHint) => void;
+    /** Ref to the fabric.Canvas instance (null when no image is loaded). */
+    canvasRef: RefObject<unknown | null>;
+    /** Current image dimensions and URL (null when no image is loaded). */
+    imageInfo: WorkspaceImageInfo | null;
+    /** Add fabric objects to the canvas. */
+    addCanvasObjects: (objects: unknown[]) => void;
+    /** Remove fabric objects matching a predicate from the canvas. */
+    removeCanvasObjects: (predicate: (obj: unknown) => boolean) => void;
+}
+
+declare interface FileLabelUploadRequest {
+    file: File;
+    contentSetId?: string;
+    elementId?: string;
+    policyId: string;
+    schemaName?: string;
+}
 
-declare interface LabelingFileSectionProps {
-    content?: FileContent;
-    readOnly?: boolean;
-    onFileUpload?: (file: File) => void;
+export declare interface FileLabelUploadVariables {
+    labelContextId?: string | null;
+    labelContextRequest?: LabelContextCreateRequest;
+    body: FileLabelUploadRequest;
 }
 
-export declare function LabelingFloatingToolbar({ items, show, verticalNav, children, }: LabelingFloatingToolbarProps): JSX_2.Element | null;
+export declare interface FileValue {
+    bucket?: string;
+    objectName?: string;
+    endpoint?: string;
+    fileName?: string;
+    [key: string]: unknown;
+}
 
-declare interface LabelingFloatingToolbarProps {
-    items: ToolbarItem[];
-    show?: boolean;
-    verticalNav?: boolean;
-    children?: ReactNode;
+declare interface FilterState {
+    filter: Record<string, unknown>;
+    setFilter: (patch: Record<string, unknown>) => void;
+    resetFilter: () => void;
 }
 
-export declare function LabelingIcon({ iconType, size, className, style, }: LabelingIconProps): JSX_2.Element | null;
+export declare const getCanvasInstance: () => any;
 
-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';
+/** Idle mutation state (not pending, no error). */
+export declare const IDLE_MUTATION: MutationState;
 
-declare interface LabelingIconProps {
-    iconType: LabelingIconName;
-    size?: IconSize;
-    className?: string;
-    style?: React.CSSProperties;
+declare interface InLabelingStatusResponse {
+    inLabeling: boolean;
 }
 
-export declare function LabelingIndicator({ indicator }: LabelingIndicatorProps): JSX_2.Element | null;
+export declare type LabelAttributeType = "SELECT" | "CHECKBOX" | "TEXT";
 
-declare interface LabelingIndicatorProps {
-    indicator?: WorkspaceIndicator;
+export declare interface LabelBatchUpdateRequest {
+    deletes?: LabelDeleteData[];
+    inserts?: LabelInsertData[];
+    updates?: LabelUpdateData[];
 }
 
-export declare function LabelingInfoPanel({ classes, annotations, selectedAnnotationId, onClassSelect, onAnnotationSelect, onAnnotationDelete, disabled, }: LabelingInfoPanelProps): JSX_2.Element;
-
-declare interface LabelingInfoPanelProps {
-    classes: LabelingClass[];
-    annotations: Annotation[];
-    selectedAnnotationId?: string | null;
-    onClassSelect?: (cls: LabelingClass) => void;
-    onAnnotationSelect?: (annotation: Annotation) => void;
-    onAnnotationDelete?: (annotationId: string) => void;
-    disabled?: boolean;
+export declare interface LabelBatchUpdateResponse {
+    deletedIds?: string[];
+    insertedLabels?: LabelResponse[];
+    updatedLabels?: LabelResponse[];
+    summary?: BatchUpdateSummary;
 }
 
-export declare function LabelingIssuePanel({ annotations, validationResults, selectedAnnotationId, onAnnotationSelect, onValidate, onValidationUpdate: _onValidationUpdate, onValidationDelete, }: LabelingIssuePanelProps): JSX_2.Element;
-
-declare interface LabelingIssuePanelProps {
-    annotations: Annotation[];
-    validationResults: ValidationResult[];
-    selectedAnnotationId?: string | null;
-    onAnnotationSelect?: (annotation: Annotation) => void;
-    onValidate?: (event: ValidateEvent) => void | Promise<void>;
-    onValidationUpdate?: (event: ValidationUpdateEvent) => void | Promise<void>;
-    onValidationDelete?: (event: ValidationDeleteEvent) => void | Promise<void>;
+export declare interface LabelBatchUpdateVariables {
+    labelContextId?: string | null;
+    labelContextRequest?: LabelContextCreateRequest;
+    labelContextUpdateRequest?: LabelContextUpdateRequest;
+    body: LabelBatchUpdateRequest;
 }
 
-export declare function LabelingNavigation({ records, activeRecordId, onRecordSelect, direction, onDirectionChange, hidden, }: LabelingNavigationProps): JSX_2.Element;
-
-declare interface LabelingNavigationProps {
-    records: WorkspaceRecord[];
-    activeRecordId: string;
-    onRecordSelect: (record: WorkspaceRecord) => void;
-    direction?: 'horizontal' | 'vertical';
-    onDirectionChange?: (direction: 'horizontal' | 'vertical') => void;
-    hidden?: boolean;
+export declare interface LabelBulkCreateVariables {
+    labelContextId: string;
+    body: BulkLabelCreateRequest;
 }
 
-/**
- * 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 LabelContextCreateRequest {
+    datasetId: string;
+    datasetVersion: string | number;
+    policyIds: string[];
 }
 
-export declare interface LabelingPolicy {
-    id: string;
-    name: string;
-    classes: LabelingClass[];
+declare interface LabelContextEnableResponse {
+    enable: boolean;
 }
 
-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 | {
-        url: string;
-        width: number;
-        height: number;
-    };
-    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: (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[];
-    indicator?: WorkspaceIndicator;
-    extensions?: LabelingExtension[];
-    tools?: ToolType[];
-    theme?: Partial<LabelingTheme>;
-    layout?: WorkspaceLayout;
-    children: ReactNode;
-}
+export declare interface LabelContextResponse {
+    id: string;
+    datasetId: string;
+    datasetVersion?: string | number;
+    policyIds: string[];
+    enable?: boolean;
+    organizationId?: string;
+    accountId?: string;
+    zoneId?: string;
+    userId?: string;
+    inLabeling?: boolean;
+    isLabeled?: boolean;
+    createdBy?: string;
+    createdDate?: string;
+    modifiedBy?: string;
+    modifiedDate?: string;
+}
+
+export declare interface LabelContextUpdateRequest {
+    policyIds?: string[];
+    inLabeling?: boolean;
+    enable?: boolean;
+}
+
+export declare interface LabelContextUpdateVariables {
+    labelContextId: string;
+    body: LabelContextUpdateRequest;
+}
+
+declare interface LabelCopyRequest {
+    copyType: LabelCopyType;
+    sourcePolicyId?: string;
+    targetPolicyId?: string;
+    targetLabelContextId?: string;
+    targetPolicyIds?: string[];
+    sourceDatasetId?: string;
+    sourceDatasetVersion?: string;
+}
+
+declare interface LabelCopyResponse {
+    copyType?: LabelCopyType;
+    copiedCount?: number;
+    skippedCount?: number;
+    totalProcessedCount?: number;
+    copiedLabelIds?: string[];
+    message?: string;
+    sourcePolicyId?: string;
+    targetPolicyId?: string;
+    targetLabelContextId?: string;
+    sourceDatasetId?: string;
+    sourceDatasetVersion?: string;
+}
+
+declare type LabelCopyType = "POLICY" | "DATASET";
 
-/**
- * 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;
-    surface: string;
-    border: string;
-    text: string;
-    textSecondary: string;
-    hover: string;
-    primaryLight: string;
-    fontFamily: string;
-    radius: number;
-    spacing: {
-        sm: number;
-        md: number;
-        lg: number;
-    };
+export declare interface LabelDeleteData {
+    id: string;
 }
 
-declare interface LabelingTool {
+export declare interface LabelDetailResponse {
     id: string;
-    init: (...args: any[]) => Promise<(() => void) | void | undefined> | (() => void) | void;
+    labelContextId: string;
+    contentId?: string;
+    contentSetId?: string;
+    elementId?: string;
+    policyId: string;
+    schemaName?: string;
+    isLabeled?: boolean;
+    organizationId?: string;
+    accountId?: string;
+    zoneId?: string;
+    userId?: string;
+    autoLabelingInfo?: AutoLabelingInfo;
+    inferenceType?: LabelInferenceType;
+    labelType?: LabelType;
+    unitType?: LabelUnitType;
+    labelValue?: LabelValue;
+    attributeValues?: AttributeValue[];
+    modifiedBy?: string;
+    modifiedDate?: string;
+    createdBy?: string;
+    createdDate?: string;
+}
+
+export declare type LabelInferenceType = "CLASSIFICATION" | "OBJECT_DETECTION" | "SEGMENTATION" | "RECOGNITION";
+
+declare const LABELING_RECORDS_CELL_ACCESSORIES_SYMBOL: unique symbol;
+
+export declare interface LabelingApiHeaders {
+    orgId?: string;
+    zoneId?: string;
+    accountId?: string;
+    userId?: string;
+    userName?: string;
 }
 
 /**
- * Floating toolbar that renders view-mode-aware tools via useLabelingUIMeta.
- * Tool set, icons, and behavior all come from the UIMeta hooks.
+ * Data that the host feeds into the labeling workspace.
+ * Each field mirrors one of the former react-query hooks.
  */
-export declare function LabelingToolbar({ children }: LabelingToolbarInternalProps): JSX_2.Element;
-
-declare interface LabelingToolbarInternalProps {
-    children?: ReactNode;
-}
-
-declare interface LabelingUIMetaResult {
-    toolbar: ToolbarItemMeta[];
+export declare interface LabelingDataContextValue {
+    policiesBatch: AsyncData<PolicyDetail[]>;
+    labelContext: AsyncData<LabelContextResponse>;
+    labelContextStatus: AsyncData<ContentsetStatusResponse>;
+    labelContextInLabeling: AsyncData<InLabelingStatusResponse>;
+    labelContextEnable: AsyncData<LabelContextEnableResponse>;
+    labelSearch: AsyncData<LabelSearchResult>;
+    previousLabelContexts: AsyncData<PreviousLabelContextWithLabelsResponse[]>;
+    validResultSearch: AsyncData<ValidResultSearchResult>;
+}
+
+export declare interface LabelingDatasetCellReference {
+    datasetId: string;
+    version: string;
+    contentSetId: string;
+    schemaNames: string[];
+    schemaLabel: string;
+    contentType: string;
+    isRequired: boolean;
+    maxItems: number | string | null;
+    showIntProps?: boolean;
 }
 
 /**
- * Level 1: All-in-one labeling workspace.
- * Renders WorkspaceControl + Navigation + WorkspaceSection + FloatingToolbar + InfoPanel.
+ * Dataset-related data the host feeds into the labeling workspace.
+ * Separated from LabelingDataContext because it changes at a different
+ * frequency (on record selection vs. on every label operation).
  */
-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;
-        width: number;
-        height: number;
-    };
-    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: (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;
+export declare interface LabelingDatasetContextValue {
+    datasetDetail: AsyncData<DatasetDTO>;
+    datasetContents: AsyncData<DatasetApiResponse<DatasetContentSearchResponse>>;
+    datasetContentDetail: AsyncData<DatasetContentRecord | null>;
 }
 
 /**
- * View-mode switching container.
- * Shows the appropriate content section based on the current view mode.
+ * A pluggable extension that the host registers to add optional
+ * features (e.g. SAM, Automated Labeling) to the labeling workspace.
+ *
+ * The library provides render slots only — the host owns all UI and logic.
  */
-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 {
+export declare interface LabelingExtension {
+    /** Unique identifier for this extension. */
     id: string;
+    /** Human-readable name. */
+    name: string;
+    /** Set to false to disable the extension without removing it. */
+    enabled?: boolean;
+    /**
+     * Renders action buttons / sections inside the InfoPanel.
+     * The returned node is placed at the bottom of the InfoPanel, after the
+     * label lists and before the issue panel toggle.
+     */
+    renderInfoPanelAction?: (ctx: ExtensionRenderContext) => ReactNode;
+    /**
+     * Renders a floating overlay on top of the workspace (e.g. a modal).
+     * Rendered at the root level so it can use portals / z-index freely.
+     */
+    renderOverlay?: (ctx: ExtensionRenderContext) => ReactNode;
+    /**
+     * Renders an additional tool button in the floating toolbar.
+     * Use this for canvas-based tools (e.g. SAM point/box input).
+     */
+    renderToolbarAction?: (ctx: ExtensionRenderContext) => ReactNode;
+}
+
+export declare interface LabelingMutationContextValue {
+    batchUpdateLabels: (vars: LabelBatchUpdateVariables) => Promise<LabelBatchUpdateResponse>;
+    batchUpdateLabelsState: MutationState;
+    bulkCreateLabels: (vars: LabelBulkCreateVariables) => Promise<BulkLabelCreateResponse>;
+    bulkCreateLabelsState: MutationState;
+    createLabelContext: (body: LabelContextCreateRequest) => Promise<LabelContextResponse>;
+    createLabelContextState: MutationState;
+    updateLabelContext: (vars: LabelContextUpdateVariables) => Promise<LabelContextResponse>;
+    updateLabelContextState: MutationState;
+    createLabelStatus: (body: LabelStatusCreateRequest) => Promise<ApiResponse<LabelStatusResponse>>;
+    createLabelStatusState: MutationState;
+    uploadFileLabel: (vars: FileLabelUploadVariables) => Promise<LabelResponse>;
+    uploadFileLabelState: MutationState;
+    copyLabels: (body: LabelCopyRequest) => Promise<LabelCopyResponse>;
+    copyLabelsState: MutationState;
+    createValidResult: (body: ValidResultCreateRequest) => Promise<ValidResultResponse>;
+    createValidResultState: MutationState;
+    updateValidResult: (vars: ValidResultUpdateVariables) => Promise<ValidResultResponse>;
+    updateValidResultState: MutationState;
+    bulkDeleteValidResults: (body: ValidResultBulkDeleteRequest) => Promise<ValidResultBulkDeleteResponse>;
+    bulkDeleteValidResultsState: MutationState;
+    /**
+     * Called by the library after a successful mutation.
+     * The host should use the hint to invalidate / refetch the right caches.
+     */
+    onMutationSuccess: (hint: MutationSuccessHint) => void;
 }
 
-declare interface LabelVisibilityState {
-    hiddenClassificationIds: Record<string, boolean>;
-    setClassificationVisibility: (labelId: string, hidden: boolean) => void;
-    reset: () => void;
-}
-
-export declare const LAYER_MODE: Record<string, LayerMode>;
-
-declare type LayerMode = [number, number] | [number];
+/**
+ * Composite provider that wraps the three labeling contexts.
+ *
+ * Usage (host app):
+ * ```tsx
+ * <LabelingProviders data={dataCtx} mutations={mutationCtx} dataset={datasetCtx}>
+ *   <LabelingWorkspace />
+ * </LabelingProviders>
+ * ```
+ */
+export declare function LabelingProviders({ data, mutations, dataset, children, }: LabelingProvidersProps): JSX_2.Element;
 
-declare interface LayerModeState {
-    mode: LayerMode;
-    setMode: (mode: LayerMode) => void;
-    cycleMode: () => void;
+export declare interface LabelingProvidersProps {
+    data: LabelingDataContextValue;
+    mutations: LabelingMutationContextValue;
+    dataset: LabelingDatasetContextValue;
+    children: React.ReactNode;
 }
 
-declare type LayoutDirection = 'horizontal' | 'vertical';
-
-export declare const loadFabric: () => Promise<fabric>;
-
-export declare const magicbrushTool: () => LabelingTool;
-
-export declare interface NavigationCellAccessories {
-    badges?: NavigationCellBadge[];
+declare interface LabelingRecordsCellAccessories {
+    badges?: LabelingRecordsCellBadge[];
     hasIssue?: boolean;
     hasValidationCompleted?: boolean;
 }
 
-export declare interface NavigationCellBadge {
+declare type LabelingRecordsCellAccessoriesMap = Record<string, LabelingRecordsCellAccessories>;
+
+declare interface LabelingRecordsCellBadge {
     title: string;
-    style: 'primary-light' | 'secondary-light';
+    style: BadgeStyle;
 }
 
-export declare interface NavigationDetailData {
-    rows: Record<string, unknown>[];
-    columns?: string[];
+export declare interface LabelingRecordSelection {
+    datasetId: string | null;
+    record: DatasetContentRecord;
+    displayRow: LabelingRecordsTableRow;
+    schemaEntries: LabelingSchemaEntry[];
+    schemaNameToContentType: Record<string, string>;
+    accessories?: LabelingRecordsCellAccessoriesMap;
+    detailReference?: LabelingDatasetCellReference;
+    rowIndex: number;
+    rowId: string;
 }
 
-export declare interface NavigationSchema {
+declare type LabelingRecordsTableRow = VirtualizedRecordsTableRow & {
+    [LABELING_RECORDS_CELL_ACCESSORIES_SYMBOL]?: LabelingRecordsCellAccessoriesMap;
+};
+
+export declare interface LabelingSchemaEntry {
     label: string;
+    summaryKeys: string[];
+    detailSchemaNames: string[];
     contentType: string;
     isRequired: boolean;
-    maxItems?: number | null;
+    maxItems: number | string | null;
+    schema?: SchemaItemDTO;
 }
 
-export declare interface NumberContent {
-    mode?: 'line' | 'bar';
-    xAxis?: {
-        label: string;
-        ticks: unknown[];
-    };
-    yAxis?: {
-        label: string;
-        series: unknown[];
-    };
-    source: {
-        columns: string[] | Array<{
-            key: string;
-            label: string;
-        }>;
-        rows: unknown[][] | Array<Record<string, unknown>>;
-    };
-    canRender?: boolean;
-    segments?: Array<{
-        id: string;
-        start: number;
-        end: number;
-        color: string;
-        opacity?: number;
-    }>;
-}
-
-declare interface NumberLabelingTool {
-    id: 'selection' | 'drag-segment';
-    label: string;
-}
+export declare function LabelingWorkspace({ extensions, }: LabelingWorkspaceProps): JSX_2.Element;
 
-declare interface NumberSegmentSelection {
-    key: string;
-    labelId: string | null;
-    tempId: string | null;
-    start: number;
-    end: number;
-    color?: string;
-    opacity?: number;
+export declare interface LabelingWorkspaceProps {
+    extensions?: LabelingExtension[];
 }
 
-declare interface NumberSegmentSelectionState {
-    selectedSegment: NumberSegmentSelection | null;
-    setSelectedSegment: (segment: NumberSegmentSelection | null) => void;
+export declare interface LabelInsertData {
+    contentSetId?: string;
+    elementId?: string;
+    policyId: string;
+    schemaName?: string;
+    inferenceType?: LabelInferenceType;
+    /**
+     * labelType 설명
+     * inferenceType classification 전용
+     * 파일 업로드 기반 라벨 > FILE
+     * 차트(Number) 기반 라벨 > TABLE
+     * 그외 타입의 엘레멘트 단위 or 레코드 단위 라벨 > 사용 안함
+     */
+    labelType?: LabelType;
+    /**
+     * unitType 설명
+     * 엘레멘트 단위 > ELEMENT
+     * 레코드 단위 > CONTENTSET
+     */
+    unitType?: LabelUnitType;
+    labelValue?: LabelValue;
+    attributeValues?: AttributeValue[];
+    isLabeled?: boolean;
+}
+
+declare type LabelOrderDirection = "ASC" | "DESC" | "asc" | "desc";
+
+export declare interface LabelResponse extends LabelDetailResponse {
+    version: DatasetContentVersion;
+}
+
+export declare interface LabelSearchRequest {
+    labelContextId: SearchOperatorFilter<string>;
+    contentSetId?: SearchOperatorFilter<string>;
+    elementId?: SearchOperatorFilter<string>;
+    unitType?: SearchOperatorFilter<LabelUnitType>;
+    orderBy?: Record<string, LabelOrderDirection>;
+    pageNumber?: number;
+    pageSize?: number;
+}
+
+export declare type LabelSearchResult = CustomPageWrapper<LabelDetailResponse, LabelSearchRequest>;
+
+declare interface LabelStatusCreateRequest {
+    labelContextId: string;
+    contentSetId: string;
+    elementId: string;
+    isLabeling?: boolean;
 }
 
-declare interface NumberToolState {
-    tool: NumberLabelingTool | null;
-    setTool: (tool: NumberLabelingTool | null) => void;
+declare interface LabelStatusResponse {
+    id: string;
+    labelContextId: string;
+    contentSetId: string;
+    elementId: string;
+    isLabeling?: boolean;
+    organizationId?: string;
+    accountId?: string;
+    zoneId?: string;
+    userId?: string;
+    createdBy?: string;
+    createdDate?: string;
 }
 
-export declare type NumberToolType = 'selection' | 'drag-segment';
+export declare type LabelType = "FILE" | "TABLE";
 
-declare interface OpacityState {
-    opacity: number;
-    setOpacity: (opacity: number) => void;
-}
+export declare type LabelUnitType = "CONTENTSET" | "ELEMENT";
 
-declare interface PaletteState {
-    colorCode: string;
-    setColorCode: (colorCode: string) => void;
+export declare interface LabelUpdateData extends LabelInsertData {
+    id: string;
 }
 
-export declare interface PolygonGeometry {
-    type: 'polygon';
-    /** Normalized vertex coordinates */
-    points: Array<{
-        x: number;
-        y: number;
-    }>;
-}
+export declare type LabelValue = ClassificationValue | BoxValue | SegmentationResponseValue | SegmentationBase64Value | ChartValue | RecognitionValue | FileValue | unknown;
 
-export declare const polygonTool: () => LabelingTool;
+/** A loading-state placeholder. */
+export declare function loadingData<T>(): AsyncData<T>;
 
-export declare interface RecognitionGeometry {
-    type: 'recognition';
-    start: number;
-    end: number;
-    text?: string;
+/**
+ * Mutation state — tracks the status of a single mutation call.
+ */
+export declare interface MutationState {
+    isPending: boolean;
+    isError: boolean;
+    error: unknown;
 }
 
-export declare type RecordStatus = 'unlabeled' | 'labeled' | 'validated' | 'issue';
-
-export declare const renderAllSafe: (targetCanvas?: FabricCanvas) => void;
+/**
+ * Hint the library sends to the host after a successful mutation so
+ * the host can invalidate / refetch the appropriate caches.
+ */
+export declare type MutationSuccessHint = {
+    type: "labels-saved";
+    labelContextId: string | null;
+} | {
+    type: "labels-copied";
+} | {
+    type: "labels-bulk-created";
+    labelContextId: string;
+} | {
+    type: "label-context-created";
+    labelContextId: string;
+} | {
+    type: "label-context-updated";
+    labelContextId: string;
+} | {
+    type: "label-status-created";
+} | {
+    type: "valid-result-created";
+} | {
+    type: "valid-result-updated";
+} | {
+    type: "valid-results-deleted";
+} | {
+    type: "file-uploaded";
+    labelContextId: string;
+};
 
-export declare interface SavePayload {
-    viewMode: WorkspaceViewMode;
-    inserts: LabelInsertData[];
-    updates: LabelUpdateData[];
-    deletes: LabelDeleteData[];
-    canvasJSON?: object;
-    imageSize?: {
-        width: number;
-        height: number;
-    };
+export declare interface PolicyClass {
+    name: string;
+    color: string;
+    opacity?: number;
+    index?: number;
+    attributes?: Attribute[] | null;
 }
 
-export declare interface SaveToRecordPayload {
-    contentSetId: string;
-    labels: LabelInsertData[];
+export declare interface PolicyDetail {
+    id: string;
+    basePolicyId: string;
+    version: string;
+    baseVersion: string;
+    name: string;
+    exist: boolean;
+    classes: PolicyClass[];
+    elements?: string[];
+    tags?: string[];
+    versions: Version[];
+    zoneId: string;
+    organizationId: string;
+    accountId: string;
+    userId: string;
+    createdBy: string;
+    createdDate: string;
+    modifiedBy: string;
+    modifiedDate: string;
+    copyLabel?: boolean;
+}
+
+declare interface PolicyLabelStatus {
+    policyId?: string;
+    labelId?: string;
+    status?: ContentsetStatusState[];
+    hasValidationError?: boolean;
+}
+
+declare interface PreviousLabelContextWithLabelsResponse {
+    id: string;
+    datasetId: string;
+    datasetVersion: string;
+    policyIds: string[];
+    createdBy?: string;
+    createdDate?: string;
+    modifiedBy?: string;
+    modifiedDate?: string;
 }
 
-export declare interface SaveValidationPayload {
-    result: boolean;
-    reason?: string;
-    labelIds: string[];
+export declare interface RecognitionValue {
+    className?: string;
+    classIndex?: number;
+    start?: number;
+    end?: number;
+    text?: string;
+    color?: string;
+    opacity?: number;
+    zindex?: number;
 }
 
-export declare const segmentAnythingTool: () => LabelingTool;
-
-export declare interface SegmentationGeometry {
-    type: 'segmentation';
-    /** Base64 PNG mask */
-    mask: string;
-    /** Fabric object vector for restoration (optional) */
-    vector?: string;
-}
+/**
+ * Remove fabric objects matching a predicate from the canvas.
+ * Extensions call this to clean up their objects.
+ */
+export declare function removeCanvasObjects(predicate: (obj: unknown) => boolean): void;
 
-declare interface SelectedClassificationInfo {
-    policyId?: string | null;
-    classIndex?: number | null;
-    className?: string | null;
-    labelId?: string | null;
-    tempId?: string | null;
-    isCanvasFocused?: boolean;
+export declare interface SchemaItemDTO {
+    baseInfo: BaseInfoDTO;
+    properties: Record<string, unknown>;
 }
 
-declare interface SelectedObjectsState {
-    objects: LabeledFabricObject[];
-    setObjects: (objects: LabeledFabricObject[]) => void;
+declare interface SchemaStatus {
+    name?: string;
+    totalCount?: number;
+    elements?: ElementStatus[];
 }
 
-export declare const selectionTool: () => LabelingTool;
-
-export declare const setCanvasInstance: (instance: FabricCanvas | null) => void;
-
-export declare const setMagicBrushModule: (module: any) => void;
-
-export declare const setSuperpixelModules: (modules: {
-    SLIC: any;
-    MagicBrush: any;
-}) => void;
-
-export declare const subscribeLabelEvents: (listener: LabelEventListener) => () => void;
-
-export declare const superpixelTool: () => LabelingTool;
-
-declare interface TemporalHistoryState<T> {
-    snapshot: T | null;
-    setSnapshot: (snapshot: T) => void;
-    reset: () => void;
+declare interface Score {
+    className?: string;
+    score?: number;
+    [key: string]: unknown;
 }
 
-declare interface TextAutoHighlightState {
-    english: boolean;
-    number: boolean;
-    special: boolean;
-    setEnglish: (value: boolean) => void;
-    setNumber: (value: boolean) => void;
-    setSpecial: (value: boolean) => void;
-    reset: () => void;
+declare interface SearchOperatorFilter<TValue> {
+    operator: string;
+    value: TValue;
 }
 
-export declare interface TextContent {
-    /** The text string to display. Use `text` or `value`. */
-    text?: string;
-    /** @deprecated Use `text` instead */
-    value?: string;
-    elementId?: string;
-    segments?: Array<{
-        id: string;
-        start: number;
-        end: number;
-        label?: string;
-        color: string;
-        opacity?: number;
-    }>;
-}
-
-declare interface TextLabelingTool {
-    id: 'selection' | 'drag-segment';
-    label: string;
+export declare interface SegmentationBase64Value {
+    className?: string;
+    classIndex?: number;
+    segColor?: string;
+    segOrder?: number;
+    segOpacity?: number;
+    segBuffer: string;
+    segVector?: string;
+    segContentType?: string;
 }
 
-declare interface TextSegmentSelection {
-    key: string;
-    labelId: string | null;
-    tempId: string | null;
-    start: number;
-    end: number;
-    text: string;
+export declare interface SegmentationResponseValue {
+    className?: string;
+    classIndex?: number;
+    bucket?: string;
+    objectName?: string;
+    endpoint?: string;
+    segVector?: string;
+    segColor?: string;
+    segOrder?: number;
+    segOpacity?: number;
     color?: string;
     opacity?: number;
+    zindex?: number;
 }
 
-declare interface TextSegmentSelectionState {
-    selectedSegment: TextSegmentSelection | null;
-    setSelectedSegment: (segment: TextSegmentSelection | null) => void;
-}
+/** Wrap an already-resolved value as AsyncData (no loading, no error). */
+export declare function staticData<T>(data: T): AsyncData<T>;
 
-declare interface TextToolState {
-    tool: TextLabelingTool | null;
-    setTool: (tool: TextLabelingTool | null) => void;
+declare interface UIType<TSize extends string = "xs" | "sm" | "md" | "lg" | "xl", TStyle extends string = string> {
+    size?: TSize;
+    style?: TStyle;
 }
 
-export declare type TextToolType = 'selection' | 'drag-segment';
-
-export declare const toHex: (color: string) => {
-    hex: string;
-    alpha: string;
-};
-
-export declare const TOOL_INFO_BOUNDED_BOX = "Bounded Box";
-
-export declare const TOOL_INFO_BRUSH = "Brush";
-
-export declare const TOOL_INFO_COMBINED_LABELS = "Combined Label";
-
-export declare const TOOL_INFO_ERASER = "Eraser";
+export declare const useFilterStore: UseBoundStore<StoreApi<FilterState>>;
 
-export declare const TOOL_INFO_FILLED_BOX = "Filled Box";
+export declare const useWorkspaceNavigationDetailSelectionStore: UseBoundStore<StoreApi<WorkspaceNavigationDetailSelectionState>>;
 
-export declare const TOOL_INFO_FILLED_POLYGON = "Filled Polygon";
-
-export declare const TOOL_INFO_MAGIC_BRUSH = "Magic Brush";
-
-export declare const TOOL_INFO_SUPERPIXEL = "Superpixel";
-
-export declare interface ToolbarButtonItem {
-    variant: 'button';
-    id?: string;
-    icon?: ReactNode;
-    title?: string;
-    tooltip?: string;
-    disabled?: boolean;
-    active?: boolean;
-    slim?: boolean;
-    onClick?: () => void;
-    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[];
+declare interface ValidResultBulkDeleteRequest {
+    validResultIds: string[];
 }
 
-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;
+declare interface ValidResultBulkDeleteResponse {
+    deletedIds: string[];
+    failedIds: string[];
+    successCount: number;
+    failureCount: number;
+    totalCount: number;
 }
 
-export declare interface ToolbarDividerItem {
-    variant: 'divider';
-}
-
-declare interface ToolbarDividerItemMeta {
-    variant: 'divider';
+export declare interface ValidResultCreateRequest {
+    labelContextId: string;
+    datasetId: string;
+    datasetVersion: string;
+    contentSetId: string;
+    elementId?: string;
+    policyId?: string;
+    labelId?: string;
+    result: boolean;
+    reason?: string;
+    validType: ValidType;
 }
 
-export declare type ToolbarItem = ToolbarButtonItem | ToolbarRadioItem | ToolbarCheckboxItem | ToolbarDividerItem;
-
-declare type ToolbarItemMeta = ToolbarRadioItemMeta | ToolbarButtonItemMeta | ToolbarCheckboxItemMeta | ToolbarDividerItemMeta;
-
-export declare interface ToolbarRadioItem {
-    variant: 'radio';
+export declare interface ValidResultResponse {
     id: string;
-    name: string;
-    icon?: ReactNode;
-    title?: string;
-    disabled?: boolean;
-    checked?: boolean;
-    onClick?: () => void;
+    labelContextId: string;
+    datasetId: string;
+    datasetVersion: string;
+    contentSetId: string;
+    elementId?: string;
+    policyId?: string;
+    labelId?: string;
+    result: boolean;
+    reason?: string;
+    validType: ValidType;
+    validatedDate?: string;
+    organizationId?: string;
+    accountId?: string;
+    zoneId?: string;
+    userId?: string;
+    modifiedBy?: string;
+    modifiedDate?: string;
+    createdBy?: string;
+    createdDate?: string;
+}
+
+declare interface ValidResultSearchRequest {
+    orderBy?: Record<string, LabelOrderDirection>;
+    pageNumber?: number;
+    pageSize?: number;
+    labelContextId?: SearchOperatorFilter<string>;
+    contentSetId?: SearchOperatorFilter<string>;
+    elementId?: SearchOperatorFilter<string>;
+    policyId?: SearchOperatorFilter<string>;
+    validType?: SearchOperatorFilter<ValidType>;
+}
+
+declare type ValidResultSearchResult = CustomPageWrapper<ValidResultResponse, ValidResultSearchRequest>;
+
+export declare interface ValidResultUpdateRequest {
+    result?: boolean;
+    reason?: string;
+    validType?: ValidType;
 }
 
-declare interface ToolbarRadioItemMeta {
-    variant: 'radio';
+export declare interface ValidResultUpdateVariables {
     id: string;
-    name: string;
-    icon: ReactNode;
-    title: string;
-    checked: boolean;
-    disabled?: boolean;
-    isSlim?: boolean;
-    onClick: () => void;
-    subButtonItems?: ToolbarItemMeta[];
+    body: ValidResultUpdateRequest;
 }
 
-export declare type ToolbarSection = 'tools' | 'brush' | 'palette' | 'zoom' | 'history' | 'layers' | 'viewMode' | 'validation' | 'navigation' | 'save';
-
-export declare interface ToolExtension extends LabelingExtension {
-    slot: 'tool';
-    icon: ReactNode;
-    label: string;
-    shortcut?: string;
-    canvasHandlers?: {
-        onMouseDown?: (e: CanvasPointerEvent) => void;
-        onMouseMove?: (e: CanvasPointerEvent) => void;
-        onMouseUp?: (e: CanvasPointerEvent) => void;
-    };
-}
-
-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;
-}
+export declare type ValidType = "CONTENTSET" | "ELEMENT" | "LABEL";
 
-declare interface ToolSelectionState {
-    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;
+declare interface Version {
+    id: string;
+    version: string;
+    classCount: number;
+    elementCount: number;
+    createdBy?: string;
+    createdDate?: string;
+    modifiedBy?: string;
+    modifiedDate?: string;
 }
 
-export declare type ToolType = 'selection' | 'brush' | 'blankRect' | 'filledRect' | 'polygon' | 'eraser' | 'magicbrush' | 'superpixel' | 'segAnything';
-
-export declare const toRgba: (hex: string, opacity: number) => string;
-
-export declare const toRgbaArray: (rgba: string) => number[];
-
-export declare const toRGBAHex: (rgba: string) => string;
-
-/**
- * Set black pixels transparent and apply opacity to non-black pixels.
- */
-export declare const transparentBlackPixel: (imageData: ImageData, opacity: number) => ImageData;
-
-export declare const useBrushStore: UseBoundStore<StoreApi<BrushState>>;
-
-export declare const useCanvasObjectsStore: UseBoundStore<StoreApi<CanvasObjectsState>>;
-
-/**
- * Manages extension lifecycle — provides the ExtensionContext
- * and hooks up ToolExtension canvas handlers.
- */
-export declare function useExtensions(options: UseExtensionsOptions): {
-    context: ExtensionContext;
-    toolExtensions: ToolExtension[];
-    sidePanelExtensions: LabelingExtension[];
-    toolbarExtensions: LabelingExtension[];
-    activeToolExtension: ToolExtension | undefined;
-};
-
-declare interface UseExtensionsOptions {
-    extensions: LabelingExtension[];
-    image: {
-        url: string;
-        width: number;
-        height: number;
-    };
-    annotations: Annotation[];
-    selectedIds: string[];
-    activeTool: string;
-    addAnnotations: (annotations: Annotation[]) => void;
-    updateAnnotation: (id: string, annotation: Partial<Annotation>) => void;
-    removeAnnotations: (ids: string[]) => void;
-    setTool: (tool: string) => void;
+export declare interface VersionDTO {
+    version: string | null;
+    versionedDate: string;
+    versionRecords: string;
 }
 
-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.
- *
- * Provides low-level canvas operations: add/remove objects,
- * export state, zoom control, etc.
- */
-export declare function useLabelingCanvas(): {
-    objects: LabeledFabricObject[];
-    zoom: number;
-    getAnnotations: (imageWidth: number, imageHeight: number) => Promise<Annotation[]>;
-    addAnnotation: (annotation: Annotation, imageWidth: number, imageHeight: number) => Promise<void>;
-    removeAnnotation: (annotationId: string) => void;
-    clearCanvas: () => void;
-    exportState: (imageWidth: number, imageHeight: number) => Promise<CanvasState_2>;
-    setZoomLevel: (level: number) => void;
-};
-
-export declare function useLabelingContext(): LabelingContextValue;
-
-/**
- * Level 3 headless hook — Canvas undo/redo history.
- *
- * Uses the tool store's undo/redo stacks (JSON snapshots).
- */
-export declare function useLabelingHistory(): {
-    canUndo: boolean;
-    canRedo: boolean;
-    undo: () => Promise<void>;
-    redo: () => Promise<void>;
-    pushSnapshot: () => void;
-    clear: () => void;
-};
-
-/**
- * Level 3 headless hook — Tool selection and palette state.
- *
- * Returns current tool, setTool, and palette/brush/opacity state with setters.
- */
-export declare function useLabelingTools(): {
-    activeToolId: string | null;
-    currentTool: LabelingTool | null;
-    setTool: (toolType: ToolType) => void;
-    clearTool: () => void;
-    colorCode: string;
-    setColorCode: (colorCode: string) => void;
-    opacity: number;
-    setOpacity: (opacity: number) => void;
-    brush: {
-        id: number;
-        lineCap: string;
-        lineWidth: number;
-    };
-    setBrush: (brush: {
-        id: number;
-        lineCap: string;
-        lineWidth: number;
-    }) => 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 VIRTUALIZED_RECORDS_ROW_META_SYMBOL: unique symbol;
 
-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, canvasReady?: boolean): {
-    activeToolId: string | null;
+declare type VirtualizedRecordsTableRow = Record<string, VirtualizedRowCellValue> & {
+    [VIRTUALIZED_RECORDS_ROW_META_SYMBOL]?: VirtualizedRowMeta;
 };
 
-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 {
-    annotationIds: string[];
-    result: boolean;
-    reason?: string;
-}
-
-export declare interface ValidationDeleteEvent {
-    ids: string[];
-}
-
-declare interface ValidationModeState {
-    isValidationMode: boolean;
-    setValidationMode: (value: boolean) => void;
-    toggleValidationMode: () => void;
-}
+declare type VirtualizedRowCellValue = string | number;
 
-export declare interface ValidationResult {
-    id: string;
-    annotationId?: string;
-    result: boolean;
-    reason?: string;
-    validatedAt?: string;
+declare interface VirtualizedRowMeta {
+    columnRefs: Record<string, unknown>;
+    rowRef?: unknown;
+    rowId?: string;
 }
 
-export declare interface ValidationUpdateEvent {
-    id: string;
-    result?: boolean;
-    reason?: string;
-}
+declare const WORKSPACE_CHART_PIVOT_MODE: {
+    readonly ROW_AS_X: "ROW_AS_X";
+    readonly COLUMN_AS_X: "COLUMN_AS_X";
+};
 
-declare interface ViewModeState {
-    mode: WorkspaceViewMode;
-    setMode: (mode: WorkspaceViewMode) => void;
+/** Information about the currently displayed image in the workspace. */
+export declare interface WorkspaceImageInfo {
+    url: string;
+    width: number;
+    height: number;
 }
 
-export declare const WORKSPACE_VIEW_MODES: readonly ["Record", "Image", "Text", "Number", "File"];
-
-export declare interface WorkspaceIndicator {
-    title: string;
-    subtitle?: string;
-    detail?: string;
-    progress?: {
-        current: number;
-        total: number;
+declare interface WorkspaceNavigationChartAxisSnapshot {
+    mode: ChartPivotMode;
+    canRender: boolean;
+    xAxis: {
+        label: string;
+        ticks: WorkspaceNavigationChartAxisTick[];
+    };
+    yAxis: {
+        label: string;
+        series: WorkspaceNavigationChartSeries[];
+    };
+    source: {
+        rows: number[];
+        columns: string[];
     };
 }
 
-export declare interface WorkspaceLayout {
-    navigation?: 'left' | 'bottom' | 'hidden';
-    toolbar?: 'top' | 'bottom';
-}
-
-declare interface WorkspaceLayoutState {
-    direction: LayoutDirection;
-    active: boolean;
-    setDirection: (direction: LayoutDirection) => void;
-    setActive: (active: boolean) => void;
-    toggleActive: () => void;
+declare interface WorkspaceNavigationChartAxisTick {
+    key: number | string;
+    label: string;
+    rowIndex?: number;
+    columnId?: string;
 }
 
-export declare type WorkspaceMode = 'labeling' | 'validation' | 'readonly';
-
-export declare interface WorkspaceRecord {
+declare interface WorkspaceNavigationChartSeries {
     id: string;
-    title: string;
-    thumbnail?: string;
-    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;
-    point?: {
-        x: number;
-        y: number;
-    };
-    onChange: (payload: {
-        level: number;
-        width: number;
-        height: number;
-    }) => void;
-}
-
-declare interface ZoomState {
-    level: number;
-    width: number;
-    height: number;
-    setZoom: (payload: {
-        level: number;
-        width: number;
-        height: number;
+    label: string;
+    values: Array<number | null>;
+    points: WorkspaceNavigationChartSeriesPoint[];
+}
+
+declare interface WorkspaceNavigationChartSeriesPoint {
+    axisKey: number | string;
+    rowIndex: number;
+    columnId: string;
+    elementId: string | null;
+    value: number | null;
+    rawValue: string | null;
+}
+
+declare interface WorkspaceNavigationDetailContext {
+    columns: string[];
+    rows: DetailTableRow[];
+    recordName: string | null;
+    columnName: string | null;
+    contentType: string | null;
+    contentSetId: string | null;
+    schemaName: string | null;
+    /**
+     * @deprecated Use contentSetId.
+     */
+    contentsetId?: string | null;
+    elementId: string | null;
+}
+
+declare interface WorkspaceNavigationDetailSelectionState extends WorkspaceNavigationDetailContext {
+    activeRowId: string | null;
+    selectedRows: number[];
+    selectedColumns: string[];
+    selectedCells: DetailTableCellSelection[];
+    chartPivotMode: ChartPivotMode;
+    chartAxisSnapshot: WorkspaceNavigationChartAxisSnapshot;
+    detailContextResetKey: number;
+    setChartPivotMode: (mode: ChartPivotMode) => void;
+    toggleChartPivotMode: () => void;
+    setContext: (context: WorkspaceNavigationDetailContext | null) => void;
+    setActiveRowId: (rowId: string | null) => void;
+    setSelectionSnapshot: (payload: Partial<WorkspaceNavigationDetailContext> & {
+        selectedRows?: number[];
+        selectedColumns?: string[];
+        selectedCells?: DetailTableCellSelection[];
     }) => void;
-    reset: () => void;
+    incrementDetailContextKey: () => void;
+    toggleRowSelection: (rowIndex: number) => void;
+    toggleColumnSelection: (columnId: string) => void;
+    toggleCellSelection: (rowIndex: number, columnId: string) => void;
+    clearSelection: () => void;
 }
 
 export { }