@cornerstonejs/tools 0.1.1

package/dist/tools.d.ts

@@ -0,0 +1,3997 @@
+import type { mat4 } from 'gl-matrix';
+import type { vtkColorTransferFunction } from 'vtk.js/Sources/Rendering/Core/ColorTransferFunction';
+import type { vtkImageData } from 'vtk.js/Sources/Common/DataModel/ImageData';
+import type { vtkPiecewiseFunction } from 'vtk.js/Sources/Common/DataModel/PiecewiseFunction';
+import type { vtkVolume } from 'vtk.js/Sources/Rendering/Core/Volume';
+
+declare namespace activeSegmentation {
+    export {
+        getActiveSegmentationInfo,
+        setActiveSegmentation,
+        _default_3 as default
+    }
+}
+
+/**
+ * Cornerstone Actor Entry including actor uid, actual volumeActor, and
+ * slabThickness for the actor. Note: actor (and actorEntry) are not
+ * the same as volumeActor which is vtkVolume. ActorEntry is the object that
+ * is retrieved from viewport when calling viewport.getActor(s)
+ */
+declare type ActorEntry = {
+    uid: string
+    volumeActor: VolumeActor
+    slabThickness?: number
+}
+
+declare function addAnnotation(element: HTMLElement, annotation: Annotation): void;
+
+declare function addColorLUT(colorLut: ColorLUT, index: number): void;
+
+declare function addColorLUT_2(colorLUT: ColorLUT, colorLUTIndex: number): void;
+
+declare function addGlobalSegmentationData(segmentationData: GlobalSegmentationData, suppressEvents?: boolean): void;
+
+declare function addSegmentationData(toolGroupUID: string, segmentationData: ToolGroupSpecificSegmentationData, suppressEvents?: boolean): void;
+
+declare function addSegmentationsForToolGroup(toolGroupUID: string, segmentationDataArray: SegmentationDataInput[], toolGroupSpecificConfig?: SegmentationConfig): Promise<void>;
+
+export declare function addTool(ToolClass: any): void;
+
+declare type Annotation = {
+    annotationUID?: string;
+    highlighted?: boolean;
+    isLocked?: boolean;
+    invalidated?: boolean;
+    metadata: {
+        cameraPosition?: Types_2.Point3;
+        cameraFocalPoint?: Types_2.Point3;
+        viewPlaneNormal?: Types_2.Point3;
+        viewUp?: Types_2.Point3;
+        FrameOfReferenceUID: string;
+        toolName: string;
+        referencedImageId?: string;
+        volumeUID?: string;
+    };
+    data: {
+        handles?: {
+            points?: Types_2.Point3[];
+            activeHandleIndex?: number | null;
+            textBox?: {
+                hasMoved: boolean;
+                worldPosition: Types_2.Point3;
+                worldBoundingBox: {
+                    topLeft: Types_2.Point3;
+                    topRight: Types_2.Point3;
+                    bottomLeft: Types_2.Point3;
+                    bottomRight: Types_2.Point3;
+                };
+            };
+            [key: string]: any;
+        };
+        cachedStats?: unknown;
+    };
+};
+
+declare namespace annotation {
+    export {
+        config,
+        locking,
+        selection,
+        state
+    }
+}
+export { annotation }
+
+declare type AnnotationAddedEventDetail = {
+    viewportUID: string;
+    renderingEngineUID: string;
+    annotation: Annotation;
+};
+
+declare type AnnotationAddedEventType = Types_2.CustomEventType<AnnotationAddedEventDetail>;
+
+declare type AnnotationForThresholding = {
+    metadata: {
+        enabledElement: Types_2.IEnabledElement;
+    };
+    data: {
+        handles: {
+            points: Types_2.Point3[];
+        };
+        cachedStats: {
+            projectionPoints: Types_2.Point3[][];
+        };
+    };
+};
+
+declare type AnnotationHandle = Types_2.Point3;
+
+declare type AnnotationLockChangeEventDetail = {
+    added: Array<Annotation>;
+    removed: Array<Annotation>;
+    locked: Array<Annotation>;
+};
+
+declare type AnnotationLockChangeEventType = Types_2.CustomEventType<AnnotationLockChangeEventDetail>;
+
+declare type AnnotationModifiedEventDetail = {
+    viewportUID: string;
+    renderingEngineUID: string;
+    annotation: Annotation;
+};
+
+declare type AnnotationModifiedEventType = Types_2.CustomEventType<AnnotationModifiedEventDetail>;
+
+declare type AnnotationRemovedEventDetail = {
+    viewportUID: string;
+    renderingEngineUID: string;
+    annotation: Annotation;
+};
+
+declare type AnnotationRemovedEventType = Types_2.CustomEventType<AnnotationRemovedEventDetail>;
+
+declare type AnnotationRenderedEventDetail = {
+    element: HTMLElement;
+    viewportUID: string;
+    renderingEngineUID: string;
+};
+
+declare type AnnotationRenderedEventType = Types_2.CustomEventType<AnnotationRenderedEventDetail>;
+
+declare type Annotations = Array<Annotation>;
+
+declare type AnnotationSelectionChangeEventDetail = {
+    added: Array<Annotation>;
+    removed: Array<Annotation>;
+    selection: Array<Annotation>;
+};
+
+declare type AnnotationSelectionChangeEventType = Types_2.CustomEventType<AnnotationSelectionChangeEventDetail>;
+
+declare type AnnotationState = {
+    [key: string]: FrameOfReferenceSpecificAnnotations;
+};
+
+declare enum AnnotationStyleStates {
+    Default = "",
+    Highlighted = "Highlighted",
+    Selected = "Selected",
+    Locked = "Locked"
+}
+
+export declare abstract class AnnotationTool extends BaseTool {
+    static toolName: string;
+    abstract addNewAnnotation(evt: EventTypes_2.MouseDownActivateEventType, interactionType: InteractionTypes): Annotation;
+    abstract renderAnnotation(enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any): any;
+    abstract cancel(element: HTMLElement): any;
+    abstract handleSelectedCallback(evt: EventTypes_2.MouseDownEventType, annotation: Annotation, handle: ToolHandle, interactionType: InteractionTypes): void;
+    abstract toolSelectedCallback(evt: EventTypes_2.MouseDownEventType, annotation: Annotation, interactionType: InteractionTypes): void;
+    abstract isPointNearTool(element: HTMLElement, annotation: Annotation, canvasCoords: Types_2.Point2, proximity: number, interactionType: string): boolean;
+    filterInteractableAnnotationsForElement(element: HTMLElement, annotations: Annotations): Annotations | undefined;
+    mouseMoveCallback: (evt: EventTypes_2.MouseMoveEventType, filteredAnnotations: Annotations) => boolean;
+    onImageSpacingCalibrated: (evt: Types_2.EventTypes.ImageSpacingCalibratedEvent) => void;
+    getHandleNearImagePoint(element: HTMLElement, annotation: Annotation, canvasCoords: Types_2.Point2, proximity: number): ToolHandle | undefined;
+    getStyle(settings: Settings, property: string, annotation?: Annotation): unknown;
+    getLinkedTextBoxStyle(settings: Settings, annotation?: Annotation): Record<string, unknown>;
+    private _imagePointNearToolOrHandle;
+}
+
+export declare abstract class BaseTool implements IBaseTool {
+    static toolName: string;
+    supportedInteractionTypes: InteractionTypes[];
+    configuration: Record<string, any>;
+    toolGroupUID: string;
+    mode: ToolModes;
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    getToolName(): string;
+    applyActiveStrategy(enabledElement: Types_2.IEnabledElement, operationData: unknown): any;
+    setConfiguration(newConfiguration: Record<string, any>): void;
+    setActiveStrategy(strategyName: string): void;
+    private getTargetVolumeUID;
+    protected getTargetUIDViewportAndImage(targetUID: string, renderingEngine: Types_2.IRenderingEngine): {
+        viewport: Types_2.IViewport;
+        image: Types_2.IImageData;
+    };
+    protected getTargetUID(viewport: Types_2.IViewport): string | undefined;
+}
+
+declare interface BidirectionalAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: Types_2.Point3[];
+            activeHandleIndex: number | null;
+            textBox: {
+                hasMoved: boolean;
+                worldPosition: Types_2.Point3;
+                worldBoundingBox: {
+                    topLeft: Types_2.Point3;
+                    topRight: Types_2.Point3;
+                    bottomLeft: Types_2.Point3;
+                    bottomRight: Types_2.Point3;
+                };
+            };
+        };
+        label: string;
+        cachedStats: {
+            [targetUID: string]: {
+                length: number;
+                width: number;
+            };
+        };
+    };
+}
+
+export declare class BidirectionalTool extends AnnotationTool {
+    static toolName: string;
+    touchDragCallback: any;
+    mouseDragCallback: any;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        movingTextBox: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    preventHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation(evt: EventTypes_2.MouseDownActivateEventType): BidirectionalAnnotation;
+    isPointNearTool: (element: HTMLElement, annotation: BidirectionalAnnotation, canvasCoords: Types_2.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: BidirectionalAnnotation, interactionType: InteractionTypes) => void;
+    handleSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: BidirectionalAnnotation, handle: ToolHandle, interactionType?: string) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _mouseDragDrawCallback: (evt: MouseMoveEventType | MouseDragEventType) => void;
+    _mouseDragModifyCallback: (evt: MouseDragEventType) => void;
+    _mouseDragModifyHandle: (evt: any) => void;
+    cancel: (element: HTMLElement) => any;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _movingLongAxisWouldPutItThroughShortAxis: (proposedFirstLineSegment: any, secondLineSegment: any) => boolean;
+    _getTextLines: (data: any, targetUID: any) => string[];
+    _calculateLength(pos1: any, pos2: any): number;
+    _calculateCachedStats: (annotation: any, renderingEngine: any, enabledElement: any) => any;
+    _isInsideVolume: (index1: any, index2: any, index3: any, index4: any, dimensions: any) => boolean;
+}
+
+declare type BoundsIJK = [Types_2.Point2, Types_2.Point2, Types_2.Point2];
+
+declare function calibrateImageSpacing(imageId: string, renderingEngine: Types_2.IRenderingEngine, rowPixelSpacing: number, columnPixelSpacing: number): void;
+
+/**
+ * CameraModified Event type
+ */
+declare type CameraModifiedEvent = CustomEvent_2<CameraModifiedEventDetail>
+
+/**
+ * CAMERA_MODIFIED Event's data
+ */
+declare type CameraModifiedEventDetail = {
+    /** Previous camera properties */
+    previousCamera: ICamera
+    /** Current camera properties */
+    camera: ICamera
+    /** Viewport HTML element in the DOM */
+    element: HTMLElement
+    /** Viewport Unique ID in the renderingEngine */
+    viewportUID: string
+    /** Unique ID for the renderingEngine */
+    renderingEngineUID: string
+}
+
+export declare function cancelActiveManipulations(element: HTMLElement): string | undefined;
+
+declare type canvasCoordinates = [
+Types_2.Point2,
+Types_2.Point2,
+Types_2.Point2,
+Types_2.Point2
+];
+
+declare function checkAndDefineIsLockedProperty(annotation: Annotation): void;
+
+export declare class CircleScissorsTool extends BaseTool {
+    static toolName: string;
+    editData: {
+        annotation: any;
+        segmentation: any;
+        segmentIndex: number;
+        segmentationDataUID: string;
+        segmentsLocked: number[];
+        segmentColor: [number, number, number, number];
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        movingTextBox: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+        centerCanvas?: Array<number>;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => void;
+    _mouseDragCallback: (evt: EventTypes_2.MouseDragEventType) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+}
+
+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 namespace config {
+    export {
+        getState,
+        getStyle,
+        getFont,
+        setAnnotationStyle,
+        setGlobalStyle,
+        setToolStyle
+    }
+}
+
+declare interface CPUFallbackColormap {
+    /** Get id of colormap */
+    getId: () => string
+    getColorSchemeName: () => string
+    setColorSchemeName: (name: string) => void
+    getNumberOfColors: () => number
+    setNumberOfColors: (numColors: number) => void
+    getColor: (index: number) => Point4
+    getColorRepeating: (index: number) => Point4
+    setColor: (index: number, rgba: Point4) => void
+    addColor: (rgba: Point4) => void
+    insertColor: (index: number, rgba: Point4) => void
+    removeColor: (index: number) => void
+    clearColors: () => void
+    buildLookupTable: (lut: CPUFallbackLookupTable) => void
+    createLookupTable: () => CPUFallbackLookupTable
+    isValidIndex: (index: number) => boolean
+}
+
+declare type CPUFallbackColormapData = {
+    name: string;
+    numOfColors?: number;
+    colors?: Point4[];
+    segmentedData?: unknown;
+    numColors?: number;
+    gamma?: number;
+};
+
+declare type CPUFallbackColormapsData = {
+    [key: string]: CPUFallbackColormapData;
+};
+
+declare interface CPUFallbackEnabledElement {
+    scale?: number
+    pan?: Point2
+    zoom?: number
+    rotation?: number
+    image?: IImage
+    canvas?: HTMLCanvasElement
+    viewport?: CPUFallbackViewport
+    colormap?: CPUFallbackColormap
+    options?: {
+        [key: string]: unknown
+        colormap?: CPUFallbackColormap
+    }
+    renderingTools?: CPUFallbackRenderingTools
+    transform?: CPUFallbackTransform
+    invalid?: boolean
+    needsRedraw?: boolean
+    metadata?: {
+        direction?: Float32Array
+        /** Last index is always 1 for CPU */
+        dimensions?: Point3
+        /** Last spacing is always EPSILON for CPU */
+        spacing?: Point3
+        origin?: Point3
+        imagePlaneModule?: {
+            frameOfReferenceUID: string
+            rows: number
+            columns: number
+            imageOrientationPatient: number[]
+            rowCosines: Point3
+            columnCosines: Point3
+            imagePositionPatient: number[]
+            sliceThickness?: number
+            sliceLocation?: number
+            pixelSpacing: Point2
+            rowPixelSpacing: number
+            columnPixelSpacing: number
+        }
+        imagePixelModule?: {
+            samplesPerPixel: number
+            photometricInterpretation: string
+            rows: number
+            columns: number
+            bitsAllocated: number
+            bitsStored: number
+            highBit: number
+            pixelRepresentation: number
+            planarConfiguration?: number
+            pixelAspectRatio?: number
+            smallestPixelValue?: number
+            largestPixelValue?: number
+            redPaletteColorLookupTableDescriptor?: number[]
+            greenPaletteColorLookupTableDescriptor?: number[]
+            bluePaletteColorLookupTableDescriptor?: number[]
+            redPaletteColorLookupTableData: number[]
+            greenPaletteColorLookupTableData: number[]
+            bluePaletteColorLookupTableData: number[]
+        }
+    }
+}
+
+declare interface CPUFallbackLookupTable {
+    setNumberOfTableValues: (number: number) => void;
+    setRamp: (ramp: string) => void;
+    setTableRange: (start: number, end: number) => void;
+    setHueRange: (start: number, end: number) => void;
+    setSaturationRange: (start: number, end: number) => void;
+    setValueRange: (start: number, end: number) => void;
+    setRange: (start: number, end: number) => void;
+    setAlphaRange: (start: number, end: number) => void;
+    getColor: (scalar: number) => Point4;
+    build: (force: boolean) => void;
+    setTableValue(index: number, rgba: Point4);
+}
+
+declare type CPUFallbackLUT = {
+    lut: number[];
+};
+
+declare type CPUFallbackRenderingTools = {
+    renderCanvas?: HTMLCanvasElement;
+    lastRenderedIsColor?: boolean;
+    lastRenderedImageId?: string;
+    lastRenderedViewport?: {
+        windowWidth: number | number[];
+        windowCenter: number | number[];
+        invert: boolean;
+        rotation: number;
+        hflip: boolean;
+        vflip: boolean;
+        modalityLUT: CPUFallbackLUT;
+        voiLUT: CPUFallbackLUT;
+        colormap: unknown;
+    };
+    renderCanvasContext?: {
+        putImageData: (
+        renderCanvasData: unknown,
+        dx: number,
+        dy: number
+        ) => unknown;
+    };
+    colormapId?: string;
+    colorLut?: CPUFallbackLookupTable;
+    renderCanvasData?: {
+        data: Uint8ClampedArray;
+    };
+};
+
+declare interface CPUFallbackTransform {
+    reset: () => void;
+    clone: () => CPUFallbackTransform;
+    multiply: (matrix: TransformMatrix2D) => void;
+    getMatrix: () => TransformMatrix2D;
+    invert: () => void;
+    rotate: (rad: number) => void;
+    translate: (x: number, y: number) => void;
+    scale: (sx: number, sy: number) => void;
+    transformPoint: (point: Point2) => Point2;
+}
+
+declare type CPUFallbackViewport = {
+    scale?: number;
+    translation?: {
+        x: number;
+        y: number;
+    };
+    voi?: {
+        windowWidth: number;
+        windowCenter: number;
+    };
+    invert?: boolean;
+    pixelReplication?: boolean;
+    rotation?: number;
+    hflip?: boolean;
+    vflip?: boolean;
+    modalityLUT?: CPUFallbackLUT;
+    voiLUT?: CPUFallbackLUT;
+    colormap?: CPUFallbackColormap;
+    displayedArea?: CPUFallbackViewportDisplayedArea;
+    modality?: string;
+};
+
+declare type CPUFallbackViewportDisplayedArea = {
+    tlhc: {
+        x: number;
+        y: number;
+    };
+    brhc: {
+        x: number;
+        y: number;
+    };
+    rowPixelSpacing: number;
+    columnPixelSpacing: number;
+    presentationSizeMode: string;
+};
+
+declare type CPUIImageData = {
+    dimensions: Point3
+    direction: Float32Array
+    spacing: Point3
+    origin: Point3
+    imageData: CPUImageData
+    metadata: { Modality: string }
+    scalarData: number[]
+    scaling: Scaling
+}
+
+declare type CPUImageData = {
+    worldToIndex?: (point: Point3) => Point3
+    indexToWorld?: (point: Point3) => Point3
+    getWorldToIndex?: () => Point3
+    getIndexToWorld?: () => Point3
+    /** Last spacing is always EPSILON */
+    getSpacing?: () => Point3
+    getDirection?: () => Float32Array
+    getScalarData?: () => number[]
+    /** Last index is always 1 */
+    getDimensions?: () => Point3
+}
+
+declare function createCameraPositionSynchronizer(synchronizerName: string): Synchronizer;
+
+declare function createMergedLabelmapForIndex(labelmaps: Array<Types_2.IImageVolume>, segmentIndex?: number, uid?: string): Types_2.IImageVolume;
+
+declare function createNewSegmentationForToolGroup(toolGroupUID: string, options?: {
+    volumeUID?: string;
+    scalarData?: Float32Array | Uint8Array;
+    targetBuffer?: {
+        type: 'Float32Array' | 'Uint8Array';
+    };
+    metadata?: any;
+    dimensions?: Types_2.Point3;
+    spacing?: Types_2.Point3;
+    origin?: Types_2.Point3;
+    direction?: Float32Array;
+}): Promise<string>;
+
+declare function createSynchronizer(synchronizerId: string, eventName: string, eventHandler: ISynchronizerEventHandler): Synchronizer;
+
+declare function createToolGroup(toolGroupUID: string): IToolGroup | undefined;
+
+declare function createVOISynchronizer(synchronizerName: string): Synchronizer;
+
+declare interface CrosshairsAnnotation extends Annotation {
+    data: {
+        handles: {
+            rotationPoints: any[];
+            slabThicknessPoints: any[];
+            activeOperation: number | null;
+            toolCenter: Types_2.Point3;
+        };
+        activeViewportUIDs: string[];
+        viewportUID: string;
+    };
+}
+
+export declare class CrosshairsTool extends AnnotationTool {
+    static toolName: string;
+    toolCenter: Types_2.Point3;
+    _getReferenceLineColor?: (viewportUID: string) => string;
+    _getReferenceLineControllable?: (viewportUID: string) => boolean;
+    _getReferenceLineDraggableRotatable?: (viewportUID: string) => boolean;
+    _getReferenceLineSlabThicknessControlsOn?: (viewportUID: string) => boolean;
+    editData: {
+        annotation: any;
+    } | null;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    initializeViewport: ({ renderingEngineUID, viewportUID, }: Types_2.IViewportUID) => {
+        normal: Types_2.Point3;
+        point: Types_2.Point3;
+    };
+    init: (viewports: ViewportInputs) => void;
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType, interactionType: string) => CrosshairsAnnotation;
+    cancel: () => void;
+    getHandleNearImagePoint(element: HTMLElement, annotation: Annotation, canvasCoords: Types_2.Point2, proximity: number): ToolHandle | undefined;
+    handleSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: Annotation, handle: ToolHandle, interactionType?: string) => void;
+    isPointNearTool: (element: HTMLElement, annotation: CrosshairsAnnotation, canvasCoords: Types_2.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: Annotation, interactionType: InteractionTypes) => void;
+    onCameraModified: (evt: any) => void;
+    mouseMoveCallback: (evt: EventTypes_2.MouseMoveEventType, filteredToolAnnotations: Annotations) => boolean;
+    filterInteractableAnnotationsForElement: (element: any, annotations: any) => any;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _autoPanViewportIfNecessary(viewportUID: string, renderingEngine: Types_2.IRenderingEngine): void;
+    _areViewportUIDArraysEqual: (viewportUIDArrayOne: any, viewportUIDArrayTwo: any) => boolean;
+    _getAnnotationsForViewportsWithDifferentCameras: (enabledElement: any, annotations: any) => any;
+    _filterLinkedViewportWithSameOrientationAndScene: (enabledElement: any, annotations: any) => any;
+    _filterAnnotationsByUniqueViewportOrientations: (enabledElement: any, annotations: any) => any[];
+    _checkIfViewportsRenderingSameScene: (viewport: any, otherViewport: any) => boolean;
+    _jump: (enabledElement: any, jumpWorld: any) => boolean;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _mouseDragCallback: (evt: MouseDragEventType) => void;
+    _isClockWise(a: any, b: any, c: any): boolean;
+    _applyDeltaShiftToSelectedViewportCameras(renderingEngine: any, viewportsAnnotationsToUpdate: any, delta: any): void;
+    _applyDeltaShiftToViewportCamera(renderingEngine: Types_2.IRenderingEngine, annotation: any, delta: any): void;
+    _pointNearReferenceLine: (annotation: any, canvasCoords: any, proximity: any, lineViewport: any) => boolean;
+    _getRotationHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
+    _getSlabThicknessHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
+    _pointNearTool(element: any, annotation: any, canvasCoords: any, proximity: any): boolean;
+}
+
+declare const CursorNames: string[];
+
+declare namespace cursors {
+    export {
+        MouseCursor,
+        ImageMouseCursor,
+        SVGMouseCursor,
+        elementCursor,
+        registerCursor,
+        CursorNames,
+        setCursorForElement
+    }
+}
+export { cursors }
+
+declare interface CustomEvent_2<T = any> extends Event {
+    /**
+     * Returns any custom data event was created with. Typically used for synthetic events.
+     */
+    readonly detail: T
+    initCustomEvent(
+    typeArg: string,
+    canBubbleArg: boolean,
+    cancelableArg: boolean,
+    detailArg: T
+    ): void
+}
+
+declare function debounce(func: Function, wait?: number, options?: {
+    leading?: boolean;
+    maxWait?: number;
+    trailing?: boolean;
+}): Function;
+
+declare function deepmerge(target?: {}, source?: {}, optionsArgument?: any): any;
+
+declare const _default: {
+    createToolGroup: typeof createToolGroup;
+    destroy: typeof destroy_3;
+    destroyToolGroupByToolGroupUID: typeof destroyToolGroupByToolGroupUID;
+    getToolGroupByToolGroupUID: typeof getToolGroupByToolGroupUID;
+    getToolGroup: typeof getToolGroup;
+    getAllToolGroups: typeof getAllToolGroups;
+};
+
+declare const _default_10: {
+    findClosestPoint: typeof findClosestPoint;
+    liangBarksyClip: typeof clip;
+};
+
+declare const _default_11: {
+    pointInEllipse: typeof pointInEllipse;
+    getCanvasEllipseCorners: typeof getCanvasEllipseCorners;
+};
+
+declare const _default_12: {
+    filterAnnotationsWithinSlice: typeof filterAnnotationsWithinSlice;
+    getWorldWidthAndHeightFromCorners: typeof getWorldWidthAndHeightFromCorners;
+    filterAnnotationsForDisplay: typeof filterAnnotationsForDisplay;
+    getPointInLineOfSightWithCriteria: typeof getPointInLineOfSightWithCriteria;
+};
+
+declare const _default_13: {
+    filterViewportsWithToolEnabled: typeof filterViewportsWithToolEnabled;
+    filterViewportsWithFrameOfReferenceUID: typeof filterViewportsWithFrameOfReferenceUID;
+    getViewportUIDsWithToolToRender: typeof getViewportUIDsWithToolToRender;
+};
+
+declare const _default_14: {
+    snapFocalPointToSlice: typeof snapFocalPointToSlice;
+    getSliceRange: typeof getSliceRange;
+    scrollThroughStack: typeof scrollThroughStack;
+};
+
+declare const _default_15: {
+    getTextBoxCoordsCanvas: typeof getTextBoxCoordsCanvas;
+};
+
+declare const _default_16: {
+    getBoundingBoxAroundShape: typeof getBoundingBoxAroundShape;
+    extend2DBoundingBoxInViewAxis: typeof extend2DBoundingBoxInViewAxis;
+    thresholdVolumeByRange: typeof thresholdVolumeByRange;
+    thresholdVolumeByRoiStats: typeof thresholdVolumeByRoiStats;
+    createMergedLabelmapForIndex: typeof createMergedLabelmapForIndex;
+    isValidRepresentationConfig: typeof isValidRepresentationConfig;
+    getDefaultRepresentationConfig: typeof getDefaultRepresentationConfig;
+};
+
+declare const _default_17: {
+    math: typeof math;
+    planar: typeof planar;
+    viewportFilters: typeof viewportFilters;
+    stackScrollTool: typeof stackScrollTool;
+    drawing: typeof drawing_2;
+    debounce: typeof debounce;
+    deepMerge: (target?: {}, source?: {}, optionsArgument?: any) => any;
+    throttle: typeof throttle;
+    isObject: typeof isObject;
+    triggerEvent: typeof triggerEvent;
+    calibrateImageSpacing: typeof calibrateImageSpacing;
+    transformPhysicalToIndex: typeof transformPhysicalToIndex;
+    segmentation: typeof segmentation_2;
+    triggerAnnotationRenderForViewportUIDs: typeof triggerAnnotationRenderForViewportUIDs;
+    pointInShapeCallback: typeof pointInShapeCallback;
+    pointInSurroundingSphereCallback: typeof pointInSurroundingSphereCallback;
+    getAnnotationNearPoint: typeof getAnnotationNearPoint;
+    getAnnotationNearPointOnEnabledElement: typeof getAnnotationNearPointOnEnabledElement;
+};
+
+declare const _default_2: {
+    draw: typeof draw;
+    drawCircle: typeof drawCircle;
+    drawEllipse: typeof drawEllipse;
+    drawHandles: typeof drawHandles;
+    drawLine: typeof drawLine;
+    drawLinkedTextBox: typeof drawLinkedTextBox;
+    drawRect: typeof drawRect;
+    drawTextBox: typeof drawTextBox;
+};
+
+declare const _default_3: {
+    getActiveSegmentationInfo: typeof getActiveSegmentationInfo;
+    setActiveSegmentation: typeof setActiveSegmentation;
+};
+
+declare const _default_4: {
+    getSegmentIndexLocked: typeof getSegmentIndexLocked;
+    setSegmentIndexLocked: typeof setSegmentIndexLocked;
+    getSegmentIndexLockedForSegmentation: typeof getSegmentIndexLockedForSegmentation;
+    setSegmentIndexLockedForSegmentation: typeof setSegmentIndexLockedForSegmentation;
+    getSegmentsLockedForSegmentation: typeof getSegmentsLockedForSegmentation;
+};
+
+declare const _default_5: {
+    getColorForSegmentIndex: typeof getColorForSegmentIndex;
+    addColorLUT: typeof addColorLUT_2;
+};
+
+declare const _default_6: {
+    getGlobalSegmentationConfig: typeof getGlobalSegmentationConfig_2;
+    setGlobalSegmentationConfig: typeof setGlobalSegmentationConfig_2;
+    getGlobalRepresentationConfig: typeof getGlobalRepresentationConfig;
+    setGlobalRepresentationConfig: typeof setGlobalRepresentationConfig;
+    updateGlobalSegmentationConfig: typeof updateGlobalSegmentationConfig;
+    updateGlobalRepresentationConfig: typeof updateGlobalRepresentationConfig;
+    getSegmentationConfig: typeof getSegmentationConfig_2;
+    setSegmentationConfig: typeof setSegmentationConfig_2;
+    setRepresentationConfig: typeof setRepresentationConfig;
+    getRepresentationConfig: typeof getRepresentationConfig;
+};
+
+declare const _default_7: {
+    setSegmentationVisibility: typeof setSegmentationVisibility;
+    getSegmentationVisibility: typeof getSegmentationVisibility;
+};
+
+declare const _default_8: {
+    getActiveSegmentIndex: typeof getActiveSegmentIndex;
+    setActiveSegmentIndex: typeof setActiveSegmentIndex;
+    getActiveSegmentIndexForSegmentation: typeof getActiveSegmentIndexForSegmentation;
+    setActiveSegmentIndexForSegmentation: typeof setActiveSegmentIndexForSegmentation;
+};
+
+declare const _default_9: {
+    vec2: {
+        findClosestPoint: findClosestPoint;
+        liangBarksyClip: clip;
+    };
+    ellipse: {
+        pointInEllipse: pointInEllipse;
+        getCanvasEllipseCorners: getCanvasEllipseCorners;
+    };
+    lineSegment: {
+        distanceToPoint: distanceToPoint;
+        distanceToPointSquared: distanceToPointSquared;
+        intersectLine: intersectLine;
+    };
+    rectangle: {
+        distanceToPoint: distanceToPoint_2;
+    };
+};
+
+export declare function destroy(): void;
+
+declare function destroy_2(): void;
+
+declare function destroy_3(): void;
+
+declare function destroySynchronizerById(synchronizerId: string): void;
+
+declare function destroyToolGroupByToolGroupUID(toolGroupUID: string): void;
+
+declare function distanceToPoint(lineStart: Types_2.Point2, lineEnd: Types_2.Point2, point: Types_2.Point2): number;
+
+declare function distanceToPoint_2(rect: number[], point: Types_2.Point2): number;
+
+declare function distanceToPointSquared(lineStart: Types_2.Point2, lineEnd: Types_2.Point2, point: Types_2.Point2): number;
+
+declare function draw(element: HTMLElement, fn: (svgDrawingElement: any) => any): void;
+
+declare function drawCircle(svgDrawingHelper: any, toolName: string, annotationUID: string, circleUID: string, center: Types_2.Point2, radius: number, options?: {}): void;
+
+declare function drawEllipse(svgDrawingHelper: any, toolName: string, annotationUID: string, ellipseUID: string, corner1: Types_2.Point2, corner2: Types_2.Point2, options?: {}): void;
+
+declare function drawHandles(svgDrawingHelper: any, toolName: string, annotationUID: string, handleGroupUID: string, handlePoints: Array<Types_2.Point2>, options?: {}): void;
+
+declare namespace drawing {
+    export {
+        draw,
+        drawCircle,
+        drawEllipse,
+        drawHandles,
+        drawLine,
+        drawLinkedTextBox,
+        drawRect,
+        drawTextBox,
+        _default_2 as default
+    }
+}
+export { drawing }
+
+declare namespace drawing_2 {
+    export {
+        getTextBoxCoordsCanvas,
+        _default_15 as default
+    }
+}
+
+declare function drawLine(svgDrawingHelper: any, toolName: string, annotationUID: string, lineUID: string, start: Types_2.Point2, end: Types_2.Point2, options?: {}): void;
+
+declare function drawLinkedTextBox(svgDrawingHelper: Record<string, unknown>, toolName: string, annotationUID: string, textBoxUID: string, textLines: Array<string>, textBoxPosition: Types_2.Point2, annotationAnchorPoints: Array<Types_2.Point2>, textBox: unknown, options?: {}): SVGRect;
+
+declare function drawRect(svgDrawingHelper: any, toolName: string, annotationUID: string, rectangleUID: string, start: Types_2.Point2, end: Types_2.Point2, options?: {}): void;
+
+declare function drawTextBox(svgDrawingHelper: Record<string, unknown>, toolName: string, annotationUID: string, textUID: string, textLines: Array<string>, position: Types_2.Point2, options?: {}): SVGRect;
+
+declare namespace elementCursor {
+    export {
+        initElementCursor,
+        resetElementCursor,
+        hideElementCursor,
+        _setElementCursor as setElementCursor
+    }
+}
+
+/**
+ * ELEMENT_DISABLED Event type
+ */
+declare type ElementDisabledEvent = CustomEvent_2<ElementDisabledEventDetail>
+
+/**
+ * ELEMENT_DISABLED Event's data
+ */
+declare type ElementDisabledEventDetail = {
+    /** Viewport HTML element in the DOM */
+    element: HTMLElement
+    /** Viewport Unique ID in the renderingEngine */
+    viewportUID: string
+    /** Unique ID for the renderingEngine */
+    renderingEngineUID: string
+}
+
+/**
+ * ELEMENT_ENABLED Event type
+ */
+declare type ElementEnabledEvent = CustomEvent_2<ElementEnabledEventDetail>
+
+/**
+ * ELEMENT_Enabled Event's data
+ */
+declare type ElementEnabledEventDetail = {
+    /** Viewport HTML element in the DOM */
+    element: HTMLElement
+    /** Viewport Unique ID in the renderingEngine */
+    viewportUID: string
+    /** Unique ID for the renderingEngine */
+    renderingEngineUID: string
+}
+
+declare type Ellipse = {
+    center: Types_2.Point3;
+    xRadius: number;
+    yRadius: number;
+    zRadius: number;
+};
+
+declare interface EllipticalRoiAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: [Types_2.Point3, Types_2.Point3, Types_2.Point3, Types_2.Point3];
+            activeHandleIndex: number | null;
+            textBox?: {
+                hasMoved: boolean;
+                worldPosition: Types_2.Point3;
+                worldBoundingBox: {
+                    topLeft: Types_2.Point3;
+                    topRight: Types_2.Point3;
+                    bottomLeft: Types_2.Point3;
+                    bottomRight: Types_2.Point3;
+                };
+            };
+        };
+        label: string;
+        cachedStats?: {
+            [targetUID: string]: {
+                Modality: string;
+                area: number;
+                max: number;
+                mean: number;
+                stdDev: number;
+            };
+        };
+    };
+}
+
+export declare class EllipticalRoiTool extends AnnotationTool {
+    static toolName: string;
+    touchDragCallback: any;
+    mouseDragCallback: any;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: Array<string>;
+        handleIndex?: number;
+        movingTextBox?: boolean;
+        centerCanvas?: Array<number>;
+        canvasWidth?: number;
+        canvasHeight?: number;
+        originalHandleCanvas?: Array<number>;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => EllipticalRoiAnnotation;
+    isPointNearTool: (element: HTMLElement, annotation: EllipticalRoiAnnotation, canvasCoords: Types_2.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: EllipticalRoiAnnotation, interactionType: InteractionTypes) => void;
+    handleSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: EllipticalRoiAnnotation, handle: ToolHandle, interactionType?: string) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _mouseDragDrawCallback: (evt: MouseMoveEventType | MouseDragEventType) => void;
+    _mouseDragModifyCallback: (evt: MouseDragEventType) => void;
+    _dragHandle: (evt: any) => void;
+    cancel: (element: HTMLElement) => any;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _getTextLines: (data: any, targetUID: any) => any[];
+    _calculateCachedStats: (annotation: any, viewport: any, renderingEngine: any, enabledElement: any) => any;
+    _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
+    _pointInEllipseCanvas(ellipse: any, location: Types_2.Point2): boolean;
+}
+
+export declare const Enums: {
+    MouseBindings: typeof MouseBindings;
+    KeyboardBindings: typeof KeyboardBindings;
+    ToolModes: typeof ToolModes;
+    Events: typeof Events;
+    SegmentationRepresentations: typeof SegmentationRepresentations;
+};
+
+declare enum Events {
+    ANNOTATION_ADDED = "CORNERSTONE_TOOLS_ANNOTATION_ADDED",
+    ANNOTATION_MODIFIED = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED",
+    ANNOTATION_REMOVED = "CORNERSTONE_TOOLS_ANNOTATION_REMOVED",
+    ANNOTATION_SELECTION_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_SELECTION_CHANGE",
+    ANNOTATION_LOCK_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE",
+    ANNOTATION_RENDERED = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED",
+    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_DATA_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_DATA_MODIFIED",
+    KEY_DOWN = "CORNERSTONE_TOOLS_KEY_DOWN",
+    KEY_UP = "CORNERSTONE_TOOLS_KEY_UP",
+    MOUSE_DOWN = "CORNERSTONE_TOOLS_MOUSE_DOWN",
+    MOUSE_UP = "CORNERSTONE_TOOLS_MOUSE_UP",
+    MOUSE_DOWN_ACTIVATE = "CORNERSTONE_TOOLS_MOUSE_DOWN_ACTIVATE",
+    MOUSE_DRAG = "CORNERSTONE_TOOLS_MOUSE_DRAG",
+    MOUSE_MOVE = "CORNERSTONE_TOOLS_MOUSE_MOVE",
+    MOUSE_CLICK = "CORNERSTONE_TOOLS_MOUSE_CLICK",
+    MOUSE_DOUBLE_CLICK = "CORNERSTONE_TOOLS_MOUSE_DOUBLE_CLICK",
+    MOUSE_WHEEL = "CORNERSTONE_TOOLS_MOUSE_WHEEL"
+}
+
+declare namespace EventTypes {
+    export {
+        CameraModifiedEventDetail,
+        CameraModifiedEvent,
+        VoiModifiedEvent,
+        VoiModifiedEventDetail,
+        ElementDisabledEvent,
+        ElementDisabledEventDetail,
+        ElementEnabledEvent,
+        ElementEnabledEventDetail,
+        ImageRenderedEventDetail,
+        ImageRenderedEvent,
+        ImageVolumeModifiedEvent,
+        ImageVolumeModifiedEventDetail,
+        ImageLoadedEvent,
+        ImageLoadedEventDetail,
+        ImageLoadedFailedEventDetail,
+        ImageLoadedFailedEvent,
+        VolumeLoadedEvent,
+        VolumeLoadedEventDetail,
+        VolumeLoadedFailedEvent,
+        VolumeLoadedFailedEventDetail,
+        ImageCacheImageAddedEvent,
+        ImageCacheImageAddedEventDetail,
+        ImageCacheImageRemovedEvent,
+        ImageCacheImageRemovedEventDetail,
+        VolumeCacheVolumeAddedEvent,
+        VolumeCacheVolumeAddedEventDetail,
+        VolumeCacheVolumeRemovedEvent,
+        VolumeCacheVolumeRemovedEventDetail,
+        StackNewImageEvent,
+        StackNewImageEventDetail,
+        ImageSpacingCalibratedEvent,
+        ImageSpacingCalibratedEventDetail,
+        ImageLoadProgressEvent,
+        ImageLoadProgressEventDetail
+    }
+}
+
+declare namespace EventTypes_2 {
+    export {
+        NormalizedMouseEventDetail,
+        NormalizedMouseEventType,
+        AnnotationAddedEventDetail,
+        AnnotationAddedEventType,
+        AnnotationModifiedEventDetail,
+        AnnotationModifiedEventType,
+        AnnotationRemovedEventDetail,
+        AnnotationRemovedEventType,
+        AnnotationSelectionChangeEventDetail,
+        AnnotationSelectionChangeEventType,
+        AnnotationRenderedEventDetail,
+        AnnotationRenderedEventType,
+        AnnotationLockChangeEventDetail,
+        AnnotationLockChangeEventType,
+        SegmentationDataModifiedEventType,
+        SegmentationStateModifiedEventDetail,
+        SegmentationStateModifiedEventType,
+        SegmentationDataModifiedEventDetail,
+        SegmentationRenderedEventType,
+        SegmentationRenderedEventDetail,
+        SegmentationGlobalStateModifiedEventType,
+        SegmentationGlobalStateModifiedEventDetail,
+        KeyDownEventDetail,
+        KeyDownEventType,
+        KeyUpEventDetail,
+        KeyUpEventType,
+        MouseDownEventDetail,
+        MouseDownEventType,
+        MouseDownActivateEventDetail,
+        MouseDownActivateEventType,
+        MouseDragEventDetail,
+        MouseDragEventType,
+        MouseUpEventDetail,
+        MouseUpEventType,
+        MouseClickEventDetail,
+        MouseClickEventType,
+        MouseMoveEventDetail,
+        MouseMoveEventType,
+        MouseDoubleClickEventDetail,
+        MouseDoubleClickEventType,
+        MouseWheelEventDetail,
+        MouseWheelEventType
+    }
+}
+
+declare function extend2DBoundingBoxInViewAxis(boundsIJK: [Types_2.Point2, Types_2.Point2, Types_2.Point2], numSlicesToProject: number): [Types_2.Point2, Types_2.Point2, Types_2.Point2];
+
+declare function filterAnnotationsForDisplay(viewport: Types_2.IViewport, annotations: Annotations): Annotations;
+
+declare function filterAnnotationsWithinSlice(annotations: Annotations, camera: Types_2.ICamera, spacingInNormalDirection: number): Annotations;
+
+declare interface FilterInterface {
+    FrameOfReferenceUID?: string;
+    toolName?: string;
+}
+
+declare function filterViewportsWithFrameOfReferenceUID(viewports: Array<Types_2.IStackViewport | Types_2.IVolumeViewport>, FrameOfReferenceUID: string): Array<Types_2.IStackViewport | Types_2.IVolumeViewport>;
+
+declare function filterViewportsWithToolEnabled(viewports: Array<Types_2.IStackViewport | Types_2.IVolumeViewport>, toolName: string): Array<Types_2.IStackViewport | Types_2.IVolumeViewport>;
+
+declare function findClosestPoint(sourcePoints: Array<Types_2.Point2>, targetPoint: Types_2.Point2): Types_2.Point2;
+
+/**
+ * Flip direction which can be horizontal or vertical.
+ */
+declare type FlipDirection = {
+    flipHorizontal?: boolean
+    flipVertical?: boolean
+}
+
+declare class FrameOfReferenceSpecificAnnotationManager {
+    private annotations;
+    readonly uid: string;
+    constructor(uid?: string);
+    _imageVolumeModifiedHandler: (evt: Types_2.EventTypes.ImageVolumeModifiedEvent) => void;
+    getFramesOfReference: () => Array<string>;
+    getFrameOfReferenceAnnotations: (FrameOfReferenceUID: string) => FrameOfReferenceSpecificAnnotations;
+    get: (FrameOfReferenceUID: string, toolName: string) => Annotations | undefined;
+    getAnnotation: (annotationUID: string, filter?: FilterInterface) => Annotation | undefined;
+    addAnnotation: (annotation: Annotation) => void;
+    removeAnnotation: (annotationUID: string, filter?: FilterInterface) => void;
+    saveAnnotations: (FrameOfReferenceUID?: string, toolName?: string) => AnnotationState | FrameOfReferenceSpecificAnnotations | Annotations;
+    restoreAnnotations: (state: AnnotationState | FrameOfReferenceSpecificAnnotations | Annotations, FrameOfReferenceUID?: string, toolName?: string) => void;
+    private _getToolSpecificAnnotationsAndIndex;
+}
+
+declare type FrameOfReferenceSpecificAnnotations = {
+    [key: string]: Annotations;
+};
+
+declare function getActiveSegmentationData(toolGroupUID: string): ToolGroupSpecificSegmentationData | undefined;
+
+declare function getActiveSegmentationInfo(toolGroupUID: string): {
+    volumeUID: string;
+    segmentationDataUID: string;
+    activeSegmentIndex: number;
+};
+
+declare function getActiveSegmentIndex(toolGroupUID: string): number | undefined;
+
+declare function getActiveSegmentIndexForSegmentation(segmentationUID: string): number | undefined;
+
+declare function getAllSynchronizers(): Array<Synchronizer>;
+
+declare function getAllToolGroups(): Array<IToolGroup>;
+
+declare function getAnnotation(annotationUID: string, element?: HTMLElement): Annotation;
+
+declare function getAnnotationNearPoint(element: HTMLElement, canvasPoint: Types_2.Point2, proximity?: number): Annotation | null;
+
+declare function getAnnotationNearPointOnEnabledElement(enabledElement: Types_2.IEnabledElement, point: Types_2.Point2, proximity: number): Annotation | null;
+
+declare function getAnnotations(element: HTMLElement, toolName: string): Annotations;
+
+declare function getAnnotationSelected(annotationUID: string): Annotation;
+
+declare function getAnnotationsLocked(): Array<Annotation>;
+
+declare function getAnnotationsLockedCount(): number;
+
+declare function getAnnotationsSelected(): Array<Annotation>;
+
+declare function getAnnotationsSelectedByToolName(toolName: string): Array<Annotation>;
+
+declare function getAnnotationsSelectedCount(): number;
+
+declare function getBoundingBoxAroundShape(vertices: Types_2.Point3[], dimensions?: Types_2.Point3): [Types_2.Point2, Types_2.Point2, Types_2.Point2];
+
+declare function getCanvasEllipseCorners(ellipseCanvasPoints: canvasCoordinates): Array<Types_2.Point2>;
+
+declare function getColorForSegmentIndex(toolGroupUID: string, segmentationDataUID: string, segmentIndex: number): Color;
+
+declare function getColorLut(index: number): ColorLUT | undefined;
+
+declare function getDefaultAnnotationManager(): FrameOfReferenceSpecificAnnotationManager;
+
+declare function getDefaultRepresentationConfig(representationType: string): 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 getGlobalSegmentationDataByUID(segmentationUID: string): GlobalSegmentationData;
+
+declare function getGlobalSegmentationState(): GlobalSegmentationState | [];
+
+declare function getPointInLineOfSightWithCriteria(viewport: Types_2.IVolumeViewport, worldPos: Types_2.Point3, targetVolumeUID: string, criteriaFunction: (intensity: number, point: Types_2.Point3) => Types_2.Point3, stepSize?: number): Types_2.Point3;
+
+declare function getRepresentationConfig(toolGroupUID: string, representationType: SegmentationRepresentations): RepresentationConfig;
+
+declare function getSegmentationConfig(toolGroupUID: string): SegmentationConfig;
+
+declare function getSegmentationConfig_2(toolGroupUID: string): SegmentationConfig;
+
+declare function getSegmentationDataByUID(toolGroupUID: string, segmentationDataUID: string): ToolGroupSpecificSegmentationData | undefined;
+
+declare function getSegmentationState(toolGroupUID: string): ToolGroupSpecificSegmentationState | [];
+
+declare function getSegmentationVisibility(toolGroupUID: string, segmentationDataUID: string): boolean | undefined;
+
+declare function getSegmentIndexLocked(toolGroupUID: string, segmentIndex: number): boolean;
+
+declare function getSegmentIndexLockedForSegmentation(segmentationUID: string, segmentIndex: number): boolean;
+
+declare function getSegmentsLockedForSegmentation(segmentationUID: string): number[] | [];
+
+declare function getSliceRange(volumeActor: Types_2.VolumeActor, viewPlaneNormal: Types_2.Point3, focalPoint: Types_2.Point3): {
+    min: number;
+    max: number;
+    current: number;
+};
+
+declare function getState(annotation?: Annotation): AnnotationStyleStates;
+
+declare function getStyle(toolName?: string, annotation?: Record<string, unknown>): Settings;
+
+declare function getSynchronizerById(synchronizerId: string): Synchronizer | void;
+
+declare function getSynchronizers(renderingEngineUID: string, viewportUID: string): Array<Synchronizer>;
+
+declare function getTextBoxCoordsCanvas(annotationCanvasPoints: Array<Types_2.Point2>): Types_2.Point2;
+
+declare function getToolGroup(viewportUID: string, renderingEngineUID: string): IToolGroup | undefined;
+
+declare function getToolGroupByToolGroupUID(toolGroupUID: string): IToolGroup | undefined;
+
+declare function getToolGroups(): string[];
+
+declare function getToolGroupsWithSegmentation(segmentationUID: string): string[];
+
+declare function getViewportSpecificAnnotationManager(element?: Types_2.IEnabledElement | HTMLElement): FrameOfReferenceSpecificAnnotationManager;
+
+declare function getViewportUIDsWithToolToRender(element: HTMLElement, toolName: string, requireSameOrientation?: boolean): string[];
+
+declare function getWorldWidthAndHeightFromCorners(viewPlaneNormal: Types_2.Point3, viewUp: Types_2.Point3, topLeftWorld: Types_2.Point3, bottomRightWorld: Types_2.Point3): {
+    worldWidth: number;
+    worldHeight: number;
+};
+
+declare type GlobalSegmentationData = {
+    volumeUID: string;
+    label: string;
+    referenceVolumeUID?: 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 {
+    toolGroupUID: string;
+    supportedInteractionTypes: InteractionTypes[];
+    mode: ToolModes;
+    configuration: {
+        preventHandleOutsideImage?: boolean;
+        strategies?: Record<string, any>;
+        defaultStrategy?: string;
+        activeStrategy?: string;
+        strategyOptions?: Record<string, unknown>;
+    };
+}
+
+declare interface ICache {
+    /** Set the maximum cache size  */
+    setMaxCacheSize: (maxCacheSize: number) => void
+    /** Get the maximum cache size  */
+    getMaxCacheSize: () => number
+    /** Get the current cache size  */
+    getCacheSize: () => number
+    /** Stores the imageLoad Object inside the cache */
+    putImageLoadObject: (
+    imageId: string,
+    imageLoadObject: IImageLoadObject
+    ) => Promise<any>
+    /** Retrieves the imageLoad Object from the cache */
+    getImageLoadObject: (imageId: string) => IImageLoadObject | void
+    /** Stores the volumeLoad Object inside the cache */
+    putVolumeLoadObject: (
+    volumeId: string,
+    volumeLoadObject: IVolumeLoadObject
+    ) => Promise<any>
+    /** Retrieves the volumeLoad Object from the cache */
+    getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject | void
+    /** Purge cache both image and volume */
+    purgeCache: () => void
+}
+
+declare interface ICachedImage {
+    image?: IImage
+    imageId: string
+    imageLoadObject: IImageLoadObject
+    loaded: boolean
+    sharedCacheKey?: string
+    timeStamp: number
+    sizeInBytes: number
+}
+
+declare interface ICachedVolume {
+    volume?: IImageVolume
+    volumeId: string
+    volumeLoadObject: IVolumeLoadObject
+    loaded: boolean
+    timeStamp: number
+    sizeInBytes: number
+}
+
+/**
+ * Camera Interface. See {@link https://kitware.github.io/vtk-examples/site/VTKBook/03Chapter3/#35-cameras} if you
+ * want to know more about the camera.
+ */
+declare interface ICamera {
+    /** Camera Clipping range*/
+    clippingRange?: Point2
+    /** Camera Focal point */
+    focalPoint?: Point3
+    /** Camera Parallel Projection flag - whether camera is using parallel projection */
+    parallelProjection?: boolean
+    /** Camera parallel scale - used for parallel projection zoom, smaller values zoom in */
+    parallelScale?: number
+    /** Camera position */
+    position?: Point3
+    /** Camera view angle - 90 degrees is orthographic */
+    viewAngle?: number
+    /** Camera viewPlaneNormal - negative of the direction the camera is pointing or directionOfProjection*/
+    viewPlaneNormal?: Point3
+    /** Camera viewUp - the direction of viewUP in camera */
+    viewUp?: Point3
+    /** Camera Slab Thickness */
+    slabThickness?: number
+}
+
+/**
+ * Cornerstone Enabled Element interface
+ */
+declare interface IEnabledElement {
+    /** Cornerstone Viewport instance - can be Stack or Volume Viewport as of now */
+    viewport: IStackViewport | IVolumeViewport
+    /** Cornerstone Rendering Engine instance */
+    renderingEngine: IRenderingEngine
+    /** Unique ID of the viewport in the renderingEngine */
+    viewportUID: string
+    /** Unique ID of the renderingEngine */
+    renderingEngineUID: string
+    /** FrameOfReference the enabledElement is rendering inside */
+    FrameOfReferenceUID: string
+}
+
+/**
+ * Cornerstone Image interface, it is used for both CPU and GPU rendering
+ */
+declare interface IImage {
+    /** Image Id */
+    imageId: string
+    sharedCacheKey?: string
+    /** minimum pixel value of the image */
+    minPixelValue: number
+    /* maximum pixel value of the image */
+    maxPixelValue: number
+    /** slope from metadata for scaling */
+    slope: number
+    /** intercept from metadata for scaling */
+    intercept: number
+    /** windowCenter from metadata */
+    windowCenter: number[] | number
+    /** windowWidth from metadata */
+    windowWidth: number[] | number
+    /** function that returns the pixelData as an array */
+    getPixelData: () => Array<number>
+    getCanvas: () => HTMLCanvasElement
+    /** image number of rows */
+    rows: number
+    /** image number of columns */
+    columns: number
+    /** image height */
+    height: number
+    /** image width */
+    width: number
+    /** is image a color image */
+    color: boolean
+    /** is image rgb and alpha */
+    rgba: boolean
+    /** number of components in the image */
+    numComps: number
+    /** CPU: custom render method for the image */
+    render?: (
+    enabledElement: CPUFallbackEnabledElement,
+    invalidated: boolean
+    ) => unknown
+    /** column pixel spacing */
+    columnPixelSpacing: number
+    /** row pixel spacing */
+    rowPixelSpacing: number
+    /** slice thickness */
+    sliceThickness?: number
+    /** whether image pixels are inverted in color */
+    invert: boolean
+    /** image size in number of bytes */
+    sizeInBytes: number
+    /** CPU: custom modality LUT for image  */
+    modalityLUT?: CPUFallbackLUT
+    /** CPU: custom VOI LUT for image  */
+    voiLUT?: CPUFallbackLUT
+    /** CPU: custom color map for image  */
+    colormap?: CPUFallbackColormap
+    /** image scaling metadata - including PT suv values */
+    scaling?: {
+        PET?: {
+            // @TODO: Do these values exist?
+            SUVlbmFactor?: number
+            SUVbsaFactor?: number
+            // accessed in ProbeTool
+            suvbwToSuvlbm?: number
+            suvbwToSuvbsa?: number
+        }
+    }
+    /** CPU: image statistics for rendering */
+    stats?: {
+        lastStoredPixelDataToCanvasImageDataTime?: number
+        lastGetPixelDataTime?: number
+        lastPutImageDataTime?: number
+        lastLutGenerateTime?: number
+        lastRenderedViewport?: unknown
+        lastRenderTime?: number
+    }
+    /** CPU: image cached LUT */
+    cachedLut?: {
+        windowWidth?: number | number[]
+        windowCenter?: number | number[]
+        invert?: boolean
+        lutArray?: Uint8ClampedArray
+        modalityLUT?: unknown
+        voiLUT?: CPUFallbackLUT
+    }
+}
+
+/**
+ * IImageData of an image, which stores actual scalarData and metaData about the image.
+ * IImageData is different from vtkImageData.
+ */
+declare interface IImageData {
+    /** image dimensions */
+    dimensions: Point3
+    /** image direction */
+    direction: Float32Array
+    /** image spacing */
+    spacing: Point3
+    /** image origin */
+    origin: Point3
+    /** image scalarData which stores the array of pixelData */
+    scalarData: Float32Array
+    /** vtkImageData object */
+    imageData: vtkImageData
+    /** image metadata - currently only modality */
+    metadata: { Modality: string }
+    /** image scaling for scaling pixelArray */
+    scaling?: Scaling
+}
+
+/**
+ * ImageLoadObject interface which any imageLoader should return
+ */
+declare interface IImageLoadObject {
+    /** promise that resolves to an image */
+    promise: Promise<IImage>
+    /** optional cancel function for loading*/
+    cancel?: () => void
+    /** optional decache function */
+    decache?: () => void
+}
+
+/**
+ * Cornerstone ImageVolume interface. Todo: we should define new IVolume class
+ * with appropriate typings for the other types of volume that don't have images (nrrd, nifti)
+ */
+declare interface IImageVolume {
+    /** unique identifier of the volume in the cache */
+    readonly uid: string
+    /** volume dimensions */
+    dimensions: Point3
+    /** volume direction */
+    direction: Float32Array
+    /** volume metadata */
+    metadata: Metadata
+    /** volume origin - set to the imagePositionPatient of the last image in the volume */
+    origin: Point3
+    /** volume scalar data */
+    scalarData: any
+    /** volume scaling metadata */
+    scaling?: {
+        PET?: {
+            SUVlbmFactor?: number
+            SUVbsaFactor?: number
+            suvbwToSuvlbm?: number
+            suvbwToSuvbsa?: number
+        }
+    }
+    /** volume size in bytes */
+    sizeInBytes?: number
+    /** volume spacing */
+    spacing: Point3
+    /** number of voxels in the volume */
+    numVoxels: number
+    /** volume image data as vtkImageData */
+    imageData?: vtkImageData
+    /** openGL texture for the volume */
+    vtkOpenGLTexture: any
+    /** loading status object for the volume containing loaded/loading statuses */
+    loadStatus?: Record<string, any>
+    /** imageIds of the volume (if it is built of separate imageIds) */
+    imageIds?: Array<string>
+    /** volume referenceVolumeUID (if it is derived from another volume) */
+    referenceVolumeUID?: 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,
+    imageIdIndex: number
+    ) => IImageLoadObject
+}
+
+/**
+ * IMAGE_CACHE_IMAGE_ADDED Event type
+ */
+declare type ImageCacheImageAddedEvent =
+CustomEvent_2<ImageCacheImageAddedEventDetail>
+
+/**
+ * IMAGE_CACHE_IMAGE_ADDED Event's data
+ */
+declare type ImageCacheImageAddedEventDetail = {
+    /** the added image */
+    image: ICachedImage
+}
+
+/**
+ * IMAGE_CACHE_IMAGE_REMOVED Event type
+ */
+declare type ImageCacheImageRemovedEvent =
+CustomEvent_2<ImageCacheImageRemovedEventDetail>
+
+/**
+ * IMAGE_CACHE_IMAGE_REMOVED Event's data
+ */
+declare type ImageCacheImageRemovedEventDetail = {
+    /** the removed image id */
+    imageId: string
+}
+
+/**
+ * IMAGE_LOADED Event type
+ */
+declare type ImageLoadedEvent = CustomEvent_2<ImageLoadedEventDetail>
+
+/**
+ * IMAGE_LOADED Event's data
+ */
+declare type ImageLoadedEventDetail = {
+    /** the loaded image */
+    image: IImage
+}
+
+/**
+ * IMAGE_LOADED_FAILED Event type
+ */
+declare type ImageLoadedFailedEvent = CustomEvent_2<ImageLoadedFailedEventDetail>
+
+/**
+ * IMAGE_LOADED_FAILED Event's data
+ */
+declare type ImageLoadedFailedEventDetail = {
+    /** the imageId for the image */
+    imageId: string
+    error: unknown
+}
+
+/**
+ * Any imageLoader function should implement a loading given the imageId
+ * and returns a mandatory promise which will resolve to the loaded image object.
+ * Additional `cancelFn` and `decache` can be implemented.
+ */
+declare type ImageLoaderFn = (
+imageId: string,
+options?: Record<string, any>
+) => {
+    /** Promise that resolves to the image object */
+    promise: Promise<Record<string, any>>
+    cancelFn?: () => void | undefined
+    decache?: () => void | undefined
+}
+
+/**
+ * IMAGE_LOAD_PROGRESS
+ */
+declare type ImageLoadProgressEvent = CustomEvent_2<ImageLoadProgressEventDetail>
+
+/**
+ * IMAGE_LOAD_PROGRESS Event's data. Note this is only for one image load and NOT volume load.
+ */
+declare type ImageLoadProgressEventDetail = {
+    /** url we are loading from */
+    url: string
+    /** loading image image id */
+    imageId: string
+    /** the bytes browser receive */
+    loaded: number
+    /** the total bytes settled by the header */
+    total: number
+    /** loaded divided by total * 100 - shows the percentage of the image loaded */
+    percent: number
+}
+
+declare class ImageMouseCursor extends MouseCursor {
+    private url;
+    private x;
+    private y;
+    constructor(url: string, x?: number, y?: number, name?: string | undefined, fallback?: MouseCursor | undefined);
+    getStyleProperty(): string;
+    static getUniqueInstanceName(prefix: string): string;
+}
+
+/**
+ * IMAGE_RENDERED Event type
+ */
+declare type ImageRenderedEvent = CustomEvent_2<ElementEnabledEventDetail>
+
+/**
+ * IMAGE_RENDERED Event's data
+ */
+declare type ImageRenderedEventDetail = {
+    /** Viewport HTML element in the DOM */
+    element: HTMLElement
+    /** Viewport Unique ID in the renderingEngine */
+    viewportUID: string
+    /** Unique ID for the renderingEngine */
+    renderingEngineUID: string
+    /** Whether to suppress the event */
+    suppressEvents?: boolean
+}
+
+/**
+ * IMAGE_SPACING_CALIBRATED
+ */
+declare type ImageSpacingCalibratedEvent =
+CustomEvent_2<ImageSpacingCalibratedEventDetail>
+
+/**
+ * IMAGE_SPACING_CALIBRATED Event's data
+ */
+declare type ImageSpacingCalibratedEventDetail = {
+    element: HTMLElement
+    viewportUID: string
+    renderingEngineUID: string
+    imageId: string
+    rowScale: number
+    columnScale: number
+    imageData: vtkImageData
+    worldToIndex: mat4
+}
+
+/** The base class for volume data. It includes the volume metadata
+ * and the volume data along with the loading status.
+ */
+declare class ImageVolume implements IImageVolume {
+    /** Read-only unique identifier for the volume */
+    readonly uid: string
+    /** Dimensions of the volume */
+    dimensions: Point3
+    /** volume direction in world space */
+    direction: Float32Array
+    /** volume metadata */
+    metadata: Metadata
+    /** volume origin, Note this is an opinionated origin for the volume */
+    origin: Point3
+    /** volume scalar data  */
+    scalarData: Float32Array | Uint8Array
+    /** volume scaling parameters if it contains scaled data */
+    scaling?: {
+        PET?: {
+            // @TODO: Do these values exist?
+            SUVlbmFactor?: number
+            SUVbsaFactor?: number
+            // accessed in ProbeTool
+            suvbwToSuvlbm?: number
+            suvbwToSuvbsa?: number
+        }
+    }
+    /** volume size in bytes */
+    sizeInBytes?: number // Seems weird to pass this in? Why not grab it from scalarData.byteLength
+    /** volume spacing in 3d world space */
+    spacing: Point3
+    /** volume number of voxels */
+    numVoxels: number
+    /** volume image data */
+    imageData?: any
+    /** open gl texture for the volume */
+    vtkOpenGLTexture: any // No good way of referencing vtk classes as they aren't classes.
+    /** load status object for the volume */
+    loadStatus?: Record<string, any>
+    /** optional image ids for the volume if it is made of separated images */
+    imageIds?: Array<string>
+    /** optional reference volume uid if the volume is derived from another volume */
+    referenceVolumeUID?: string
+
+    constructor(props: IVolume) {
+        this.uid = props.uid
+        this.metadata = props.metadata
+        this.dimensions = props.dimensions
+        this.spacing = props.spacing
+        this.origin = props.origin
+        this.direction = props.direction
+        this.imageData = props.imageData
+        this.scalarData = props.scalarData
+        this.sizeInBytes = props.sizeInBytes
+        this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance()
+        this.numVoxels =
+        this.dimensions[0] * this.dimensions[1] * this.dimensions[2]
+
+        if (props.scaling) {
+            this.scaling = props.scaling
+        }
+
+        if (props.referenceVolumeUID) {
+            this.referenceVolumeUID = props.referenceVolumeUID
+        }
+    }
+}
+
+/**
+ * IMAGE_VOLUME_MODIFIED Event type
+ */
+declare type ImageVolumeModifiedEvent = CustomEvent_2<ImageVolumeModifiedEventDetail>
+
+/**
+ * IMAGE_VOLUME_MODIFIED Event's data
+ */
+declare type ImageVolumeModifiedEventDetail = {
+    /** the modified volume */
+    imageVolume: IImageVolume
+    /** FrameOfReferenceUID where the volume belongs to */
+    FrameOfReferenceUID: string
+}
+
+export declare function init(defaultConfiguration?: {}): void;
+
+declare function initElementCursor(element: HTMLElement, cursor: MouseCursor | null): void;
+
+declare type InteractionTypes = 'Mouse';
+
+/**
+ * Interpolation types for image rendering
+ */
+declare enum InterpolationType {
+    /** nearest neighbor interpolation */
+    NEAREST,
+    /** linear interpolation - Default */
+    LINEAR,
+    /** */
+    FAST_LINEAR,
+}
+
+declare function intersectLine(line1Start: Types_2.Point2, line1End: Types_2.Point2, line2Start: Types_2.Point2, line2End: Types_2.Point2): number[];
+
+declare type IPoints = {
+    page: Types_2.Point2;
+    client: Types_2.Point2;
+    canvas: Types_2.Point2;
+    world: Types_2.Point3;
+};
+
+/**
+ * Register image loader interface
+ */
+declare interface IRegisterImageLoader {
+    registerImageLoader: (scheme: string, imageLoader: ImageLoaderFn) => void
+}
+
+declare interface IRenderingEngine {
+    uid: string
+    hasBeenDestroyed: boolean
+    offscreenMultiRenderWindow: any
+    offScreenCanvasContainer: any
+    setViewports(viewports: Array<PublicViewportInput>): void
+    resize(): void
+    getViewport(uid: string): IStackViewport | IVolumeViewport
+    getViewports(): Array<IStackViewport | IVolumeViewport>
+    render(): void
+    renderViewports(viewportUIDs: Array<string>): void
+    renderViewport(viewportUID: string): void
+    renderFrameOfReference(FrameOfReferenceUID: string): void
+    fillCanvasWithBackgroundColor(
+    canvas: HTMLCanvasElement,
+    backgroundColor: [number, number, number]
+    ): void
+    enableElement(viewportInputEntry: PublicViewportInput): void
+    disableElement(viewportUID: string): void
+    getStackViewports(): Array<IStackViewport>
+    getVolumeViewports(): Array<IVolumeViewport>
+    destroy(): void
+    _debugRender(): void
+}
+
+declare function isAnnotationLocked(annotation: Annotation): boolean;
+
+declare function isAnnotationSelected(annotation: Annotation): boolean;
+
+declare function isObject(value: any): boolean;
+
+/**
+ * Interface for Stack Viewport
+ */
+declare interface IStackViewport extends IViewport {
+    modality: string
+    /** Scaling parameters */
+    scaling: Scaling
+    /**
+     * Resizes the viewport - only used in CPU fallback for StackViewport. The
+     * GPU resizing happens inside the RenderingEngine.
+     */
+    resize: () => void
+    /**
+     * Returns the frame of reference UID, if the image doesn't have imagePlaneModule
+     * metadata, it returns undefined, otherwise, frameOfReferenceUID is returned.
+     */
+    getFrameOfReferenceUID: () => string
+    /**
+     * Sets the properties for the viewport on the default actor. Properties include
+     * setting the VOI, inverting the colors and setting the interpolation type, rotation
+     * and flipHorizontal/Vertical.
+     */
+    setProperties({
+        voiRange,
+        invert,
+        interpolationType,
+        rotation,
+        flipHorizontal,
+        flipVertical,
+    }: StackViewportProperties): void
+    /**
+     * Retrieve the viewport properties
+     */
+    getProperties: () => StackViewportProperties
+    /**
+     * canvasToWorld Returns the world coordinates of the given `canvasPos`
+     * projected onto the plane defined by the `Viewport`'s camera.
+     */
+    canvasToWorld: (canvasPos: Point2) => Point3
+    /**
+     * Returns the canvas coordinates of the given `worldPos`
+     * projected onto the `Viewport`'s `canvas`.
+     */
+    worldToCanvas: (worldPos: Point3) => Point2
+    /**
+     * Returns the index of the imageId being renderer
+     */
+    getCurrentImageIdIndex: () => number
+    /**
+     * Returns the list of image Ids for the current viewport
+     */
+    getImageIds: () => string[]
+    /**
+     * Returns the currently rendered imageId
+     */
+    getCurrentImageId: () => string
+    /**
+     * Custom rendering pipeline for the rendering for the CPU fallback
+     */
+    customRenderViewportToCanvas: () => {
+        canvas: HTMLCanvasElement
+        element: HTMLElement
+        viewportUID: string
+        renderingEngineUID: string
+    }
+    /**
+     * Returns the image and its properties that is being shown inside the
+     * stack viewport. It returns, the image dimensions, image direction,
+     * image scalar data, vtkImageData object, metadata, and scaling (e.g., PET suvbw)
+     */
+    getImageData(): IImageData | CPUIImageData
+    /**
+     * Reset the viewport properties to the default values
+     */
+    resetProperties(): void
+    /**
+     * If the user has selected CPU rendering, return the CPU camera, otherwise
+     * return the default camera
+     */
+    getCamera(): ICamera
+    /**
+     * Set the camera based on the provided camera object.
+     */
+    setCamera(cameraInterface: ICamera): void
+    /**
+     * Sets the imageIds to be visualized inside the stack viewport. It accepts
+     * list of imageIds, the index of the first imageId to be viewed. It is a
+     * asynchronous function that returns a promise resolving to imageId being
+     * displayed in the stack viewport.
+     */
+    setStack(
+    imageIds: Array<string>,
+    currentImageIdIndex?: number
+    ): Promise<string>
+    /**
+     * Centers Pan and resets the zoom for stack viewport.
+     */
+    resetCamera(resetPanZoomForViewPlane?: boolean): boolean
+    /**
+     * Loads the image based on the provided imageIdIndex. It is an Async function which
+     * returns a promise that resolves to the imageId.
+     */
+    setImageIdIndex(imageIdIndex: number): Promise<string>
+    /**
+     * Calibrates the image with new metadata that has been added for imageId. To calibrate
+     * a viewport, you should add your calibration data manually to
+     * calibratedPixelSpacingMetadataProvider and call viewport.calibrateSpacing
+     * for it get applied.
+     */
+    calibrateSpacing(imageId: string): void
+    /**
+     * If the renderer is CPU based, throw an error. Otherwise, returns the `vtkRenderer` responsible for rendering the `Viewport`.
+     */
+    getRenderer(): any
+    /**
+     * Sets the colormap for the current viewport.
+     * @param colormap - The colormap data to use.
+     */
+    setColormap(colormap: CPUFallbackColormapData): void
+    /**
+     * It sets the colormap to the default colormap.
+     */
+    unsetColormap(): void
+}
+
+/**
+ * Cornerstone StreamingImageVolume which extends ImageVolume
+ */
+declare interface IStreamingImageVolume extends ImageVolume {
+    /** method to load all the loading requests */
+    clearLoadCallbacks(): void
+    /** method to convert the volume data in the volume cache, to separate images in the image cache */
+    convertToCornerstoneImage(imageId: string, imageIdIndex: number): any
+    /** method to decache the volume from cache */
+    decache(completelyRemove: boolean): void
+}
+
+declare interface IStreamingVolumeProperties {
+    /** imageIds of the volume  */
+    imageIds: Array<string>
+    /** loading status object for the volume containing loaded/loading statuses */
+    loadStatus: {
+        loaded: boolean
+        loading: boolean
+        cachedFrames: Array<boolean>
+        callbacks: Array<() => void>
+    }
+}
+
+declare function isValidRepresentationConfig(representationType: string, config: RepresentationConfig): boolean;
+
+declare interface ISynchronizerEventHandler {
+    (synchronizer: Synchronizer, sourceViewport: Types_2.IViewportUID, targetViewport: Types_2.IViewportUID, sourceEvent: any): void;
+}
+
+declare type IToolBinding = {
+    mouseButton: ToolBindingMouseType;
+    modifierKey?: ToolBindingKeyboardType;
+};
+
+declare interface IToolGroup {
+    _toolInstances: Record<string, any>;
+    uid: string;
+    viewportsInfo: Array<Types_2.IViewportUID>;
+    toolOptions: Record<string, any>;
+    getViewportUIDs: () => string[];
+    getToolInstance: {
+        (toolName: string): any;
+    };
+    addTool: {
+        (toolName: string, toolConfiguration?: any): void;
+    };
+    addViewport: {
+        (viewportUID: string, renderingEngineUID?: string): void;
+    };
+    removeViewports: {
+        (renderingEngineUID: string, viewportUID?: string): void;
+    };
+    setToolActive: {
+        (toolName: string, toolBindingsOption?: SetToolBindingsType): void;
+    };
+    setToolPassive: {
+        (toolName: string): void;
+    };
+    setToolEnabled: {
+        (toolName: string): void;
+    };
+    setToolDisabled: {
+        (toolName: string): void;
+    };
+    getToolOptions: {
+        (toolName: string): ToolOptionsType;
+    };
+    getActivePrimaryMouseButtonTool: {
+        (): undefined | string;
+    };
+    setViewportsCursorByToolName: {
+        (toolName: string, strategyName?: string): void;
+    };
+}
+
+/**
+ * Viewport interface for cornerstone viewports
+ */
+declare interface IViewport {
+    /** unique identifier of the viewport */
+    uid: string
+    /** renderingEngineUID the viewport belongs to */
+    renderingEngineUID: string
+    /** viewport type, can be ORTHOGRAPHIC or STACK for now */
+    type: ViewportType
+    /** canvas associated to the viewport */
+    canvas: HTMLCanvasElement
+    /** public DOM element associated to the viewport */
+    element: HTMLElement
+    /** sx of the viewport on the offscreen canvas (if rendering using GPU) */
+    sx: number
+    /** sy of the viewport on the offscreen canvas (if rendering using GPU) */
+    sy: number
+    /** width of the viewport on the offscreen canvas (if rendering using GPU) */
+    sWidth: number
+    /** height of the viewport on the offscreen canvas (if rendering using GPU) */
+    sHeight: number
+    /** actors rendered in the viewport (volumeActors as of now) */
+    _actors: Map<string, any>
+    /** viewport default options including the axis, and background color  */
+    defaultOptions: any
+    /** viewport options */
+    options: ViewportInputOptions
+    /** Suppress events */
+    suppressEvents: boolean
+    /** frameOfReferenceUID the viewport's default actor is rendering */
+    getFrameOfReferenceUID: () => string
+    /** method to convert canvas to world coordinates */
+    canvasToWorld: (canvasPos: Point2) => Point3
+    /** method to convert world to canvas coordinates */
+    worldToCanvas: (worldPos: Point3) => Point2
+    /** returns all the actors on the viewport which includes both volumeActor object and its uid */
+    getActors(): Array<ActorEntry>
+    /** returns specific actor by its uid */
+    getActor(actorUID: string): ActorEntry
+    /** set and overwrite actors in a viewport */
+    setActors(actors: Array<ActorEntry>): void
+    /** add actors to the list of actors */
+    addActors(actors: Array<ActorEntry>): void
+    /** add one actor */
+    addActor(actorEntry: ActorEntry): void
+    /** remove all actors from the viewport */
+    removeAllActors(): void
+    /** returns the renderingEngine instance the viewport belongs to */
+    getRenderingEngine(): any
+    /** returns the vtkRenderer (for GPU rendering) of the viewport */
+    getRenderer(): void
+    /** triggers render for all actors in the viewport */
+    render(): void
+    /** set options for the viewport */
+    setOptions(options: ViewportInputOptions, immediate: boolean): void
+    /** reset camera and options*/
+    reset(immediate: boolean): void
+    /** returns the canvas */
+    getCanvas(): HTMLCanvasElement
+    /** returns camera object */
+    getCamera(): ICamera
+    /** sets the camera */
+    setCamera(cameraInterface: ICamera): void
+    /** whether the viewport has custom rendering */
+    customRenderViewportToCanvas: () => unknown
+    _getCorners(bounds: Array<number>): Array<number>[]
+}
+
+/**
+ * Interface to uniquely define a viewport in cornerstone. Note: viewportUIDs
+ * can be shared between different rendering engines, but having a renderingEngineUID
+ * and a viewportUID is required to uniquely define a viewport.
+ */
+declare interface IViewportUID {
+    renderingEngineUID: string
+    viewportUID: string
+}
+
+/**
+ * Cornerstone ImageVolume interface.
+ */
+declare interface IVolume {
+    /** unique identifier for the volume in the cache */
+    uid: string
+    /** volume metadata */
+    metadata: Metadata
+    /** volume dimensions */
+    dimensions: Point3
+    /** volume spacing */
+    spacing: Point3
+    /** volume origin */
+    origin: Point3
+    /** volume direction */
+    direction: Float32Array
+    /** volume scalarData */
+    scalarData: Float32Array | Uint8Array
+    /** volume size in bytes */
+    sizeInBytes?: number
+    /** volume image data as vtkImageData */
+    imageData?: vtkImageData
+    /** referenceVolumeUID if volume is derived from another volume */
+    referenceVolumeUID?: string
+    /** volume scaling metadata */
+    scaling?: {
+        PET?: {
+            // @TODO: Do these values exist?
+            SUVlbmFactor?: number
+            SUVbsaFactor?: number
+            // accessed in ProbeTool
+            suvbwToSuvlbm?: number
+            suvbwToSuvbsa?: number
+        }
+    }
+}
+
+/**
+ * VolumeInput that can be used to add a volume to a viewport. It includes
+ * mandatory `volumeUID` but other options such as `visibility`, `blendMode`,
+ * `slabThickness` and `callback` can also be provided
+ */
+declare interface IVolumeInput {
+    /** Volume UID of the volume in the cache */
+    volumeUID: string
+    // actorUID for segmentations, since two segmentations with the same volumeUID
+    // can have different representations
+    actorUID?: string
+    /** Visibility of the volume - by default it is true */
+    visibility?: boolean
+    /** Callback to be called when the volume is added to the viewport */
+    callback?: VolumeInputCallback
+    /** Blend mode of the volume - by default it is `additive` */
+    blendMode?: string
+    /** Slab thickness of the volume - by default it is calculated by the image size*/
+    slabThickness?: number
+}
+
+/**
+ * VolumeLoadObject interface which any volumeLoader should return
+ */
+declare interface IVolumeLoadObject {
+    /** promise that resolves to an ImageVolume */
+    promise: Promise<ImageVolume>
+    /** optional cancel function for loading*/
+    cancel?: () => void
+    /** optional decache function */
+    decache?: () => void
+}
+
+/**
+ * Interface for the Volume Viewport
+ */
+declare interface IVolumeViewport extends IViewport {
+    useCPURendering: boolean
+    getFrameOfReferenceUID: () => string
+    getProperties: () => any
+    /**
+     * canvasToWorld Returns the world coordinates of the given `canvasPos`
+     * projected onto the plane defined by the `Viewport`'s `vtkCamera`'s focal point
+     * and the direction of projection.
+     */
+    canvasToWorld: (canvasPos: Point2) => Point3
+    /**
+     * Returns the canvas coordinates of the given `worldPos`
+     * projected onto the `Viewport`'s `canvas`.
+     */
+    worldToCanvas: (worldPos: Point3) => Point2
+    /**
+     * Uses viewport camera and volume actor to decide if the viewport
+     * is looking at the volume in the direction of acquisition (imageIds).
+     * If so, it uses the origin and focalPoint to calculate the slice index.
+     */
+    getCurrentImageIdIndex: () => number
+    /**
+     * Uses viewport camera and volume actor to decide if the viewport
+     * is looking at the volume in the direction of acquisition (imageIds).
+     * If so, it uses the origin and focalPoint to find which imageId is
+     * currently being viewed.
+     */
+    getCurrentImageId: () => string
+    /**
+     * Creates volume actors for all volumes defined in the `volumeInputArray`.
+     * For each entry, if a `callback` is supplied, it will be called with the new volume actor as input.
+     * For each entry, if a `blendMode` and/or `slabThickness` is defined, this will be set on the actor's
+     * `VolumeMapper`.
+     */
+    setVolumes(
+    volumeInputArray: Array<IVolumeInput>,
+    immediate?: boolean
+    ): Promise<void>
+    /**
+     * Creates and adds volume actors for all volumes defined in the `volumeInputArray`.
+     * For each entry, if a `callback` is supplied, it will be called with the new volume actor as input.
+     */
+    addVolumes(
+    volumeInputArray: Array<IVolumeInput>,
+    immediate?: boolean
+    ): Promise<void>
+    /**
+     * It removes the volume actor from the Viewport. If the volume actor is not in
+     * the viewport, it does nothing.
+     */
+    removeVolumeActors(actorUIDs: Array<string>, immediate?: boolean): void
+    /**
+     * Given a point in world coordinates, return the intensity at that point
+     */
+    getIntensityFromWorld(point: Point3): number
+    /**
+     * getBounds gets the visible bounds of the viewport
+     */
+    getBounds(): any
+    /**
+     * Flip the viewport along the desired axis
+     */
+    flip(flipDirection: FlipDirection): void
+    /**
+     * Reset the camera for the volume viewport
+     */
+    resetCamera(resetPanZoomForViewPlane?: boolean): boolean
+    /**
+     * Sets the slab thickness option in the `Viewport`'s `options`.
+     */
+    setSlabThickness(slabThickness: number): void
+    /**
+     * Gets the slab thickness option in the `Viewport`'s `options`.
+     */
+    getSlabThickness(): number
+    /**
+     * Returns the image and its properties that is being shown inside the
+     * stack viewport. It returns, the image dimensions, image direction,
+     * image scalar data, vtkImageData object, metadata, and scaling (e.g., PET suvbw)
+     */
+    getImageData(): IImageData | undefined
+}
+
+declare enum KeyboardBindings {
+    Shift = 16,
+    Ctrl = 18,
+    Alt = 17
+}
+
+declare type KeyDownEventDetail = {
+    element: HTMLElement;
+    viewportUID: string;
+    renderingEngineUID: string;
+    key: string;
+    keyCode: number;
+};
+
+declare type KeyDownEventType = Types_2.CustomEventType<KeyDownEventDetail>;
+
+declare type KeyUpEventDetail = KeyDownEventDetail;
+
+declare type KeyUpEventType = Types_2.CustomEventType<KeyUpEventDetail>;
+
+declare type LabelmapConfig = {
+    renderOutline?: boolean;
+    outlineWidth?: number;
+    outlineWidthActive?: number;
+    outlineWidthInactive?: number;
+    renderFill?: boolean;
+    fillAlpha?: number;
+    fillAlphaInactive?: number;
+};
+
+declare type LabelmapRepresentation = {
+    type: typeof SegmentationRepresentations.Labelmap;
+    config: {
+        cfun?: vtkColorTransferFunction;
+        ofun?: vtkPiecewiseFunction;
+    };
+};
+
+declare interface LengthAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: Types_2.Point3[];
+            activeHandleIndex: number | null;
+            textBox: {
+                hasMoved: boolean;
+                worldPosition: Types_2.Point3;
+                worldBoundingBox: {
+                    topLeft: Types_2.Point3;
+                    topRight: Types_2.Point3;
+                    bottomLeft: Types_2.Point3;
+                    bottomRight: Types_2.Point3;
+                };
+            };
+        };
+        label: string;
+        cachedStats: {
+            [targetUID: string]: {
+                length: number;
+            };
+        };
+    };
+}
+
+export declare class LengthTool extends AnnotationTool {
+    static toolName: string;
+    touchDragCallback: any;
+    mouseDragCallback: any;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        movingTextBox?: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => LengthAnnotation;
+    isPointNearTool: (element: HTMLElement, annotation: LengthAnnotation, canvasCoords: Types_2.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: LengthAnnotation, interactionType: InteractionTypes) => void;
+    handleSelectedCallback(evt: EventTypes_2.MouseDownEventType, annotation: LengthAnnotation, handle: ToolHandle, interactionType?: string): void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _mouseDragCallback: (evt: EventTypes_2.MouseDragEventType | EventTypes_2.MouseMoveEventType) => void;
+    cancel: (element: HTMLElement) => any;
+    _activateModify: (element: HTMLElement) => void;
+    _deactivateModify: (element: HTMLElement) => void;
+    _activateDraw: (element: HTMLElement) => void;
+    _deactivateDraw: (element: HTMLElement) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _getTextLines(data: any, targetUID: any): string[];
+    _calculateLength(pos1: any, pos2: any): number;
+    _calculateCachedStats(annotation: any, renderingEngine: any, enabledElement: any): any;
+    _isInsideVolume(index1: any, index2: any, dimensions: any): boolean;
+}
+
+declare const lineSegment: {
+    distanceToPoint: typeof distanceToPoint;
+    distanceToPointSquared: typeof distanceToPointSquared;
+    intersectLine: typeof intersectLine;
+};
+
+declare namespace locking {
+    export {
+        setAnnotationLocked,
+        getAnnotationsLocked,
+        getAnnotationsLockedCount,
+        unlockAllAnnotations,
+        isAnnotationLocked,
+        checkAndDefineIsLockedProperty
+    }
+}
+
+declare namespace math {
+    export {
+        _default_9 as default,
+        _default_10 as vec2,
+        _default_11 as ellipse,
+        lineSegment,
+        rectangle
+    }
+}
+
+/**
+ * Metadata for images, More information can be found in the
+ * {@link https://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html#table_C.7-11c}
+ */
+declare type Metadata = {
+    /** Number of bits allocated for each pixel sample. Each sample shall have the same number of bits allocated */
+    BitsAllocated: number
+    /** Number of bits stored for each pixel sample */
+    BitsStored: number
+    SamplesPerPixel: number
+    /** Most significant bit for pixel sample data */
+    HighBit: number
+    /** Specifies the intended interpretation of the pixel data */
+    PhotometricInterpretation: string
+    /** Data representation of the pixel samples. */
+    PixelRepresentation: number
+    /** Image Modality */
+    Modality: string
+    /** The direction cosines of the first row and the first column with respect to the patient */
+    ImageOrientationPatient: Array<number>
+    /** Physical distance in the patient between the center of each pixel */
+    PixelSpacing: Array<number>
+    /** Uniquely identifies the Frame of Reference for a Series */
+    FrameOfReferenceUID: string
+    /** Number of columns in the image. */
+    Columns: number
+    /** Number of rows in the image. */
+    Rows: number
+    /** Window Level/Center for the image */
+    voiLut: Array<VOI>
+}
+
+export declare class MIPJumpToClickTool extends BaseTool {
+    static toolName: string;
+    _bounds: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseClickCallback(evt: any): void;
+}
+
+declare enum MouseBindings {
+    Primary = 1,
+    Secondary = 2,
+    Primary_And_Secondary = 3,
+    Auxiliary = 4,
+    Primary_And_Auxiliary = 5,
+    Secondary_And_Auxiliary = 6,
+    Primary_And_Secondary_And_Auxiliary = 7,
+    Fourth_Button = 8,
+    Fifth_Button = 16
+}
+
+declare type MouseClickEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+
+declare type MouseClickEventType = Types_2.CustomEventType<MouseClickEventDetail>;
+
+declare class MouseCursor {
+    private name;
+    private fallback;
+    constructor(name: string, fallback?: MouseCursor | undefined);
+    getName(): string;
+    addFallbackStyleProperty(style: string): string;
+    getStyleProperty(): string;
+    static getDefinedCursor(name: string): MouseCursor | undefined;
+    static setDefinedCursor(name: string, cursor: MouseCursor): boolean;
+}
+
+declare type MouseDoubleClickEventDetail = NormalizedMouseEventDetail & {
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+
+declare type MouseDoubleClickEventType = Types_2.CustomEventType<MouseDoubleClickEventDetail>;
+
+declare type MouseDownActivateEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+
+declare type MouseDownActivateEventType = Types_2.CustomEventType<MouseDownActivateEventDetail>;
+
+declare type MouseDownEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+
+declare type MouseDownEventType = Types_2.CustomEventType<MouseDownEventDetail>;
+
+declare type MouseDragEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+
+declare type MouseDragEventType = Types_2.CustomEventType<MouseDragEventDetail>;
+
+declare type MouseMoveEventDetail = NormalizedMouseEventDetail & {
+    currentPoints: IPoints;
+};
+
+declare type MouseMoveEventType = Types_2.CustomEventType<MouseMoveEventDetail>;
+
+declare type MouseUpEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+
+declare type MouseUpEventType = Types_2.CustomEventType<MouseUpEventDetail>;
+
+declare type MouseWheelEventDetail = NormalizedMouseEventDetail & {
+    detail: Record<string, any>;
+    wheel: {
+        spinX: number;
+        spinY: number;
+        pixelX: number;
+        pixelY: number;
+        direction: number;
+    };
+    points: IPoints;
+};
+
+declare type MouseWheelEventType = Types_2.CustomEventType<MouseWheelEventDetail>;
+
+declare type NormalizedMouseEventDetail = {
+    event: Record<string, unknown> | MouseEvent;
+    eventName: string;
+    renderingEngineUID: string;
+    viewportUID: string;
+    camera: Record<string, unknown>;
+    element: HTMLElement;
+};
+
+declare type NormalizedMouseEventType = Types_2.CustomEventType<NormalizedMouseEventDetail>;
+
+declare type Orientation = {
+    /** Slice Normal for the viewport - the normal that points in the opposite direction of the slice normal out of screen and is negative of direction of projection */
+    sliceNormal: Point3
+    /** viewUp direction for the viewport - the vector that points from bottom to top of the viewport */
+    viewUp: Point3
+}
+
+export declare class PanTool extends BaseTool {
+    static toolName: string;
+    touchDragCallback: () => void;
+    mouseDragCallback: () => void;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _dragCallback(evt: any): void;
+}
+
+declare namespace planar {
+    export {
+        _default_12 as default,
+        filterAnnotationsWithinSlice,
+        getWorldWidthAndHeightFromCorners,
+        filterAnnotationsForDisplay,
+        getPointInLineOfSightWithCriteria
+    }
+}
+
+declare type PlanarBoundingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+/**
+ * Plane equation Ax+By+Cz=D, plane is defined by [A, B, C, D]
+ */
+declare type Plane = [number, number, number, number]
+
+/**
+ * This duplicates the typing established in gl-matrix for a vec2
+ */
+declare type Point2 = [number, number]
+
+/**
+ * This duplicates the typing established in gl-matrix for a vec3
+ */
+declare type Point3 = [number, number, number]
+
+/**
+ * This represents a 4-vector or RGBA value.
+ */
+declare type Point4 = [number, number, number, number];
+
+declare function pointInEllipse(ellipse: Ellipse, pointLPS: Types_2.Point3): boolean;
+
+declare type PointInShapeCallback = ({ value, index, pointIJK, pointLPS, }: {
+    value: number;
+    index: number;
+    pointIJK: Types_2.Point3;
+    pointLPS: Types_2.Point3;
+}) => void;
+
+declare function pointInShapeCallback(imageData: vtkImageData | Types_2.CPUImageData, pointInShapeFn: ShapeFnCriteria, callback: PointInShapeCallback, boundsIJK?: BoundsIJK): void;
+
+declare function pointInSurroundingSphereCallback(viewport: Types_2.IVolumeViewport, imageData: vtkImageData, circlePoints: [Types_2.Point3, Types_2.Point3], callback: PointInShapeCallback): void;
+
+declare interface ProbeAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: Types_2.Point3[];
+        };
+        cachedStats: {
+            [targetUID: string]: {
+                Modality: string;
+                index: Types_2.Point3;
+                value: number;
+            };
+        };
+        label: string;
+    };
+}
+
+export declare class ProbeTool extends AnnotationTool {
+    static toolName: string;
+    touchDragCallback: any;
+    mouseDragCallback: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: string[];
+    } | null;
+    eventDispatchDetail: {
+        viewportUID: string;
+        renderingEngineUID: string;
+    };
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    isPointNearTool(): boolean;
+    toolSelectedCallback(): void;
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => ProbeAnnotation;
+    getHandleNearImagePoint(element: HTMLElement, annotation: ProbeAnnotation, canvasCoords: Types_2.Point2, proximity: number): ToolHandle | undefined;
+    handleSelectedCallback(evt: EventTypes_2.MouseDownEventType, annotation: ProbeAnnotation, handle: ToolHandle, interactionType?: string): void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _mouseDragCallback: (evt: any) => void;
+    cancel: (element: HTMLElement) => any;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _getTextLines(data: any, targetUID: any): any[];
+    _getValueForModality(value: any, imageVolume: any, modality: any): {};
+    _calculateCachedStats(annotation: any, renderingEngine: any, enabledElement: any): any;
+}
+
+declare type PTScaling = {
+    /** suv body weight to suv lean body mass */
+    suvbwToSuvlbm?: number
+    /** suv body weight to suv body surface area */
+    suvbwToSuvbsa?: number
+}
+
+declare type PublicToolProps = SharedToolProp & {
+    name?: string;
+};
+
+/**
+ * Public Interface for viewport input to get enabled/disabled or set
+ */
+declare type PublicViewportInput = {
+    /** HTML element in the DOM */
+    element: HTMLElement
+    /** unique id for the viewport in the renderingEngine */
+    viewportUID: string
+    /** type of the viewport */
+    type: ViewportType
+    /** options for the viewport */
+    defaultOptions: ViewportInputOptions
+}
+
+declare const rectangle: {
+    distanceToPoint: typeof distanceToPoint_2;
+};
+
+declare interface RectangleRoiAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: Types_2.Point3[];
+            activeHandleIndex: number | null;
+            textBox: {
+                hasMoved: boolean;
+                worldPosition: Types_2.Point3;
+                worldBoundingBox: {
+                    topLeft: Types_2.Point3;
+                    topRight: Types_2.Point3;
+                    bottomLeft: Types_2.Point3;
+                    bottomRight: Types_2.Point3;
+                };
+            };
+        };
+        label: string;
+        cachedStats?: RectangleRoiCachedStats | {
+            projectionPoints?: Types_2.Point3[];
+            projectionPointsImageIds?: string[];
+        };
+    };
+}
+
+declare interface RectangleRoiCachedStats {
+    [targetUID: string]: {
+        Modality: string;
+        area: number;
+        max: number;
+        mean: number;
+        stdDev: number;
+    };
+}
+
+declare interface RectangleRoiStartEndThresholdAnnotation extends Annotation {
+    metadata: {
+        cameraPosition?: Types_2.Point3;
+        cameraFocalPoint?: Types_2.Point3;
+        viewPlaneNormal?: Types_2.Point3;
+        viewUp?: Types_2.Point3;
+        annotationUID?: string;
+        FrameOfReferenceUID: string;
+        referencedImageId?: string;
+        toolName: string;
+        enabledElement: any;
+        volumeUID: string;
+        spacingInNormal: number;
+    };
+    data: {
+        label: string;
+        startSlice: number;
+        endSlice: number;
+        cachedStats: {
+            projectionPoints: Types_2.Point3[][];
+            projectionPointsImageIds: string[];
+        };
+        handles: {
+            points: Types_2.Point3[];
+            activeHandleIndex: number | null;
+        };
+    };
+}
+
+export declare class RectangleRoiStartEndThresholdTool extends RectangleRoiTool {
+    static toolName: string;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => {
+        highlighted: boolean;
+        invalidated: boolean;
+        metadata: {
+            viewPlaneNormal: Types_2.Point3;
+            enabledElement: Types_2.IEnabledElement;
+            viewUp: Types_2.Point3;
+            FrameOfReferenceUID: string;
+            referencedImageId: any;
+            toolName: string;
+            volumeUID: any;
+            spacingInNormal: number;
+        };
+        data: {
+            label: string;
+            startSlice: number;
+            endSlice: number;
+            cachedStats: {
+                projectionPoints: any[];
+                projectionPointsImageIds: any[];
+            };
+            handles: {
+                textBox: {
+                    hasMoved: boolean;
+                    worldPosition: any;
+                    worldBoundingBox: any;
+                };
+                points: Types_2.Point3[];
+                activeHandleIndex: any;
+            };
+            labelmapUID: any;
+        };
+    };
+    _computeProjectionPoints(annotation: RectangleRoiStartEndThresholdAnnotation, imageVolume: Types_2.IImageVolume): void;
+    _calculateCachedStatsTool(annotation: any, enabledElement: any): any;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _getEndSliceIndex(imageVolume: Types_2.IImageVolume, worldPos: Types_2.Point3, spacingInNormal: number, viewPlaneNormal: Types_2.Point3): number | undefined;
+}
+
+export declare class RectangleRoiThresholdTool extends RectangleRoiTool {
+    static toolName: string;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => {
+        highlighted: boolean;
+        invalidated: boolean;
+        metadata: {
+            viewPlaneNormal: Types_2.Point3;
+            enabledElement: Types_2.IEnabledElement;
+            viewUp: Types_2.Point3;
+            FrameOfReferenceUID: string;
+            referencedImageId: any;
+            toolName: string;
+            volumeUID: any;
+        };
+        data: {
+            label: string;
+            handles: {
+                textBox: {
+                    hasMoved: boolean;
+                    worldPosition: any;
+                    worldBoundingBox: any;
+                };
+                points: Types_2.Point3[];
+                activeHandleIndex: any;
+            };
+            segmentationUID: any;
+        };
+    };
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+}
+
+export declare class RectangleRoiTool extends AnnotationTool {
+    static toolName: string;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        movingTextBox?: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => RectangleRoiAnnotation;
+    isPointNearTool: (element: HTMLElement, annotation: RectangleRoiAnnotation, canvasCoords: Types_2.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: RectangleRoiAnnotation, interactionType: InteractionTypes) => void;
+    handleSelectedCallback: (evt: EventTypes_2.MouseDownEventType, annotation: RectangleRoiAnnotation, handle: ToolHandle, interactionType?: string) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _mouseDragCallback: (evt: EventTypes_2.MouseMoveEventType | EventTypes_2.MouseDragEventType) => void;
+    cancel: (element: HTMLElement) => any;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+    _getRectangleImageCoordinates: (points: Array<Types_2.Point2>) => {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    _getTextLines: (data: any, targetUID: string) => any[];
+    _calculateCachedStats: (annotation: any, viewPlaneNormal: any, viewUp: any, renderingEngine: any, enabledElement: any) => any;
+    _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
+}
+
+export declare class RectangleScissorsTool extends BaseTool {
+    static toolName: string;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: any;
+        segmentationDataUID: string;
+        segmentation: any;
+        segmentIndex: number;
+        segmentsLocked: number[];
+        segmentColor: [number, number, number, number];
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        movingTextBox: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => void;
+    _mouseDragCallback: (evt: EventTypes_2.MouseDragEventType) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+}
+
+declare function registerCursor(toolName: string, iconContent: string, viewBox: {
+    x: number;
+    y: number;
+}): void;
+
+declare function removeAnnotation(element: HTMLElement, annotationUID: string): void;
+
+declare function removeSegmentationData(toolGroupUID: string, segmentationDataUID: string): void;
+
+declare function removeSegmentationsFromToolGroup(toolGroupUID: string, segmentationDataUIDs?: string[] | undefined): void;
+
+export declare function removeTool(ToolClass: any): void;
+
+declare type RepresentationConfig = LabelmapConfig;
+
+declare function resetElementCursor(element: HTMLElement): void;
+
+declare type Scaling = {
+    PET?: PTScaling
+}
+
+declare type ScalingParameters = {
+    /** m in m*p+b which specifies the linear transformation from stored pixels to memory value  */
+    rescaleSlope: number
+    /** b in m*p+b which specifies the offset of the transformation */
+    rescaleIntercept: number
+    /** modality */
+    modality: string
+    /** SUV body weight */
+    suvbw?: number
+    /** SUV lean body mass */
+    suvlbm?: number
+    /** SUV body surface area */
+    suvbsa?: number
+}
+
+declare function scrollThroughStack(evt: MouseWheelEventType | MouseDragEventType, deltaFrames: number, volumeUID: string, invert?: boolean): void;
+
+declare namespace segmentation {
+    export {
+        state_2 as state,
+        activeSegmentation,
+        addSegmentationsForToolGroup,
+        removeSegmentationsFromToolGroup,
+        createNewSegmentationForToolGroup,
+        segmentLocking,
+        segmentationColor,
+        segmentationConfig,
+        segmentationVisibility,
+        segmentIndex,
+        triggerSegmentationEvents
+    }
+}
+export { segmentation }
+
+declare namespace segmentation_2 {
+    export {
+        getBoundingBoxAroundShape,
+        extend2DBoundingBoxInViewAxis,
+        thresholdVolumeByRange,
+        thresholdVolumeByRoiStats,
+        createMergedLabelmapForIndex,
+        isValidRepresentationConfig,
+        getDefaultRepresentationConfig,
+        _default_16 as default
+    }
+}
+
+declare namespace segmentationColor {
+    export {
+        _default_5 as default,
+        getColorForSegmentIndex,
+        addColorLUT_2 as addColorLUT
+    }
+}
+
+declare type SegmentationConfig = {
+    renderInactiveSegmentations: boolean;
+    representations: {
+        LABELMAP?: LabelmapConfig;
+    };
+};
+
+declare namespace segmentationConfig {
+    export {
+        getGlobalSegmentationConfig_2 as getGlobalSegmentationConfig,
+        setGlobalSegmentationConfig_2 as setGlobalSegmentationConfig,
+        getGlobalRepresentationConfig,
+        setGlobalRepresentationConfig,
+        updateGlobalSegmentationConfig,
+        updateGlobalRepresentationConfig,
+        getSegmentationConfig_2 as getSegmentationConfig,
+        setSegmentationConfig_2 as setSegmentationConfig,
+        setRepresentationConfig,
+        getRepresentationConfig,
+        _default_6 as default
+    }
+}
+
+declare type SegmentationDataInput = Partial<ToolGroupSpecificSegmentationData> & {
+    toolGroupUID: string;
+};
+
+declare type SegmentationDataModifiedEventDetail = {
+    toolGroupUID: string;
+    segmentationDataUID: string;
+};
+
+declare type SegmentationDataModifiedEventType = Types_2.CustomEventType<SegmentationDataModifiedEventDetail>;
+
+export declare class SegmentationDisplayTool extends BaseTool {
+    static toolName: string;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    enableCallback(): void;
+    disableCallback(): void;
+    renderSegmentation: (toolGroupUID: string) => void;
+    _getSegmentationConfig(toolGroupUID: string): SegmentationConfig;
+}
+
+declare type SegmentationGlobalStateModifiedEventDetail = {
+    segmentationUID: string;
+};
+
+declare type SegmentationGlobalStateModifiedEventType = Types_2.CustomEventType<SegmentationGlobalStateModifiedEventDetail>;
+
+declare type SegmentationRenderedEventDetail = {
+    viewportUID: string;
+    toolGroupUID: string;
+};
+
+declare type SegmentationRenderedEventType = Types_2.CustomEventType<SegmentationRenderedEventDetail>;
+
+declare type SegmentationRepresentation = LabelmapRepresentation;
+
+declare enum SegmentationRepresentations {
+    Labelmap = "LABELMAP"
+}
+
+declare interface SegmentationState {
+    colorLutTables: ColorLUT[];
+    global: GlobalSegmentationStateWithConfig;
+    toolGroups: {
+        [key: string]: ToolGroupSpecificSegmentationStateWithConfig;
+    };
+}
+
+declare class SegmentationStateManager {
+    private state;
+    readonly uid: string;
+    constructor(uid?: string);
+    getState(): SegmentationState;
+    getToolGroups(): string[];
+    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(toolGroupUID: string): ToolGroupSpecificSegmentationState | [];
+    getSegmentationConfig(toolGroupUID: string): SegmentationConfig | undefined;
+    setSegmentationConfig(toolGroupUID: string, config: SegmentationConfig): void;
+    getSegmentationDataByUID(toolGroupUID: string, segmentationDataUID: string): ToolGroupSpecificSegmentationData | undefined;
+    getActiveSegmentationData(toolGroupUID: string): ToolGroupSpecificSegmentationData | undefined;
+    addColorLUT(colorLut: ColorLUT, lutIndex: number): void;
+    addGlobalSegmentationData(segmentationData: GlobalSegmentationData): void;
+    addSegmentationData(toolGroupUID: string, segmentationData: ToolGroupSpecificSegmentationData): void;
+    setActiveSegmentationData(toolGroupUID: string, segmentationDataUID: string): void;
+    removeSegmentationData(toolGroupUID: string, segmentationDataUID: string): void;
+    _handleActiveSegmentation(toolGroupUID: string, recentlyAddedOrRemovedSegmentationData: ToolGroupSpecificSegmentationData): void;
+    _initDefaultColorLutIfNecessary(): void;
+}
+
+declare type SegmentationStateModifiedEventDetail = {
+    toolGroupUID: string;
+};
+
+declare type SegmentationStateModifiedEventType = Types_2.CustomEventType<SegmentationStateModifiedEventDetail>;
+
+declare namespace segmentationVisibility {
+    export {
+        _default_7 as default,
+        setSegmentationVisibility,
+        getSegmentationVisibility
+    }
+}
+
+declare namespace segmentIndex {
+    export {
+        _default_8 as default,
+        getActiveSegmentIndex,
+        setActiveSegmentIndex,
+        getActiveSegmentIndexForSegmentation,
+        setActiveSegmentIndexForSegmentation
+    }
+}
+
+declare namespace segmentLocking {
+    export {
+        getSegmentIndexLocked,
+        setSegmentIndexLocked,
+        getSegmentIndexLockedForSegmentation,
+        setSegmentIndexLockedForSegmentation,
+        getSegmentsLockedForSegmentation,
+        _default_4 as default
+    }
+}
+
+declare namespace selection {
+    export {
+        setAnnotationSelected,
+        getAnnotationsSelected,
+        getAnnotationSelected,
+        getAnnotationsSelectedByToolName,
+        getAnnotationsSelectedCount,
+        isAnnotationSelected
+    }
+}
+
+declare function setActiveSegmentation(toolGroupUID: string, segmentationDataUID: string): void;
+
+declare function setActiveSegmentationData(toolGroupUID: string, segmentationDataUID: string, suppressEvents?: boolean): void;
+
+declare function setActiveSegmentIndex(toolGroupUID: string, segmentIndex: number): void;
+
+declare function setActiveSegmentIndexForSegmentation(segmentationUID: string, segmentIndex: number): void;
+
+declare function setAnnotationLocked(annotation: Annotation, locked?: boolean): void;
+
+declare function setAnnotationSelected(annotation: Annotation, selected?: boolean, preserveSelected?: boolean): void;
+
+declare function setAnnotationStyle(toolName: string, annotation: Record<string, unknown>, style: Record<string, unknown>): boolean;
+
+declare function setCursorForElement(element: HTMLElement, cursorName: string): void;
+
+declare function _setElementCursor(element: HTMLElement, cursor: MouseCursor | null): void;
+
+declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: RepresentationConfig): void;
+
+declare function setGlobalSegmentationConfig(config: SegmentationConfig, suppressEvents?: boolean): void;
+
+declare function setGlobalSegmentationConfig_2(segmentationConfig: SegmentationConfig): void;
+
+declare function setGlobalStyle(style: Record<string, unknown>): boolean;
+
+declare function setRepresentationConfig(toolGroupUID: string, representationType: SegmentationRepresentations, representationConfig: RepresentationConfig): void;
+
+declare function setSegmentationConfig(toolGroupUID: string, config: SegmentationConfig, suppressEvents?: boolean): void;
+
+declare function setSegmentationConfig_2(toolGroupUID: string, segmentationConfig: SegmentationConfig): void;
+
+declare function setSegmentationVisibility(toolGroupUID: string, segmentationDataUID: string, visibility: boolean): void;
+
+declare function setSegmentIndexLocked(toolGroupUID: string, segmentIndex: number, locked?: boolean): void;
+
+declare function setSegmentIndexLockedForSegmentation(segmentationUID: string, segmentIndex: number, locked?: boolean): void;
+
+/**
+ * Settings
+ */
+declare class Settings {
+    constructor(base?: Settings) {
+        const dictionary = Object.create(
+        base instanceof Settings && DICTIONARY in base ? base[DICTIONARY] : null
+        )
+        Object.seal(
+        Object.defineProperty(this, DICTIONARY, {
+            value: dictionary,
+        })
+        )
+    }
+
+    set(key: string, value: unknown): boolean {
+        return set(this[DICTIONARY], key, value, null)
+    }
+
+    get(key: string): unknown {
+        return get(this[DICTIONARY], key)
+    }
+
+    /**
+     * Unset a specific key or a set of keys within a namespace when the key ends with a dot (ASCII #46).
+     * If the key is ".", all keys will be removed and this command works as a reset.
+     * @param key - name The key to be unset or a namespace.
+     * @returns boolean
+     */
+    unset(key: string): boolean {
+        return unset(this[DICTIONARY], key + '')
+    }
+
+    forEach(callback: (key: string, value: unknown) => void): void {
+        iterate(this[DICTIONARY], callback)
+    }
+
+    extend(): Settings {
+        return new Settings(this)
+    }
+
+    /**
+     * Recursively import all properties from the given plain JavaScript object.
+     * This method has the opposite effect of the `dump` method.
+     * @param root - The root object whose properties will
+     * be imported.
+     */
+    import(root: Record<string, unknown>): void {
+        if (isPlainObject(root)) {
+            Object.keys(root).forEach((key) => {
+                set(this[DICTIONARY], key, root[key], null)
+            })
+        }
+    }
+
+    /**
+     * Build a JSON representation of the current internal state of this settings
+     * object. The returned object can be safely passed to `JSON.stringify`
+     * function.
+     * @returns The JSON representation of the current
+     * state of this settings instance
+     */
+    dump(): Record<string, unknown> {
+        const context = {}
+        iterate(this[DICTIONARY], (key, value) => {
+            if (typeof value !== 'undefined') {
+                deepSet(context, key, value)
+            }
+        })
+        return context
+    }
+
+    static assert(subject: Settings): Settings {
+        return subject instanceof Settings ? subject : Settings.getRuntimeSettings()
+    }
+
+    static getDefaultSettings(subfield = null): Settings | any {
+        let defaultSettings = Settings[DEFAULT_SETTINGS]
+        if (!(defaultSettings instanceof Settings)) {
+            defaultSettings = new Settings()
+            Settings[DEFAULT_SETTINGS] = defaultSettings
+        }
+
+        // Given subfield of 'segmentation' it will return all settings
+        // that starts with segmentation.*
+        if (subfield) {
+            const settingObj = {}
+            defaultSettings.forEach((name: string) => {
+                if (name.startsWith(subfield)) {
+                    const setting = name.split(`${subfield}.`)[1]
+                    settingObj[setting] = defaultSettings.get(name)
+                }
+            })
+            return settingObj
+        }
+
+        return defaultSettings
+    }
+
+    static getRuntimeSettings(): Settings {
+        let runtimeSettings = Settings[RUNTIME_SETTINGS]
+        if (!(runtimeSettings instanceof Settings)) {
+            runtimeSettings = new Settings(Settings.getDefaultSettings())
+            Settings[RUNTIME_SETTINGS] = runtimeSettings
+        }
+        return runtimeSettings
+    }
+
+    static getObjectSettings(subject: unknown, from?: unknown): Settings {
+        let settings = null
+        if (subject instanceof Settings) {
+            settings = subject
+        } else if (typeof subject === 'object' && subject !== null) {
+            let objectSettingsMap = Settings[OBJECT_SETTINGS_MAP]
+            if (!(objectSettingsMap instanceof WeakMap)) {
+                objectSettingsMap = new WeakMap()
+                Settings[OBJECT_SETTINGS_MAP] = objectSettingsMap
+            }
+            settings = objectSettingsMap.get(subject)
+            if (!(settings instanceof Settings)) {
+                settings = new Settings(
+                Settings.assert(Settings.getObjectSettings(from))
+                )
+                objectSettingsMap.set(subject, settings)
+            }
+        }
+        return settings
+    }
+
+    static extendRuntimeSettings(): Settings {
+        return Settings.getRuntimeSettings().extend()
+    }
+}
+
+declare type SetToolBindingsType = {
+    bindings: IToolBinding[];
+};
+
+declare function setToolStyle(toolName: string, style: Record<string, unknown>): boolean;
+
+declare type ShapeFnCriteria = (pointIJK: Types_2.Point3, pointLPS: Types_2.Point3) => boolean;
+
+declare type SharedToolProp = {
+    supportedInteractionTypes?: Array<string>;
+    configuration?: Record<string, any>;
+};
+
+declare function snapFocalPointToSlice(focalPoint: Types_2.Point3, position: Types_2.Point3, scrollRange: any, viewPlaneNormal: Types_2.Point3, spacingInNormalDirection: number, deltaFrames: number): {
+    newFocalPoint: Types_2.Point3;
+    newPosition: Types_2.Point3;
+};
+
+export declare class SphereScissorsTool extends BaseTool {
+    static toolName: string;
+    editData: {
+        annotation: any;
+        segmentation: any;
+        segmentIndex: number;
+        segmentsLocked: number[];
+        segmentationDataUID: string;
+        toolGroupUID: string;
+        segmentColor: [number, number, number, number];
+        viewportUIDsToRender: string[];
+        handleIndex?: number;
+        movingTextBox: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+        centerCanvas?: Array<number>;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes_2.MouseDownActivateEventType) => void;
+    _mouseDragCallback: (evt: EventTypes_2.MouseDragEventType) => void;
+    _mouseUpCallback: (evt: EventTypes_2.MouseUpEventType | EventTypes_2.MouseClickEventType) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types_2.IEnabledElement, svgDrawingHelper: any) => void;
+}
+
+/**
+ * START_NEW_IMAGE
+ */
+declare type StackNewImageEvent = CustomEvent_2<StackNewImageEventDetail>
+
+/**
+ * STACK_NEW_IMAGE Event's data
+ */
+declare type StackNewImageEventDetail = {
+    /** the new image set on the stack viewport */
+    image: IImage
+    /** the image imageId */
+    imageId: string
+    /** unique id for the viewport */
+    viewportUID: string
+    /** unique id for the renderingEngine */
+    renderingEngineUID: string
+}
+
+export declare class StackScrollMouseWheelTool extends BaseTool {
+    static toolName: string;
+    _configuration: any;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+        invert: boolean;
+    });
+    mouseWheelCallback(evt: MouseWheelEventType): void;
+}
+
+export declare class StackScrollTool extends BaseTool {
+    static toolName: string;
+    touchDragCallback: () => void;
+    mouseDragCallback: () => void;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _dragCallback(evt: EventTypes_2.MouseDragEventType): void;
+}
+
+declare namespace stackScrollTool {
+    export {
+        snapFocalPointToSlice,
+        getSliceRange,
+        scrollThroughStack,
+        _default_14 as default
+    }
+}
+
+/**
+ * Stack Viewport Properties
+ */
+declare type StackViewportProperties = {
+    /** voi range (upper, lower) for the viewport */
+    voiRange?: VOIRange
+    /** invert flag - whether the image is inverted */
+    invert?: boolean
+    /** interpolation type - linear or nearest neighbor */
+    interpolationType?: InterpolationType
+    /** image rotation */
+    rotation?: number
+    /** flip horizontal flag */
+    flipHorizontal?: boolean
+    /** flip vertical flag */
+    flipVertical?: boolean
+}
+
+declare namespace state {
+    export {
+        getAnnotations,
+        addAnnotation,
+        getAnnotation,
+        removeAnnotation,
+        getViewportSpecificAnnotationManager,
+        getDefaultAnnotationManager
+    }
+}
+
+declare namespace state_2 {
+    export {
+        getGlobalSegmentationConfig,
+        getSegmentationConfig,
+        setGlobalSegmentationConfig,
+        setSegmentationConfig,
+        addColorLUT,
+        getColorLut,
+        getGlobalSegmentationState,
+        getGlobalSegmentationDataByUID,
+        addGlobalSegmentationData,
+        getSegmentationState,
+        addSegmentationData,
+        removeSegmentationData,
+        getSegmentationDataByUID,
+        setActiveSegmentationData,
+        getActiveSegmentationData,
+        getToolGroupsWithSegmentation,
+        getToolGroups,
+        getDefaultSegmentationStateManager
+    }
+}
+
+declare type SVGCursorDescriptor = {
+    iconContent: string;
+    iconSize: number;
+    viewBox: SVGPoint_2;
+    mousePoint: SVGPoint_2;
+    mousePointerGroupString: string;
+};
+
+declare class SVGMouseCursor extends ImageMouseCursor {
+    constructor(url: string, x?: number, y?: number, name?: string | undefined, fallback?: MouseCursor | undefined);
+    static getDefinedCursor(name: string, pointer?: boolean, color?: string): MouseCursor;
+}
+
+declare type SVGPoint_2 = {
+    x: number;
+    y: number;
+};
+
+export declare class Synchronizer {
+    private _enabled;
+    private _eventName;
+    private _eventHandler;
+    private _ignoreFiredEvents;
+    private _sourceViewports;
+    private _targetViewports;
+    id: string;
+    constructor(synchronizerId: string, eventName: string, eventHandler: ISynchronizerEventHandler);
+    isDisabled(): boolean;
+    add(viewportInfo: Types_2.IViewportUID): void;
+    addSource(viewportInfo: Types_2.IViewportUID): void;
+    addTarget(viewportInfo: Types_2.IViewportUID): void;
+    getSourceViewports(): Array<Types_2.IViewportUID>;
+    getTargetViewports(): Array<Types_2.IViewportUID>;
+    destroy(): void;
+    remove(viewportInfo: Types_2.IViewportUID): void;
+    removeSource(viewportInfo: Types_2.IViewportUID): void;
+    removeTarget(viewportInfo: Types_2.IViewportUID): void;
+    hasSourceViewport(renderingEngineUID: string, viewportUID: string): boolean;
+    private fireEvent;
+    private _onEvent;
+    private _hasSourceElements;
+    private _updateDisableHandlers;
+}
+
+declare namespace SynchronizerManager {
+    export {
+        createSynchronizer,
+        destroy_2 as destroy,
+        getSynchronizerById,
+        getSynchronizers,
+        getAllSynchronizers,
+        destroySynchronizerById
+    }
+}
+export { SynchronizerManager }
+
+declare namespace synchronizers {
+    export {
+        createCameraPositionSynchronizer,
+        createVOISynchronizer
+    }
+}
+export { synchronizers }
+
+declare type TextBoxHandle = {
+    hasMoved: boolean;
+    worldBoundingBox: {
+        bottomLeft: Types_2.Point3;
+        bottomRight: Types_2.Point3;
+        topLeft: Types_2.Point3;
+        topRight: Types_2.Point3;
+    };
+    worldPosition: Types_2.Point3;
+};
+
+declare type ThresholdRangeOptions = {
+    higherThreshold: number;
+    lowerThreshold: number;
+    numSlicesToProject?: number;
+    overwrite: boolean;
+};
+
+declare type ThresholdRoiStatsOptions = {
+    statistic: 'max' | 'min';
+    weight: number;
+    numSlicesToProject?: number;
+    overwrite: boolean;
+};
+
+declare function thresholdVolumeByRange(toolGroupUID: string, annotations: AnnotationForThresholding[], referenceVolumes: Types_2.IImageVolume[], segmentationData: ToolGroupSpecificSegmentationData, options: ThresholdRangeOptions): Types_2.IImageVolume;
+
+declare function thresholdVolumeByRoiStats(toolGroupUID: string, annotations: AnnotationForThresholding[], referenceVolumes: Types_2.IImageVolume[], segmentationData: ToolGroupSpecificSegmentationData, options: ThresholdRoiStatsOptions): void;
+
+declare function throttle(func: Function, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): Function;
+
+declare type ToolBindingKeyboardType = typeof KeyboardBindings[keyof typeof KeyboardBindings];
+
+declare type ToolBindingMouseType = typeof MouseBindings[keyof typeof MouseBindings];
+
+declare namespace ToolGroupManager {
+    export {
+        _default as default,
+        createToolGroup,
+        destroy_3 as destroy,
+        destroyToolGroupByToolGroupUID,
+        getToolGroupByToolGroupUID,
+        getToolGroup,
+        getAllToolGroups
+    }
+}
+export { ToolGroupManager }
+
+declare type ToolGroupSpecificSegmentationData = {
+    volumeUID: string;
+    segmentationDataUID: string;
+    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;
+
+declare enum ToolModes {
+    Active = "Active",
+    Passive = "Passive",
+    Enabled = "Enabled",
+    Disabled = "Disabled"
+}
+
+declare type ToolOptionsType = {
+    bindings: IToolBinding[];
+    mode: ToolModes;
+};
+
+declare type ToolProps = SharedToolProp;
+
+/** used for CPU rendering */
+declare type TransformMatrix2D = [number, number, number, number, number, number]
+
+declare function transformPhysicalToIndex(imageData: any, physicalPoint: any): any;
+
+declare function triggerAnnotationRenderForViewportUIDs(renderingEngine: Types_2.IRenderingEngine, viewportUIDsToRender: string[]): void;
+
+/**
+ * Small utility to trigger a custom event for a given EventTarget.
+ *
+ * @example
+ *
+ * ```javascript
+ * triggerEvent(element, Events.IMAGE_RENDERED, { element })
+ * ```
+ * or it can trigger event on the eventTarget itself
+ *
+ * ```javascript
+ * triggerEvent(eventTarget, CSTOOLS_EVENTS.ANNOTATION_MODIFIED, { viewportUID, annotationUID })
+ * ```
+ *
+ * @param el - The element or EventTarget to trigger the event upon
+ * @param type - The event type name
+ * @param detail - The event detail to be sent
+ * @returns false if event is cancelable and at least one of the event handlers
+ * which received event called Event.preventDefault(). Otherwise it returns true.
+ */
+declare function triggerEvent(
+el: EventTarget = eventTarget,
+type: string,
+detail: unknown = null
+): boolean {
+    if (!type) {
+        throw new Error('Event type was not defined')
+    }
+
+    const event = new CustomEvent(type, {
+        detail,
+        cancelable: true,
+    })
+
+    return el.dispatchEvent(event)
+}
+
+declare function triggerSegmentationDataModified(toolGroupUID: string, segmentationDataUID: string): void;
+
+declare namespace triggerSegmentationEvents {
+    export {
+        triggerSegmentationStateModified,
+        triggerSegmentationDataModified,
+        triggerSegmentationGlobalStateModified
+    }
+}
+
+declare function triggerSegmentationGlobalStateModified(segmentationUID?: string): void;
+
+declare function triggerSegmentationStateModified(toolGroupUID: string): void;
+
+declare namespace Types {
+    export {
+        Annotation,
+        Annotations,
+        FrameOfReferenceSpecificAnnotations,
+        AnnotationState,
+        PlanarBoundingBox,
+        ToolProps,
+        PublicToolProps,
+        EventTypes_2 as EventTypes,
+        IPoints,
+        IToolBinding,
+        SetToolBindingsType,
+        ToolOptionsType,
+        InteractionTypes,
+        IToolGroup,
+        ToolHandle,
+        AnnotationHandle,
+        TextBoxHandle,
+        SegmentationRepresentation,
+        LabelmapRepresentation,
+        Color,
+        ColorLUT,
+        RepresentationConfig,
+        SegmentationConfig,
+        GlobalSegmentationData,
+        GlobalSegmentationState,
+        GlobalSegmentationStateWithConfig,
+        ToolGroupSpecificSegmentationData,
+        ToolGroupSpecificSegmentationStateWithConfig,
+        ToolGroupSpecificSegmentationState,
+        SVGCursorDescriptor,
+        SVGPoint_2 as SVGPoint
+    }
+}
+export { Types }
+
+declare namespace Types_2 {
+    export {
+        ICamera,
+        IStackViewport,
+        IVolumeViewport,
+        IEnabledElement,
+        ICache,
+        IVolume,
+        IViewportUID,
+        IImageVolume,
+        IRenderingEngine,
+        ScalingParameters,
+        PTScaling,
+        Scaling,
+        IStreamingImageVolume,
+        IImage,
+        IImageData,
+        CPUIImageData,
+        CPUImageData,
+        EventTypes,
+        ImageLoaderFn,
+        VolumeLoaderFn,
+        IRegisterImageLoader,
+        IStreamingVolumeProperties,
+        IViewport,
+        StackViewportProperties,
+        PublicViewportInput,
+        VolumeActor,
+        ActorEntry,
+        IImageLoadObject,
+        IVolumeLoadObject,
+        IVolumeInput,
+        VolumeInputCallback,
+        Metadata,
+        Orientation,
+        Point2,
+        Point3,
+        Point4,
+        Plane,
+        ViewportInputOptions,
+        VOIRange,
+        VOI,
+        FlipDirection,
+        ICachedImage,
+        ICachedVolume,
+        CPUFallbackEnabledElement,
+        CPUFallbackViewport,
+        CPUFallbackTransform,
+        CPUFallbackColormapData,
+        CPUFallbackViewportDisplayedArea,
+        CPUFallbackColormapsData,
+        CPUFallbackColormap,
+        TransformMatrix2D,
+        CPUFallbackLookupTable,
+        CPUFallbackLUT,
+        CPUFallbackRenderingTools,
+        CustomEvent_2 as CustomEventType
+    }
+}
+
+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,
+        planar,
+        viewportFilters,
+        stackScrollTool,
+        drawing_2 as drawing,
+        debounce,
+        deepmerge as deepMerge,
+        throttle,
+        isObject,
+        triggerEvent,
+        calibrateImageSpacing,
+        segmentation_2 as segmentation,
+        triggerAnnotationRenderForViewportUIDs,
+        pointInShapeCallback,
+        pointInSurroundingSphereCallback,
+        getAnnotationNearPoint,
+        getAnnotationNearPointOnEnabledElement,
+        transformPhysicalToIndex,
+        _default_17 as default
+    }
+}
+export { utilities }
+
+declare namespace viewportFilters {
+    export {
+        _default_13 as default,
+        filterViewportsWithToolEnabled,
+        filterViewportsWithFrameOfReferenceUID,
+        getViewportUIDsWithToolToRender
+    }
+}
+
+/**
+ * This type defines the shape of viewport input options, so we can throw when it is incorrect.
+ */
+declare type ViewportInputOptions = {
+    /** background color */
+    background?: [number, number, number]
+    /** orientation of the viewport - Axial, Coronal, Sagittal */
+    orientation?: Orientation
+    /** whether the events should be suppressed and not fired*/
+    suppressEvents?: boolean
+}
+
+declare type ViewportInputs = Array<Types_2.IViewportUID>;
+
+/**
+ * ViewportType enum for cornerstone-render which defines the type of viewport.
+ * It can be either STACK, PERSPECTIVE, ORTHOGRAPHIC.
+ */
+declare enum ViewportType {
+    /**
+     * - Suitable for rendering a stack of images, that might or might not belong to the same image.
+     * - Stack can include 2D images of different shapes, size and direction
+     */
+    STACK = 'stack',
+    /**
+     * - Suitable for rendering a volumetric data which is considered as one 3D image.
+     * - Having a VolumeViewport enables Multi-planar reformation or reconstruction (MPR) by design, in which you can visualize the volume from various different orientations without addition of performance costs.
+     */
+    ORTHOGRAPHIC = 'orthographic',
+    /** Perspective Viewport: Not Implemented yet */
+    PERSPECTIVE = 'perspective',
+}
+
+declare type VOI = {
+    /** Window Width for display */
+    windowWidth: number
+    /** Window Center for display */
+    windowCenter: number
+}
+
+/**
+ * VOI_MODIFIED Event type
+ */
+declare type VoiModifiedEvent = CustomEvent_2<VoiModifiedEventDetail>
+
+/**
+ * VOI_MODIFIED Event's data
+ */
+declare type VoiModifiedEventDetail = {
+    /** Viewport Unique ID in the renderingEngine */
+    viewportUID: string
+    /** Unique ID for the volume in the cache */
+    volumeUID: string
+    /** new VOI range */
+    range: VOIRange
+}
+
+declare type VOIRange = {
+    /** upper value for display */
+    upper: number
+    /** lower value for display */
+    lower: number
+}
+
+/** volume actor which is vtkVolume */
+declare type VolumeActor = vtkVolume
+
+/**
+ * VOLUME_CACHE_VOLUME_ADDED Event type
+ */
+declare type VolumeCacheVolumeAddedEvent =
+CustomEvent_2<VolumeCacheVolumeAddedEventDetail>
+
+/**
+ * VOLUME_CACHE_VOLUME_ADDED Event's data
+ */
+declare type VolumeCacheVolumeAddedEventDetail = {
+    /** the added volume */
+    volume: ICachedVolume
+}
+
+/**
+ * VOLUME_CACHE_VOLUME_REMOVED Event type
+ */
+declare type VolumeCacheVolumeRemovedEvent =
+CustomEvent_2<VolumeCacheVolumeRemovedEventDetail>
+
+/**
+ * VOLUME_CACHE_VOLUME_REMOVED Event's data
+ */
+declare type VolumeCacheVolumeRemovedEventDetail = {
+    /** the removed volume id */
+    volumeId: string
+}
+
+/**
+ * Volume input callback type, used to perform operations on the volume data
+ * after it has been loaded.
+ */
+declare type VolumeInputCallback = (params: {
+    /** vtk volume actor */
+    volumeActor: VolumeActor
+    /** unique volume UID in the cache */
+    volumeUID: string
+}) => unknown
+
+/**
+ * VOLUME_LOADED Event type
+ */
+declare type VolumeLoadedEvent = CustomEvent_2<VolumeLoadedEventDetail>
+
+/**
+ * VOLUME_LOADED Event's data
+ */
+declare type VolumeLoadedEventDetail = {
+    /** the loaded volume */
+    volume: IImageVolume
+}
+
+/**
+ * VOLUME_LOADED_FAILED Event type
+ */
+declare type VolumeLoadedFailedEvent = CustomEvent_2<VolumeLoadedFailedEventDetail>
+
+/**
+ * VOLUME_LOADED_FAILED Event's data
+ */
+declare type VolumeLoadedFailedEventDetail = {
+    /** the volumeId for the volume */
+    volumeId: string
+    error: unknown
+}
+
+/**
+ * Any volumeLoader function should implement a loading given the volumeId
+ * and returns a mandatory promise which will resolve to the loaded volume object.
+ * Additional `cancelFn` and `decache` can be implemented.
+ */
+declare type VolumeLoaderFn = (
+volumeId: string,
+options?: Record<string, any>
+) => {
+    /** promise that resolves to the volume object */
+    promise: Promise<Record<string, any>>
+    /** cancel function */
+    cancelFn?: () => void | undefined
+    /** decache function */
+    decache?: () => void | undefined
+}
+
+export declare class VolumeRotateMouseWheelTool extends BaseTool {
+    static toolName: string;
+    _configuration: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback(evt: MouseWheelEventType): void;
+}
+
+export declare class WindowLevelTool extends BaseTool {
+    static toolName: string;
+    touchDragCallback: () => void;
+    mouseDragCallback: () => void;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+    });
+    _dragCallback(evt: any): void;
+    getPTNewRange({ deltaPointsCanvas, lower, upper, clientHeight }: {
+        deltaPointsCanvas: any;
+        lower: any;
+        upper: any;
+        clientHeight: any;
+    }): {
+        lower: any;
+        upper: any;
+    };
+    getNewRange({ deltaPointsCanvas, useDynamicRange, volumeUID, lower, upper }: {
+        deltaPointsCanvas: any;
+        useDynamicRange: any;
+        volumeUID: any;
+        lower: any;
+        upper: any;
+    }): {
+        lower: number;
+        upper: number;
+    };
+    _getMultiplyerFromDynamicRange(volumeUID: any): number;
+    _getImageDynamicRange: (volumeUID: string) => number;
+}
+
+export declare class ZoomTool extends BaseTool {
+    static toolName: string;
+    touchDragCallback: () => void;
+    mouseDragCallback: () => void;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _dragCallback(evt: any): void;
+    _dragParallelProjection: (evt: any, camera: any) => void;
+    _dragPerspectiveProjection: (evt: any, camera: any) => void;
+}
+
+export { }