@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/types/AnnotationStyle.d.ts

@@ -0,0 +1,30 @@
+type Modes = '' | 'Active' | 'Passive' | 'Enabled';
+type States = '' | 'Highlighted' | 'Selected' | 'Locked' | 'AutoGenerated';
+type Properties = 'color' | 'colorAutoGenerated' | 'lineWidth' | 'lineWidthAutoGenerated' | 'lineDash' | 'textBoxFontFamily' | 'textBoxFontSize' | 'textBoxColor' | 'textBoxBackground' | 'textBoxLinkLineWidth' | 'textBoxLinkLineDash' | 'locked' | 'fillColor' | 'fillOpacity' | 'textbox' | 'shadow' | 'visibility' | 'markerSize';
+export type AnnotationStyle = {
+    [key in `${Properties}${States}${Modes}`]?: string | number | boolean | Record<string, unknown>;
+};
+export type ToolStyleConfig = {
+    [toolName: string]: AnnotationStyle;
+} & {
+    global?: AnnotationStyle;
+};
+export type StyleConfig = {
+    annotations?: {
+        [annotationUID: string]: AnnotationStyle;
+    };
+    viewports?: {
+        [viewportId: string]: ToolStyleConfig;
+    };
+    toolGroups?: {
+        [toolGroupId: string]: ToolStyleConfig;
+    };
+    default: ToolStyleConfig;
+};
+export type StyleSpecifier = {
+    viewportId?: string;
+    toolGroupId?: string;
+    toolName?: string;
+    annotationUID?: string;
+};
+export {};

package/dist/esm/types/AnnotationTypes.d.ts

@@ -0,0 +1,45 @@
+import type { Types } from '@cornerstonejs/core';
+type Annotation = {
+    annotationUID?: string;
+    parentAnnotationUID?: string;
+    interpolationUID?: string;
+    childAnnotationUIDs?: string[];
+    highlighted?: boolean;
+    isLocked?: boolean;
+    isVisible?: boolean;
+    invalidated?: boolean;
+    isSelected?: boolean;
+    autoGenerated?: boolean;
+    metadata: Types.ViewReference & {
+        toolName: string;
+        cameraPosition?: Types.Point3;
+        viewUp?: Types.Point3;
+    };
+    data: {
+        handles?: {
+            points?: Types.Point3[];
+            activeHandleIndex?: number | null;
+            textBox?: {
+                hasMoved?: boolean;
+                worldPosition?: Types.Point3;
+                worldBoundingBox?: {
+                    topLeft: Types.Point3;
+                    topRight: Types.Point3;
+                    bottomLeft: Types.Point3;
+                    bottomRight: Types.Point3;
+                };
+            };
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+        cachedStats?: Record<string, unknown>;
+    };
+};
+type Annotations = Array<Annotation>;
+type GroupSpecificAnnotations = {
+    [toolName: string]: Annotations;
+};
+type AnnotationState = {
+    [key: string]: GroupSpecificAnnotations;
+};
+export type { Annotation, Annotations, GroupSpecificAnnotations, AnnotationState, };

package/dist/esm/types/BoundsIJK.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+type BoundsIJK = Types.BoundsIJK;
+export type { BoundsIJK as default };

package/dist/esm/types/CINETypes.d.ts

@@ -0,0 +1,30 @@
+type PlayClipOptions = {
+    framesPerSecond?: number;
+    frameTimeVector?: number[];
+    reverse?: boolean;
+    loop?: boolean;
+    dynamicCineEnabled?: boolean;
+    frameTimeVectorSpeedMultiplier?: number;
+    waitForRendered?: number;
+};
+interface ToolData {
+    intervalId: number | undefined;
+    framesPerSecond: number;
+    lastFrameTimeStamp: number | undefined;
+    frameTimeVector: number[] | undefined;
+    ignoreFrameTimeVector: boolean;
+    usingFrameTimeVector: boolean;
+    speed: number;
+    reverse: boolean;
+    loop: boolean;
+    dynamicCineEnabled?: boolean;
+}
+type CinePlayContext = {
+    get numScrollSteps(): number;
+    get currentStepIndex(): number;
+    get frameTimeVectorEnabled(): boolean;
+    waitForRenderedCount?: number;
+    scroll(delta: number): void;
+    play?(fps?: number): number;
+};
+export type { PlayClipOptions, ToolData, CinePlayContext };

package/dist/esm/types/CalculatorTypes.d.ts

@@ -0,0 +1,42 @@
+import type { Types } from '@cornerstonejs/core';
+type Statistics = {
+    name: string;
+    label?: string;
+    value: number | number[];
+    unit: null | string;
+    pointIJK?: Types.Point3;
+    pointLPS?: Types.Point3;
+};
+type NamedStatistics = {
+    mean: Statistics & {
+        name: 'mean';
+    };
+    max: Statistics & {
+        name: 'max';
+    };
+    min: Statistics & {
+        name: 'min';
+    };
+    stdDev: Statistics & {
+        name: 'stdDev';
+    };
+    count: Statistics & {
+        name: 'count';
+    };
+    area?: Statistics & {
+        name: 'area';
+    };
+    volume?: Statistics & {
+        name: 'volume';
+    };
+    circumference?: Statistics & {
+        name: 'circumference';
+    };
+    pointsInShape?: Types.IPointsManager<Types.Point3>;
+    maxIJKs?: Array<{
+        value: number;
+        pointIJK: Types.Point3;
+    }>;
+    array: Statistics[];
+};
+export type { Statistics, NamedStatistics };

package/dist/esm/types/CardinalSplineProps.d.ts

@@ -0,0 +1,5 @@
+import type { SplineProps } from './SplineProps';
+export type CardinalSplineProps = SplineProps & {
+    scale?: number;
+    fixedScale?: boolean;
+};

package/dist/esm/types/ClosestControlPoint.d.ts

@@ -0,0 +1,4 @@
+import type { ClosestPoint } from './ClosestPoint';
+export type ClosestControlPoint = ClosestPoint & {
+    index: number;
+};

package/dist/esm/types/ClosestPoint.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export type ClosestPoint = {
+    point: Types.Point2;
+    distance: number;
+};

package/dist/esm/types/ClosestSplinePoint.d.ts

@@ -0,0 +1,4 @@
+import type { ClosestPoint } from './ClosestPoint';
+export type ClosestSplinePoint = ClosestPoint & {
+    uValue: number;
+};

package/dist/esm/types/ContourAnnotation.d.ts

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+export declare enum ContourWindingDirection {
+    CounterClockwise = -1,
+    Unknown = 0,
+    Clockwise = 1
+}
+export type ContourAnnotationData = {
+    data: {
+        cachedStats?: Record<string, unknown>;
+        contour: {
+            polyline: Types.Point3[];
+            closed: boolean;
+            windingDirection?: ContourWindingDirection;
+            pointsManager?: Types.IPointsManager<Types.Point3>;
+        };
+    };
+    onInterpolationComplete?: () => void;
+};
+export type ContourAnnotation = Annotation & ContourAnnotationData;

package/dist/esm/types/ContourAnnotation.js

@@ -0,0 +1,6 @@
+export var ContourWindingDirection;
+(function (ContourWindingDirection) {
+    ContourWindingDirection[ContourWindingDirection["CounterClockwise"] = -1] = "CounterClockwise";
+    ContourWindingDirection[ContourWindingDirection["Unknown"] = 0] = "Unknown";
+    ContourWindingDirection[ContourWindingDirection["Clockwise"] = 1] = "Clockwise";
+})(ContourWindingDirection || (ContourWindingDirection = {}));

package/dist/esm/types/ContourSegmentationAnnotation.d.ts

@@ -0,0 +1,24 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourAnnotation } from './ContourAnnotation';
+export type ContourSegmentationAnnotationData = {
+    autoGenerated?: boolean;
+    interpolationUID?: string;
+    interpolationCompleted?: boolean;
+    data: {
+        segmentation: {
+            segmentationId: string;
+            segmentIndex: number;
+        };
+        contour: {
+            originalPolyline?: Types.Point3[];
+        };
+    };
+    metadata?: {
+        originalToolName?: string;
+    };
+    handles?: {
+        interpolationSources?: Types.IPointsManager<Types.Point3>[];
+    };
+    onInterpolationComplete?: (annotation: ContourSegmentationAnnotation) => unknown;
+};
+export type ContourSegmentationAnnotation = ContourAnnotation & ContourSegmentationAnnotationData;

package/dist/esm/types/ContourTypes.d.ts

@@ -0,0 +1,27 @@
+export type BaseContourStyle = {
+    outlineWidth?: number;
+    outlineOpacity?: number;
+    outlineDash?: string;
+    activeSegmentOutlineWidthDelta?: number;
+    renderOutline?: boolean;
+    renderFill?: boolean;
+    fillAlpha?: number;
+};
+export type InactiveContourStyle = {
+    outlineWidthInactive?: number;
+    outlineOpacityInactive?: number;
+    outlineDashInactive?: string;
+    fillAlphaInactive?: number;
+    renderOutlineInactive?: boolean;
+    renderFillInactive?: boolean;
+};
+export type AutoGeneratedContourStyle = {
+    outlineWidthAutoGenerated?: number;
+    outlineDashAutoGenerated?: string;
+    fillAlphaAutoGenerated?: number;
+};
+export type ContourStyle = BaseContourStyle & InactiveContourStyle & AutoGeneratedContourStyle;
+export type ContourSegmentationData = {
+    geometryIds?: string[];
+    annotationUIDsMap?: Map<number, Set<string>>;
+};

package/dist/esm/types/ControlPointInfo.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export type ControlPointInfo = {
+    index: number;
+    point: Types.Point2;
+};

package/dist/esm/types/CursorTypes.d.ts

@@ -0,0 +1,18 @@
+export type SVGPoint = {
+    x: number;
+    y: number;
+};
+export type SVGCursorDescriptor = {
+    name?: string;
+    iconContent: string;
+    iconSize?: number;
+    viewBox: {
+        x: number;
+        y: number;
+    };
+    mousePoint?: {
+        x: number;
+        y: number;
+    };
+    mousePointerGroupString?: string;
+};

package/dist/esm/types/EventTypes.d.ts

@@ -0,0 +1,234 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+import type IPoints from './IPoints';
+import type ITouchPoints from './ITouchPoints';
+import type IDistance from './IDistance';
+import type { SetToolBindingsType } from './ISetToolModeOptions';
+import type { Swipe } from '../enums/Touch';
+import type { ToolModes, ChangeTypes } from '../enums';
+import type { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+type NormalizedInteractionEventDetail = {
+    eventName: string;
+    renderingEngineId: string;
+    viewportId: string;
+    camera: Record<string, unknown>;
+    element: HTMLDivElement;
+};
+type MouseCustomEventDetail = NormalizedInteractionEventDetail & {
+    event: Record<string, unknown> | MouseEvent;
+    buttons?: number;
+};
+type TouchCustomEventDetail = NormalizedInteractionEventDetail & {
+    event: Record<string, unknown> | TouchEvent;
+};
+type MousePointsDetail = {
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+type TouchPointsDetail = {
+    startPoints: ITouchPoints;
+    lastPoints: ITouchPoints;
+    currentPoints: ITouchPoints;
+    startPointsList: ITouchPoints[];
+    lastPointsList: ITouchPoints[];
+    currentPointsList: ITouchPoints[];
+    deltaPoints: IPoints;
+    deltaDistance: IDistance;
+};
+type InteractionEventDetail = NormalizedInteractionEventDetail & (MouseCustomEventDetail | TouchCustomEventDetail) & (MousePointsDetail | TouchPointsDetail);
+type InteractionStartEventDetail = InteractionEventDetail;
+type InteractionEndEventDetail = InteractionEventDetail;
+type ToolModeChangedEventDetail = {
+    toolGroupId: string;
+    toolName: string;
+    mode: ToolModes;
+    toolBindingsOptions?: SetToolBindingsType;
+};
+type ToolActivatedEventDetail = {
+    toolGroupId: string;
+    toolName: string;
+    toolBindingsOptions: SetToolBindingsType;
+};
+type AnnotationAddedEventDetail = {
+    viewportId?: string;
+    renderingEngineId?: string;
+    annotation: Annotation;
+};
+type AnnotationCompletedEventDetail = {
+    annotation: Annotation;
+    changeType?: ChangeTypes.Completed;
+};
+type AnnotationModifiedEventDetail = {
+    annotation: Annotation;
+    changeType?: ChangeTypes;
+    viewportId?: string;
+    renderingEngineId?: string;
+};
+type AnnotationRemovedEventDetail = {
+    annotation: Annotation;
+    annotationManagerUID: string;
+};
+type AnnotationSelectionChangeEventDetail = {
+    added: Array<string>;
+    removed: Array<string>;
+    selection: Array<string>;
+};
+type AnnotationLockChangeEventDetail = {
+    added: Array<string>;
+    removed: Array<string>;
+    locked: Array<string>;
+};
+type AnnotationVisibilityChangeEventDetail = {
+    lastHidden: Array<string>;
+    lastVisible: Array<string>;
+    hidden: Array<string>;
+};
+type AnnotationRenderedEventDetail = {
+    element: HTMLDivElement;
+    viewportId: string;
+    renderingEngineId: string;
+};
+type AnnotationInterpolationCompletedEventDetail = {
+    annotation: InterpolationROIAnnotation;
+    element: HTMLDivElement;
+    viewportId: string;
+    renderingEngineId: string;
+};
+type AnnotationInterpolationRemovedEventDetail = {
+    annotations: Array<InterpolationROIAnnotation>;
+    element: HTMLDivElement;
+    viewportId: string;
+    renderingEngineId: string;
+};
+type ContourAnnotationCompletedEventDetail = AnnotationCompletedEventDetail & {
+    contourHoleProcessingEnabled: boolean;
+};
+type SegmentationDataModifiedEventDetail = {
+    segmentationId: string;
+    modifiedSlicesToUse?: number[];
+    segmentIndex?: number;
+};
+type SegmentationRenderedEventDetail = {
+    viewportId: string;
+    segmentationId: string;
+    type: string;
+};
+type SegmentationRepresentationModifiedEventDetail = {
+    segmentationId: string;
+    type: string;
+    viewportId: string;
+};
+type SegmentationRemovedEventDetail = {
+    segmentationId: string;
+};
+type SegmentationRepresentationRemovedEventDetail = {
+    segmentationId: string;
+    type: string;
+    viewportId: string;
+};
+type SegmentationModifiedEventDetail = {
+    segmentationId: string;
+};
+type SegmentationAddedEventDetail = {
+    segmentationId: string;
+};
+type KeyDownEventDetail = {
+    element: HTMLDivElement;
+    viewportId: string;
+    renderingEngineId: string;
+    key: string;
+    keyCode: number;
+};
+type KeyUpEventDetail = KeyDownEventDetail;
+type MouseDownEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & {
+    mouseButton: number;
+};
+type TouchStartEventDetail = NormalizedInteractionEventDetail & TouchCustomEventDetail & TouchPointsDetail;
+type MouseDragEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & {
+    mouseButton: number;
+};
+type TouchDragEventDetail = NormalizedInteractionEventDetail & TouchCustomEventDetail & TouchPointsDetail;
+type MouseMoveEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & {
+    currentPoints: IPoints;
+};
+type MouseUpEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & {
+    mouseButton: number;
+};
+type TouchEndEventDetail = NormalizedInteractionEventDetail & TouchPointsDetail & TouchCustomEventDetail;
+type MouseDownActivateEventDetail = NormalizedInteractionEventDetail & MousePointsDetail & MouseCustomEventDetail & {
+    mouseButton: number;
+};
+type TouchStartActivateEventDetail = NormalizedInteractionEventDetail & TouchCustomEventDetail & TouchPointsDetail;
+type MouseClickEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & {
+    mouseButton: number;
+};
+type MouseDoubleClickEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail;
+type TouchTapEventDetail = NormalizedInteractionEventDetail & TouchCustomEventDetail & {
+    currentPointsList: ITouchPoints[];
+    currentPoints: ITouchPoints;
+    taps: number;
+};
+type TouchSwipeEventDetail = NormalizedInteractionEventDetail & TouchCustomEventDetail & {
+    swipe: Swipe;
+};
+type TouchPressEventDetail = NormalizedInteractionEventDetail & TouchCustomEventDetail & {
+    startPointsList: ITouchPoints[];
+    lastPointsList: ITouchPoints[];
+    startPoints: ITouchPoints;
+    lastPoints: ITouchPoints;
+};
+type MouseWheelEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & {
+    detail: Record<string, unknown>;
+    wheel: {
+        spinX: number;
+        spinY: number;
+        pixelX: number;
+        pixelY: number;
+        direction: number;
+    };
+    points: IPoints;
+};
+type NormalizedMouseEventType = Types.CustomEventType<MouseCustomEventDetail>;
+type NormalizedTouchEventType = Types.CustomEventType<TouchCustomEventDetail>;
+type ToolModeChangedEventType = Types.CustomEventType<ToolModeChangedEventDetail>;
+type ToolActivatedEventType = Types.CustomEventType<ToolActivatedEventDetail>;
+type AnnotationAddedEventType = Types.CustomEventType<AnnotationAddedEventDetail>;
+type AnnotationCompletedEventType = Types.CustomEventType<AnnotationCompletedEventDetail>;
+type AnnotationModifiedEventType = Types.CustomEventType<AnnotationModifiedEventDetail>;
+type AnnotationRemovedEventType = Types.CustomEventType<AnnotationRemovedEventDetail>;
+type AnnotationSelectionChangeEventType = Types.CustomEventType<AnnotationSelectionChangeEventDetail>;
+type AnnotationRenderedEventType = Types.CustomEventType<AnnotationRenderedEventDetail>;
+type AnnotationLockChangeEventType = Types.CustomEventType<AnnotationLockChangeEventDetail>;
+type AnnotationVisibilityChangeEventType = Types.CustomEventType<AnnotationVisibilityChangeEventDetail>;
+type AnnotationInterpolationCompletedEventType = Types.CustomEventType<AnnotationInterpolationCompletedEventDetail>;
+type AnnotationInterpolationRemovedEventType = Types.CustomEventType<AnnotationInterpolationRemovedEventDetail>;
+type SegmentationDataModifiedEventType = Types.CustomEventType<SegmentationDataModifiedEventDetail>;
+type SegmentationRepresentationModifiedEventType = Types.CustomEventType<SegmentationRepresentationModifiedEventDetail>;
+type SegmentationRemovedEventType = Types.CustomEventType<SegmentationRemovedEventDetail>;
+type SegmentationRepresentationRemovedEventType = Types.CustomEventType<SegmentationRepresentationRemovedEventDetail>;
+type SegmentationRenderedEventType = Types.CustomEventType<SegmentationRenderedEventDetail>;
+type SegmentationModifiedEventType = Types.CustomEventType<SegmentationModifiedEventDetail>;
+type SegmentationAddedEventType = Types.CustomEventType<SegmentationAddedEventDetail>;
+type KeyDownEventType = Types.CustomEventType<KeyDownEventDetail>;
+type KeyUpEventType = Types.CustomEventType<KeyUpEventDetail>;
+type MouseDownEventType = Types.CustomEventType<MouseDownEventDetail>;
+type TouchTapEventType = Types.CustomEventType<TouchTapEventDetail>;
+type TouchSwipeEventType = Types.CustomEventType<TouchSwipeEventDetail>;
+type TouchPressEventType = Types.CustomEventType<TouchPressEventDetail>;
+type TouchStartEventType = Types.CustomEventType<TouchStartEventDetail>;
+type InteractionEventType = Types.CustomEventType<InteractionEventDetail>;
+type InteractionStartType = Types.CustomEventType<InteractionStartEventDetail>;
+type InteractionEndType = Types.CustomEventType<InteractionEndEventDetail>;
+type MouseDownActivateEventType = Types.CustomEventType<MouseDownActivateEventDetail>;
+type TouchStartActivateEventType = Types.CustomEventType<TouchStartActivateEventDetail>;
+type MouseDragEventType = Types.CustomEventType<MouseDragEventDetail>;
+type TouchDragEventType = Types.CustomEventType<TouchDragEventDetail>;
+type MouseUpEventType = Types.CustomEventType<MouseUpEventDetail>;
+type TouchEndEventType = Types.CustomEventType<TouchEndEventDetail>;
+type MouseClickEventType = Types.CustomEventType<MouseClickEventDetail>;
+type MouseMoveEventType = Types.CustomEventType<MouseMoveEventDetail>;
+type MouseDoubleClickEventType = Types.CustomEventType<MouseDoubleClickEventDetail>;
+type MouseWheelEventType = Types.CustomEventType<MouseWheelEventDetail>;
+export type { InteractionStartType, InteractionEndType, InteractionEventType, NormalizedInteractionEventDetail, NormalizedMouseEventType, NormalizedTouchEventType, ToolModeChangedEventDetail, ToolModeChangedEventType, ToolActivatedEventDetail, ToolActivatedEventType, AnnotationAddedEventDetail, AnnotationAddedEventType, AnnotationCompletedEventDetail, AnnotationCompletedEventType, AnnotationModifiedEventDetail, AnnotationModifiedEventType, AnnotationRemovedEventDetail, AnnotationRemovedEventType, AnnotationSelectionChangeEventDetail, AnnotationSelectionChangeEventType, AnnotationRenderedEventDetail, AnnotationRenderedEventType, AnnotationLockChangeEventDetail, AnnotationVisibilityChangeEventDetail, AnnotationLockChangeEventType, AnnotationVisibilityChangeEventType, AnnotationInterpolationCompletedEventDetail, AnnotationInterpolationCompletedEventType, AnnotationInterpolationRemovedEventDetail, AnnotationInterpolationRemovedEventType, ContourAnnotationCompletedEventDetail, SegmentationDataModifiedEventType, SegmentationRepresentationModifiedEventDetail, SegmentationRepresentationModifiedEventType, SegmentationRepresentationRemovedEventDetail, SegmentationRepresentationRemovedEventType, SegmentationRemovedEventType, SegmentationRemovedEventDetail, SegmentationDataModifiedEventDetail, SegmentationRenderedEventType, SegmentationRenderedEventDetail, SegmentationModifiedEventType, SegmentationModifiedEventDetail, KeyDownEventDetail, KeyDownEventType, KeyUpEventDetail, KeyUpEventType, MouseDownEventDetail, TouchStartEventDetail, MouseDownEventType, TouchStartEventType, MouseDownActivateEventDetail, TouchStartActivateEventDetail, MouseDownActivateEventType, TouchStartActivateEventType, MouseDragEventDetail, TouchDragEventDetail, MouseDragEventType, TouchDragEventType, MouseUpEventDetail, TouchEndEventDetail, MouseUpEventType, TouchEndEventType, MouseClickEventDetail, MouseClickEventType, TouchTapEventDetail, TouchTapEventType, TouchSwipeEventDetail, TouchSwipeEventType, TouchPressEventDetail, TouchPressEventType, MouseMoveEventDetail, MouseMoveEventType, MouseDoubleClickEventDetail, MouseDoubleClickEventType, MouseWheelEventDetail, MouseWheelEventType, SegmentationAddedEventDetail, SegmentationAddedEventType, };

package/dist/esm/types/FloodFillTypes.d.ts

@@ -0,0 +1,16 @@
+import type { Types } from '@cornerstonejs/core';
+type FloodFillResult = {
+    flooded: Types.Point2[] | Types.Point3[];
+};
+type FloodFillGetter3D = (x: number, y: number, z: number) => unknown;
+type FloodFillGetter2D = (x: number, y: number) => unknown;
+type FloodFillGetter = FloodFillGetter2D | FloodFillGetter3D;
+type FloodFillOptions = {
+    onFlood?: (x: number, y: number, z?: number) => void;
+    onBoundary?: (x: number, y: number, z?: number) => void;
+    equals?: (a: any, b: any) => boolean;
+    diagonals?: boolean;
+    bounds?: Map<number, Types.Point2 | Types.Point3>;
+    filter?: (point: any) => boolean;
+};
+export type { FloodFillResult, FloodFillGetter, FloodFillOptions };

package/dist/esm/types/IAnnotationManager.d.ts

@@ -0,0 +1,14 @@
+import type AnnotationGroupSelector from './AnnotationGroupSelector';
+import type { Annotation, Annotations, GroupSpecificAnnotations } from './AnnotationTypes';
+interface IAnnotationManager {
+    getGroupKey: (annotationGroupSelector: AnnotationGroupSelector) => string;
+    addAnnotation: (annotation: Annotation, groupKey: string) => void;
+    getAnnotations: (groupKey: string, toolName?: string) => GroupSpecificAnnotations | Annotations;
+    getAnnotation: (annotationUID: string) => Annotation;
+    removeAnnotation: (annotationUID: string) => void;
+    removeAnnotations: (groupKey: string) => void;
+    removeAllAnnotations: () => void;
+    getNumberOfAnnotations: (groupKey: string, toolName?: string) => number;
+    getNumberOfAllAnnotations: () => number;
+}
+export type { IAnnotationManager as default };

package/dist/esm/types/IBaseTool.d.ts

@@ -0,0 +1,2 @@
+import type BaseTool from '../tools/base/BaseTool';
+export type IBaseTool = BaseTool;

package/dist/esm/types/IDistance.d.ts

@@ -0,0 +1,7 @@
+type IDistance = {
+    page: number;
+    client: number;
+    canvas: number;
+    world: number;
+};
+export type { IDistance as default };

package/dist/esm/types/IPoints.d.ts

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+type IPoints = {
+    page: Types.Point2;
+    client: Types.Point2;
+    canvas: Types.Point2;
+    world: Types.Point3;
+};
+export type { IPoints as default };

package/dist/esm/types/ISculptToolShape.d.ts

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper, EventTypes, ContourAnnotation } from '.';
+import type { PushedHandles } from '../tools/SculptorTool/CircleSculptCursor';
+import type { SculptData } from '../tools/SculptorTool';
+export interface ISculptToolShape {
+    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: any): void;
+    pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
+    configureToolSize(evt: EventTypes.InteractionEventType): void;
+    updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotation): void;
+    getMaxSpacing(minSpacing: number): number;
+    getInsertPosition(previousIndex: number, nextIndex: number, sculptData: SculptData): Types.Point3;
+}