@cornerstonejs/tools 0.1.4 → 0.2.0

package/dist/tools.d.ts

@@ -6,8 +6,8 @@ import type { vtkVolume } from 'vtk.js/Sources/Rendering/Core/Volume';
 
 declare namespace activeSegmentation {
     export {
-        getActiveSegmentationInfo,
-        setActiveSegmentation
+        getActiveSegmentationRepresentation,
+        setActiveSegmentationRepresentation
     }
 }
 
@@ -25,15 +25,17 @@ declare type ActorEntry = {
 
 declare function addAnnotation(element: HTMLElement, annotation: Annotation): void;
 
-declare function addColorLUT(colorLut: ColorLUT, index: number): void;
+declare function addColorLUT(colorLut: ColorLut, index: number): void;
 
-declare function addColorLUT_2(colorLUT: ColorLUT, colorLUTIndex: number): void;
+declare function addColorLUT_2(colorLUT: ColorLut, colorLUTIndex: number): void;
 
-declare function addGlobalSegmentationData(segmentationData: GlobalSegmentationData, suppressEvents?: boolean): void;
+declare function addSegmentation(segmentationInput: SegmentationPublicInput, suppressEvents?: boolean): void;
 
-declare function addSegmentationData(toolGroupId: string, segmentationData: ToolGroupSpecificSegmentationData, suppressEvents?: boolean): void;
+declare function addSegmentationRepresentation(toolGroupId: string, segmentationRepresentation: ToolGroupSpecificRepresentation, suppressEvents?: boolean): void;
 
-declare function addSegmentationsForToolGroup(toolGroupId: string, segmentationDataArray: SegmentationDataInput[], toolGroupSpecificConfig?: SegmentationConfig): Promise<void>;
+declare function addSegmentationRepresentations(toolGroupId: string, representationInputArray: RepresentationPublicInput[], toolGroupSpecificRepresentationConfig?: SegmentationRepresentationConfig): Promise<void>;
+
+declare function addSegmentations(segmentationInputArray: SegmentationPublicInput[]): void;
 
 export declare function addTool(ToolClass: any): void;
 
@@ -319,7 +321,7 @@ export declare class CircleScissorsTool extends BaseTool {
         annotation: any;
         segmentation: any;
         segmentIndex: number;
-        segmentationDataUID: string;
+        segmentationId: string;
         segmentsLocked: number[];
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];
@@ -344,7 +346,7 @@ declare function clip(a: any, b: any, box: any, da?: any, db?: any): 0 | 1;
 
 declare type Color = [number, number, number, number];
 
-declare type ColorLUT = Array<Color>;
+declare type ColorLut = Array<Color>;
 
 declare namespace config {
     export {
@@ -357,6 +359,15 @@ declare namespace config {
     }
 }
 
+declare namespace CONSTANTS {
+    export {
+        CORNERSTONE_COLOR_LUT as COLOR_LUT
+    }
+}
+export { CONSTANTS }
+
+declare const CORNERSTONE_COLOR_LUT: number[][];
+
 declare interface CPUFallbackColormap {
     /** Get id of colormap */
     getId: () => string
@@ -708,7 +719,7 @@ declare function destroy_3(): void;
 
 declare function destroySynchronizerById(synchronizerId: string): void;
 
-declare function destroyToolGroupByToolGroupId(toolGroupId: string): void;
+declare function destroyToolGroupById(toolGroupId: string): void;
 
 declare function distanceToPoint(lineStart: Types_2.Point2, lineEnd: Types_2.Point2, point: Types_2.Point2): number;
 
@@ -886,6 +897,17 @@ export declare const Enums: {
     SegmentationRepresentations: typeof SegmentationRepresentations;
 };
 
+declare namespace Enums_2 {
+    export {
+        MouseBindings,
+        KeyboardBindings,
+        ToolModes,
+        AnnotationStyleStates,
+        Events,
+        SegmentationRepresentations
+    }
+}
+
 declare enum Events {
     ANNOTATION_ADDED = "CORNERSTONE_TOOLS_ANNOTATION_ADDED",
     ANNOTATION_MODIFIED = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED",
@@ -893,9 +915,10 @@ declare enum Events {
     ANNOTATION_SELECTION_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_SELECTION_CHANGE",
     ANNOTATION_LOCK_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE",
     ANNOTATION_RENDERED = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED",
+    SEGMENTATION_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_MODIFIED",
     SEGMENTATION_RENDERED = "CORNERSTONE_TOOLS_SEGMENTATION_RENDERED",
-    SEGMENTATION_STATE_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_STATE_MODIFIED",
-    SEGMENTATION_GLOBAL_STATE_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_GLOBAL_STATE_MODIFIED",
+    SEGMENTATION_REPRESENTATION_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_MODIFIED",
+    SEGMENTATION_REPRESENTATION_REMOVED = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_REMOVED",
     SEGMENTATION_DATA_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_DATA_MODIFIED",
     KEY_DOWN = "CORNERSTONE_TOOLS_KEY_DOWN",
     KEY_UP = "CORNERSTONE_TOOLS_KEY_UP",
@@ -965,13 +988,15 @@ declare namespace EventTypes_2 {
         AnnotationLockChangeEventDetail,
         AnnotationLockChangeEventType,
         SegmentationDataModifiedEventType,
-        SegmentationStateModifiedEventDetail,
-        SegmentationStateModifiedEventType,
+        SegmentationRepresentationModifiedEventDetail,
+        SegmentationRepresentationModifiedEventType,
+        SegmentationRepresentationRemovedEventDetail,
+        SegmentationRepresentationRemovedEventType,
         SegmentationDataModifiedEventDetail,
         SegmentationRenderedEventType,
         SegmentationRenderedEventDetail,
-        SegmentationGlobalStateModifiedEventType,
-        SegmentationGlobalStateModifiedEventDetail,
+        SegmentationModifiedEventType,
+        SegmentationModifiedEventDetail,
         KeyDownEventDetail,
         KeyDownEventType,
         KeyUpEventDetail,
@@ -1040,17 +1065,11 @@ declare type FrameOfReferenceSpecificAnnotations = {
     [key: string]: Annotations;
 };
 
-declare function getActiveSegmentationData(toolGroupId: string): ToolGroupSpecificSegmentationData | undefined;
-
-declare function getActiveSegmentationInfo(toolGroupId: string): {
-    volumeId: string;
-    segmentationDataUID: string;
-    activeSegmentIndex: number;
-};
+declare function getActiveSegmentationRepresentation(toolGroupId: string): ToolGroupSpecificRepresentation;
 
 declare function getActiveSegmentIndex(toolGroupId: string): number | undefined;
 
-declare function getActiveSegmentIndexForSegmentation(segmentationUID: string): number | undefined;
+declare function getActiveSegmentIndexForSegmentation(segmentationId: string): number | undefined;
 
 declare function getAllSynchronizers(): Array<Synchronizer>;
 
@@ -1080,47 +1099,41 @@ declare function getBoundingBoxAroundShape(vertices: Types_2.Point3[], dimension
 
 declare function getCanvasEllipseCorners(ellipseCanvasPoints: canvasCoordinates): Array<Types_2.Point2>;
 
-declare function getColorForSegmentIndex(toolGroupId: string, segmentationDataUID: string, segmentIndex: number): Color;
+declare function getColorForSegmentIndex(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): Color;
 
-declare function getColorLut(index: number): ColorLUT | undefined;
+declare function getColorLut(index: number): ColorLut | undefined;
 
 declare function getDefaultAnnotationManager(): FrameOfReferenceSpecificAnnotationManager;
 
-declare function getDefaultRepresentationConfig(representationType: string): LabelmapConfig;
+declare function getDefaultRepresentationConfig(segmentation: Segmentation): labelmapConfig;
 
 declare function getDefaultSegmentationStateManager(): SegmentationStateManager;
 
 declare function getFont(settings?: Settings, state?: AnnotationStyleStates, mode?: ToolModes): string;
 
-declare function getGlobalRepresentationConfig(representationType: SegmentationRepresentations): RepresentationConfig;
-
-declare function getGlobalSegmentationConfig(): SegmentationConfig;
-
-declare function getGlobalSegmentationConfig_2(): SegmentationConfig;
+declare function getGlobalConfig(): SegmentationRepresentationConfig;
 
-declare function getGlobalSegmentationDataByUID(segmentationUID: string): GlobalSegmentationData;
+declare function getGlobalConfig_2(): SegmentationRepresentationConfig;
 
-declare function getGlobalSegmentationState(): GlobalSegmentationState | [];
+declare function getGlobalRepresentationConfig(representationType: SegmentationRepresentations): RepresentationConfig['LABELMAP'];
 
 declare function getPointInLineOfSightWithCriteria(viewport: Types_2.IVolumeViewport, worldPos: Types_2.Point3, targetVolumeId: string, criteriaFunction: (intensity: number, point: Types_2.Point3) => Types_2.Point3, stepSize?: number): Types_2.Point3;
 
-declare function getRepresentationConfig(toolGroupId: string, representationType: SegmentationRepresentations): RepresentationConfig;
+declare function getSegmentation(segmentationId: string): Segmentation | undefined;
 
-declare function getSegmentationConfig(toolGroupId: string): SegmentationConfig;
+declare function getSegmentationRepresentationByUID(toolGroupId: string, segmentationRepresentationUID: string): ToolGroupSpecificRepresentation | undefined;
 
-declare function getSegmentationConfig_2(toolGroupId: string): SegmentationConfig;
+declare function getSegmentationRepresentations(toolGroupId: string): ToolGroupSpecificRepresentation[] | [];
 
-declare function getSegmentationDataByUID(toolGroupId: string, segmentationDataUID: string): ToolGroupSpecificSegmentationData | undefined;
+declare function getSegmentations(): Segmentation[] | [];
 
-declare function getSegmentationState(toolGroupId: string): ToolGroupSpecificSegmentationState | [];
-
-declare function getSegmentationVisibility(toolGroupId: string, segmentationDataUID: string): boolean | undefined;
+declare function getSegmentationVisibility(toolGroupId: string, segmentationRepresentationUID: string): boolean | undefined;
 
 declare function getSegmentIndexLocked(toolGroupId: string, segmentIndex: number): boolean;
 
-declare function getSegmentIndexLockedForSegmentation(segmentationUID: string, segmentIndex: number): boolean;
+declare function getSegmentIndexLockedForSegmentation(segmentationId: string, segmentIndex: number): boolean;
 
-declare function getSegmentsLockedForSegmentation(segmentationUID: string): number[] | [];
+declare function getSegmentsLockedForSegmentation(segmentationId: string): number[] | [];
 
 declare function getSliceRange(volumeActor: Types_2.VolumeActor, viewPlaneNormal: Types_2.Point3, focalPoint: Types_2.Point3): {
     min: number;
@@ -1140,11 +1153,13 @@ declare function getTextBoxCoordsCanvas(annotationCanvasPoints: Array<Types_2.Po
 
 declare function getToolGroup(viewportId: string, renderingEngineId: string): IToolGroup | undefined;
 
-declare function getToolGroupByToolGroupId(toolGroupId: string): IToolGroup | undefined;
+declare function getToolGroupById(toolGroupId: string): IToolGroup | undefined;
+
+declare function getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig;
 
-declare function getToolGroups(): string[];
+declare function getToolGroupSpecificConfig_2(toolGroupId: string): SegmentationRepresentationConfig;
 
-declare function getToolGroupsWithSegmentation(segmentationUID: string): string[];
+declare function getToolGroupsWithSegmentation(segmentationId: string): string[];
 
 declare function getViewportIdsWithToolToRender(element: HTMLElement, toolName: string, requireSameOrientation?: boolean): string[];
 
@@ -1155,25 +1170,6 @@ declare function getWorldWidthAndHeightFromCorners(viewPlaneNormal: Types_2.Poin
     worldHeight: number;
 };
 
-declare type GlobalSegmentationData = {
-    volumeId: string;
-    label: string;
-    referenceVolumeId?: string;
-    referenceImageId?: string;
-    activeSegmentIndex: number;
-    segmentsLocked: Set<number>;
-    cachedStats: {
-        [key: string]: number;
-    };
-};
-
-declare type GlobalSegmentationState = GlobalSegmentationData[];
-
-declare type GlobalSegmentationStateWithConfig = {
-    segmentations: GlobalSegmentationState;
-    config: SegmentationConfig;
-};
-
 declare function hideElementCursor(element: HTMLElement): void;
 
 declare interface IBaseTool {
@@ -1437,8 +1433,8 @@ declare interface IImageVolume {
     loadStatus?: Record<string, any>
     /** imageIds of the volume (if it is built of separate imageIds) */
     imageIds?: Array<string>
-    /** volume referenceVolumeId (if it is derived from another volume) */
-    referenceVolumeId?: string // if volume is derived from another volume
+    /** volume referencedVolumeId (if it is derived from another volume) */
+    referencedVolumeId?: string // if volume is derived from another volume
     /** method to convert the volume data in the volume cache, to separate images in the image cache */
     convertToCornerstoneImage?: (
     imageId: string,
@@ -1627,7 +1623,7 @@ declare class ImageVolume implements IImageVolume {
     /** optional image ids for the volume if it is made of separated images */
     imageIds?: Array<string>
     /** optional reference volume id if the volume is derived from another volume */
-    referenceVolumeId?: string
+    referencedVolumeId?: string
 
     constructor(props: IVolume) {
         this.volumeId = props.volumeId
@@ -1647,8 +1643,8 @@ declare class ImageVolume implements IImageVolume {
             this.scaling = props.scaling
         }
 
-        if (props.referenceVolumeId) {
-            this.referenceVolumeId = props.referenceVolumeId
+        if (props.referencedVolumeId) {
+            this.referencedVolumeId = props.referencedVolumeId
         }
     }
 }
@@ -2035,8 +2031,8 @@ declare interface IVolume {
     sizeInBytes?: number
     /** volume image data as vtkImageData */
     imageData?: vtkImageData
-    /** referenceVolumeId if volume is derived from another volume */
-    referenceVolumeId?: string
+    /** referencedVolumeId if volume is derived from another volume */
+    referencedVolumeId?: string
     /** volume scaling metadata */
     scaling?: {
         PET?: {
@@ -2189,7 +2185,7 @@ declare type KeyUpEventDetail = KeyDownEventDetail;
 
 declare type KeyUpEventType = Types_2.CustomEventType<KeyUpEventDetail>;
 
-declare type LabelmapConfig = {
+declare type labelmapConfig = {
     renderOutline?: boolean;
     outlineWidth?: number;
     outlineWidthActive?: number;
@@ -2199,12 +2195,14 @@ declare type LabelmapConfig = {
     fillAlphaInactive?: number;
 };
 
-declare type LabelmapRepresentation = {
-    type: typeof SegmentationRepresentations.Labelmap;
-    config: {
-        cfun?: vtkColorTransferFunction;
-        ofun?: vtkPiecewiseFunction;
-    };
+declare type LabelmapRenderingConfig = {
+    cfun?: vtkColorTransferFunction;
+    ofun?: vtkPiecewiseFunction;
+};
+
+declare type LabelmapRepresentationData = {
+    volumeId: string;
+    referencedVolumeId?: string;
 };
 
 declare interface LengthAnnotation extends Annotation {
@@ -2740,7 +2738,7 @@ export declare class RectangleRoiThresholdTool extends RectangleRoiTool {
                 points: Types_2.Point3[];
                 activeHandleIndex: any;
             };
-            segmentationUID: any;
+            segmentationId: any;
         };
     };
     renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
@@ -2788,7 +2786,7 @@ export declare class RectangleScissorsTool extends BaseTool {
     _throttledCalculateCachedStats: any;
     editData: {
         annotation: any;
-        segmentationDataUID: string;
+        segmentationId: string;
         segmentation: any;
         segmentIndex: number;
         segmentsLocked: number[];
@@ -2817,13 +2815,20 @@ declare function registerCursor(toolName: string, iconContent: string, viewBox:
 
 declare function removeAnnotation(element: HTMLElement, annotationUID: string): void;
 
-declare function removeSegmentationData(toolGroupId: string, segmentationDataUID: string): void;
+declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
 
-declare function removeSegmentationsFromToolGroup(toolGroupId: string, segmentationDataUIDs?: string[] | undefined): void;
+declare function removeSegmentationsFromToolGroup(toolGroupId: string, segmentationRepresentationUIDs?: string[] | undefined): void;
 
 export declare function removeTool(ToolClass: any): void;
 
-declare type RepresentationConfig = LabelmapConfig;
+declare type RepresentationConfig = {
+    LABELMAP?: labelmapConfig;
+};
+
+declare type RepresentationPublicInput = {
+    segmentationId: string;
+    type: Enums_2.SegmentationRepresentations;
+};
 
 declare function resetElementCursor(element: HTMLElement): void;
 
@@ -2848,11 +2853,24 @@ declare type ScalingParameters = {
 
 declare function scrollThroughStack(evt: MouseWheelEventType | MouseDragEventType, deltaFrames: number, volumeId: string, invert?: boolean): void;
 
+declare type Segmentation = {
+    segmentationId: string;
+    type: Enums_2.SegmentationRepresentations;
+    label: string;
+    activeSegmentIndex: number;
+    segmentsLocked: Set<number>;
+    cachedStats: {
+        [key: string]: number;
+    };
+    representations: SegmentationRepresentationData;
+};
+
 declare namespace segmentation {
     export {
         state_2 as state,
+        addSegmentations,
         activeSegmentation,
-        addSegmentationsForToolGroup,
+        addSegmentationRepresentations,
         removeSegmentationsFromToolGroup,
         createNewSegmentationForToolGroup,
         segmentLocking,
@@ -2870,7 +2888,6 @@ declare namespace segmentation_2 {
         getBoundingBoxAroundShape,
         extend2DBoundingBoxInViewAxis,
         thresholdVolumeByRange,
-        thresholdVolumeByRoiStats,
         createMergedLabelmapForIndex,
         isValidRepresentationConfig,
         getDefaultRepresentationConfig
@@ -2884,35 +2901,19 @@ declare namespace segmentationColor {
     }
 }
 
-declare type SegmentationConfig = {
-    renderInactiveSegmentations: boolean;
-    representations: {
-        LABELMAP?: LabelmapConfig;
-    };
-};
-
 declare namespace segmentationConfig {
     export {
-        getGlobalSegmentationConfig_2 as getGlobalSegmentationConfig,
-        setGlobalSegmentationConfig_2 as setGlobalSegmentationConfig,
+        getGlobalConfig_2 as getGlobalConfig,
+        setGlobalConfig_2 as setGlobalConfig,
         getGlobalRepresentationConfig,
         setGlobalRepresentationConfig,
-        updateGlobalSegmentationConfig,
-        updateGlobalRepresentationConfig,
-        getSegmentationConfig_2 as getSegmentationConfig,
-        setSegmentationConfig_2 as setSegmentationConfig,
-        setRepresentationConfig,
-        getRepresentationConfig
+        getToolGroupSpecificConfig_2 as getToolGroupSpecificConfig,
+        setToolGroupSpecificConfig_2 as setToolGroupSpecificConfig
     }
 }
 
-declare type SegmentationDataInput = Partial<ToolGroupSpecificSegmentationData> & {
-    toolGroupId: string;
-};
-
 declare type SegmentationDataModifiedEventDetail = {
-    toolGroupId: string;
-    segmentationDataUID: string;
+    segmentationId: string;
 };
 
 declare type SegmentationDataModifiedEventType = Types_2.CustomEventType<SegmentationDataModifiedEventDetail>;
@@ -2923,14 +2924,22 @@ export declare class SegmentationDisplayTool extends BaseTool {
     enableCallback(): void;
     disableCallback(): void;
     renderSegmentation: (toolGroupId: string) => void;
-    _getSegmentationConfig(toolGroupId: string): SegmentationConfig;
+    _getMergedRepresentationsConfig(toolGroupId: string): SegmentationRepresentationConfig;
 }
 
-declare type SegmentationGlobalStateModifiedEventDetail = {
-    segmentationUID: string;
+declare type SegmentationModifiedEventDetail = {
+    segmentationId: string;
 };
 
-declare type SegmentationGlobalStateModifiedEventType = Types_2.CustomEventType<SegmentationGlobalStateModifiedEventDetail>;
+declare type SegmentationModifiedEventType = Types_2.CustomEventType<SegmentationModifiedEventDetail>;
+
+declare type SegmentationPublicInput = {
+    segmentationId: string;
+    representation: {
+        type: Enums_2.SegmentationRepresentations;
+        data: LabelmapRepresentationData;
+    };
+};
 
 declare type SegmentationRenderedEventDetail = {
     viewportId: string;
@@ -2939,19 +2948,44 @@ declare type SegmentationRenderedEventDetail = {
 
 declare type SegmentationRenderedEventType = Types_2.CustomEventType<SegmentationRenderedEventDetail>;
 
-declare type SegmentationRepresentation = LabelmapRepresentation;
+declare type SegmentationRepresentationConfig = {
+    renderInactiveSegmentations: boolean;
+    representations: RepresentationConfig;
+};
+
+declare type SegmentationRepresentationData = {
+    LABELMAP?: LabelmapRepresentationData;
+};
+
+declare type SegmentationRepresentationModifiedEventDetail = {
+    toolGroupId: string;
+    segmentationRepresentationUID: string;
+};
+
+declare type SegmentationRepresentationModifiedEventType = Types_2.CustomEventType<SegmentationRepresentationModifiedEventDetail>;
+
+declare type SegmentationRepresentationRemovedEventDetail = {
+    toolGroupId: string;
+    segmentationRepresentationUID: string;
+};
+
+declare type SegmentationRepresentationRemovedEventType = Types_2.CustomEventType<SegmentationRepresentationRemovedEventDetail>;
 
 declare enum SegmentationRepresentations {
     Labelmap = "LABELMAP"
 }
 
-declare interface SegmentationState {
-    colorLutTables: ColorLUT[];
-    global: GlobalSegmentationStateWithConfig;
+declare type SegmentationState = {
+    colorLut: ColorLut[];
+    segmentations: Segmentation[];
+    globalConfig: SegmentationRepresentationConfig;
     toolGroups: {
-        [key: string]: ToolGroupSpecificSegmentationStateWithConfig;
+        [key: string]: {
+            segmentationRepresentations: ToolGroupSpecificRepresentation[];
+            config: SegmentationRepresentationConfig;
+        };
     };
-}
+};
 
 declare class SegmentationStateManager {
     private state;
@@ -2959,33 +2993,24 @@ declare class SegmentationStateManager {
     constructor(uid?: string);
     getState(): SegmentationState;
     getToolGroups(): string[];
-    getColorLut(lutIndex: number): ColorLUT | undefined;
+    getColorLut(lutIndex: number): ColorLut | undefined;
     resetState(): void;
-    getGlobalSegmentationData(segmentationUID: string): GlobalSegmentationData | undefined;
-    getGlobalSegmentationState(): GlobalSegmentationState | [];
-    getGlobalSegmentationConfig(): SegmentationConfig;
-    setGlobalSegmentationConfig(config: SegmentationConfig): void;
-    getToolGroupsWithSegmentation(segmentationUID: string): string[];
-    getSegmentationState(toolGroupId: string): ToolGroupSpecificSegmentationState | [];
-    getSegmentationConfig(toolGroupId: string): SegmentationConfig | undefined;
-    setSegmentationConfig(toolGroupId: string, config: SegmentationConfig): void;
-    getSegmentationDataByUID(toolGroupId: string, segmentationDataUID: string): ToolGroupSpecificSegmentationData | undefined;
-    getActiveSegmentationData(toolGroupId: string): ToolGroupSpecificSegmentationData | undefined;
-    addColorLUT(colorLut: ColorLUT, lutIndex: number): void;
-    addGlobalSegmentationData(segmentationData: GlobalSegmentationData): void;
-    addSegmentationData(toolGroupId: string, segmentationData: ToolGroupSpecificSegmentationData): void;
-    setActiveSegmentationData(toolGroupId: string, segmentationDataUID: string): void;
-    removeSegmentationData(toolGroupId: string, segmentationDataUID: string): void;
-    _handleActiveSegmentation(toolGroupId: string, recentlyAddedOrRemovedSegmentationData: ToolGroupSpecificSegmentationData): void;
+    getSegmentation(segmentationId: string): Segmentation | undefined;
+    addSegmentation(segmentation: Segmentation): void;
+    getSegmentationRepresentations(toolGroupId: string): ToolGroupSpecificRepresentation[] | undefined;
+    addSegmentationRepresentation(toolGroupId: string, segmentationRepresentation: ToolGroupSpecificRepresentation): void;
+    getGlobalConfig(): SegmentationRepresentationConfig;
+    setGlobalConfig(config: SegmentationRepresentationConfig): void;
+    getSegmentationRepresentationByUID(toolGroupId: string, segmentationRepresentationUID: string): ToolGroupSpecificRepresentation | undefined;
+    removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
+    setActiveSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
+    getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig | undefined;
+    setSegmentationRepresentationConfig(toolGroupId: string, config: SegmentationRepresentationConfig): void;
+    addColorLUT(colorLut: ColorLut, lutIndex: number): void;
+    _handleActiveSegmentation(toolGroupId: string, recentlyAddedOrRemovedSegmentationRepresentation: ToolGroupSpecificRepresentation): void;
     _initDefaultColorLutIfNecessary(): void;
 }
 
-declare type SegmentationStateModifiedEventDetail = {
-    toolGroupId: string;
-};
-
-declare type SegmentationStateModifiedEventType = Types_2.CustomEventType<SegmentationStateModifiedEventDetail>;
-
 declare namespace segmentationVisibility {
     export {
         setSegmentationVisibility,
@@ -3023,13 +3048,11 @@ declare namespace selection {
     }
 }
 
-declare function setActiveSegmentation(toolGroupId: string, segmentationDataUID: string): void;
-
-declare function setActiveSegmentationData(toolGroupId: string, segmentationDataUID: string, suppressEvents?: boolean): void;
+declare function setActiveSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
 
 declare function setActiveSegmentIndex(toolGroupId: string, segmentIndex: number): void;
 
-declare function setActiveSegmentIndexForSegmentation(segmentationUID: string, segmentIndex: number): void;
+declare function setActiveSegmentIndexForSegmentation(segmentationId: string, segmentIndex: number): void;
 
 declare function setAnnotationLocked(annotation: Annotation, locked?: boolean): void;
 
@@ -3041,25 +3064,19 @@ declare function setCursorForElement(element: HTMLElement, cursorName: string):
 
 declare function _setElementCursor(element: HTMLElement, cursor: MouseCursor | null): void;
 
-declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: RepresentationConfig): void;
+declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
 
-declare function setGlobalSegmentationConfig(config: SegmentationConfig, suppressEvents?: boolean): void;
+declare function setGlobalConfig_2(segmentationConfig: SegmentationRepresentationConfig): void;
 
-declare function setGlobalSegmentationConfig_2(segmentationConfig: SegmentationConfig): void;
+declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: RepresentationConfig['LABELMAP']): void;
 
 declare function setGlobalStyle(style: Record<string, unknown>): boolean;
 
-declare function setRepresentationConfig(toolGroupId: string, representationType: SegmentationRepresentations, representationConfig: RepresentationConfig): void;
-
-declare function setSegmentationConfig(toolGroupId: string, config: SegmentationConfig, suppressEvents?: boolean): void;
-
-declare function setSegmentationConfig_2(toolGroupId: string, segmentationConfig: SegmentationConfig): void;
-
-declare function setSegmentationVisibility(toolGroupId: string, segmentationDataUID: string, visibility: boolean): void;
+declare function setSegmentationVisibility(toolGroupId: string, segmentationRepresentationUID: string, visibility: boolean): void;
 
 declare function setSegmentIndexLocked(toolGroupId: string, segmentIndex: number, locked?: boolean): void;
 
-declare function setSegmentIndexLockedForSegmentation(segmentationUID: string, segmentIndex: number, locked?: boolean): void;
+declare function setSegmentIndexLockedForSegmentation(segmentationId: string, segmentIndex: number, locked?: boolean): void;
 
 /**
  * Settings
@@ -3199,6 +3216,10 @@ declare type SetToolBindingsType = {
     bindings: IToolBinding[];
 };
 
+declare function setToolGroupSpecificConfig(toolGroupId: string, config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
+
+declare function setToolGroupSpecificConfig_2(toolGroupId: string, segmentationRepresentationConfig: SegmentationRepresentationConfig): void;
+
 declare function setToolStyle(toolName: string, style: Record<string, unknown>): boolean;
 
 declare type ShapeFnCriteria = (pointIJK: Types_2.Point3, pointLPS: Types_2.Point3) => boolean;
@@ -3220,7 +3241,7 @@ export declare class SphereScissorsTool extends BaseTool {
         segmentation: any;
         segmentIndex: number;
         segmentsLocked: number[];
-        segmentationDataUID: string;
+        segmentationId: string;
         toolGroupId: string;
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];
@@ -3318,24 +3339,21 @@ declare namespace state {
 
 declare namespace state_2 {
     export {
-        getGlobalSegmentationConfig,
-        getSegmentationConfig,
-        setGlobalSegmentationConfig,
-        setSegmentationConfig,
-        addColorLUT,
-        getColorLut,
-        getGlobalSegmentationState,
-        getGlobalSegmentationDataByUID,
-        addGlobalSegmentationData,
-        getSegmentationState,
-        addSegmentationData,
-        removeSegmentationData,
-        getSegmentationDataByUID,
-        setActiveSegmentationData,
-        getActiveSegmentationData,
+        getDefaultSegmentationStateManager,
+        getSegmentation,
+        getSegmentations,
+        addSegmentation,
+        getSegmentationRepresentations,
+        addSegmentationRepresentation,
+        removeSegmentationRepresentation,
+        getToolGroupSpecificConfig,
+        setToolGroupSpecificConfig,
+        getGlobalConfig,
+        setGlobalConfig,
         getToolGroupsWithSegmentation,
-        getToolGroups,
-        getDefaultSegmentationStateManager
+        getSegmentationRepresentationByUID,
+        addColorLUT,
+        getColorLut
     }
 }
 
@@ -3421,16 +3439,7 @@ declare type ThresholdRangeOptions = {
     overwrite: boolean;
 };
 
-declare type ThresholdRoiStatsOptions = {
-    statistic: 'max' | 'min';
-    weight: number;
-    numSlicesToProject?: number;
-    overwrite: boolean;
-};
-
-declare function thresholdVolumeByRange(toolGroupId: string, annotations: AnnotationForThresholding[], referenceVolumes: Types_2.IImageVolume[], segmentationData: ToolGroupSpecificSegmentationData, options: ThresholdRangeOptions): Types_2.IImageVolume;
-
-declare function thresholdVolumeByRoiStats(toolGroupId: string, annotations: AnnotationForThresholding[], referenceVolumes: Types_2.IImageVolume[], segmentationData: ToolGroupSpecificSegmentationData, options: ThresholdRoiStatsOptions): void;
+declare function thresholdVolumeByRange(annotations: AnnotationForThresholding[], referenceVolumes: Types_2.IImageVolume[], segmentationRepresentation: ToolGroupSpecificRepresentation, options: ThresholdRangeOptions): Types_2.IImageVolume;
 
 declare function throttle(func: Function, wait?: number, options?: {
     leading?: boolean;
@@ -3445,29 +3454,28 @@ declare namespace ToolGroupManager {
     export {
         createToolGroup,
         destroy_3 as destroy,
-        destroyToolGroupByToolGroupId,
-        getToolGroupByToolGroupId,
+        destroyToolGroupById,
+        getToolGroupById,
         getToolGroup,
         getAllToolGroups
     }
 }
 export { ToolGroupManager }
 
-declare type ToolGroupSpecificSegmentationData = {
-    volumeId: string;
-    segmentationDataUID: string;
+declare type ToolGroupSpecificLabelmapRepresentation = ToolGroupSpecificRepresentationState & {
+    config: LabelmapRenderingConfig;
+};
+
+declare type ToolGroupSpecificRepresentation = ToolGroupSpecificLabelmapRepresentation;
+
+declare type ToolGroupSpecificRepresentationState = {
+    segmentationRepresentationUID: string;
+    segmentationId: string;
+    type: Enums_2.SegmentationRepresentations;
     active: boolean;
     segmentsHidden: Set<number>;
     visibility: boolean;
     colorLUTIndex: number;
-    representation: SegmentationRepresentation;
-};
-
-declare type ToolGroupSpecificSegmentationState = ToolGroupSpecificSegmentationData[];
-
-declare type ToolGroupSpecificSegmentationStateWithConfig = {
-    segmentations: ToolGroupSpecificSegmentationState;
-    config: SegmentationConfig;
 };
 
 declare type ToolHandle = AnnotationHandle | TextBoxHandle;
@@ -3530,19 +3538,22 @@ detail: unknown = null
     return el.dispatchEvent(event)
 }
 
-declare function triggerSegmentationDataModified(toolGroupId: string, segmentationDataUID: string): void;
+declare function triggerSegmentationDataModified(segmentationId: string): void;
 
 declare namespace triggerSegmentationEvents {
     export {
-        triggerSegmentationStateModified,
+        triggerSegmentationRepresentationModified,
+        triggerSegmentationRepresentationRemoved,
         triggerSegmentationDataModified,
-        triggerSegmentationGlobalStateModified
+        triggerSegmentationModified
     }
 }
 
-declare function triggerSegmentationGlobalStateModified(segmentationUID?: string): void;
+declare function triggerSegmentationModified(segmentationId?: string): void;
+
+declare function triggerSegmentationRepresentationModified(toolGroupId: string, segmentationRepresentationUID?: string): void;
 
-declare function triggerSegmentationStateModified(toolGroupId: string): void;
+declare function triggerSegmentationRepresentationRemoved(toolGroupId: string, segmentationRepresentationUID: string): void;
 
 declare namespace Types {
     export {
@@ -3563,18 +3574,16 @@ declare namespace Types {
         ToolHandle,
         AnnotationHandle,
         TextBoxHandle,
-        SegmentationRepresentation,
-        LabelmapRepresentation,
-        Color,
-        ColorLUT,
+        Segmentation,
+        SegmentationState,
+        SegmentationRepresentationData,
+        SegmentationRepresentationConfig,
         RepresentationConfig,
-        SegmentationConfig,
-        GlobalSegmentationData,
-        GlobalSegmentationState,
-        GlobalSegmentationStateWithConfig,
-        ToolGroupSpecificSegmentationData,
-        ToolGroupSpecificSegmentationStateWithConfig,
-        ToolGroupSpecificSegmentationState,
+        ToolGroupSpecificRepresentationState,
+        ToolGroupSpecificLabelmapRepresentation,
+        ToolGroupSpecificRepresentation,
+        Color,
+        ColorLut,
         SVGCursorDescriptor,
         SVGPoint_2 as SVGPoint
     }
@@ -3643,10 +3652,6 @@ declare namespace Types_2 {
 
 declare function unlockAllAnnotations(): void;
 
-declare function updateGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: Partial<RepresentationConfig>): void;
-
-declare function updateGlobalSegmentationConfig(config: Partial<SegmentationConfig>): void;
-
 declare namespace utilities {
     export {
         math,