larvitar 4.0.0-alpha.3 → 4.0.0-alpha.30

package/dist/imaging/MetaDataReadable.d.ts

@@ -27,6 +27,8 @@ export type MetaDataReadable = {
     frameDelay?: number;
     rWaveTimeVector?: number[];
     isMultiframe?: boolean;
+    isVideo?: boolean;
+    isVideoSupported?: boolean;
     waveform?: boolean;
     temporalPositionIdentifier?: number;
     numberOfTemporalPositions?: number;

package/dist/imaging/MetaDataTypes.d.ts

@@ -1,6 +1,7 @@
 export type ExtendedMetaDataTypes = MetaDataTypes & {
     [key: string]: unknown;
 };
+export declare const arrayTags: string[];
 export type MetaDataTypes = {
     x20000010?: number;
     x2000001e?: MetaDataTypes[];
@@ -1834,9 +1835,9 @@ export type MetaDataTypes = {
     x00281080?: string;
     x00281090?: string;
     x00281100?: number;
-    x00281101?: number;
-    x00281102?: number;
-    x00281103?: number;
+    x00281101?: number[];
+    x00281102?: number[];
+    x00281103?: number[];
     x00281104?: number;
     x00281111?: number;
     x00281112?: number;
@@ -3491,4 +3492,5 @@ export type MetaDataTypes = {
     x300e0005?: string;
     x300e0008?: string;
     x50003000?: MetaDataTypes[];
+    x7fe00010?: number;
 };

package/dist/imaging/imageContours.d.ts

@@ -15,4 +15,4 @@ import { Contours } from "./types";
  */
 export declare const parseContours: (contoursData: {
     [key: string]: Uint8Array;
-}, pointBatchSize: number, segmentationName: string, viewports: Array<string>) => Contours;
+}, pointBatchSize: number, segmentationName: string, viewports?: Array<string>) => Contours;

package/dist/imaging/imageIo.d.ts

@@ -47,6 +47,13 @@ export declare const importNRRDImage: (bufferArray: ArrayBuffer) => Object;
  * @returns {String | null} base64 image (png full quality) or null if canvas does not exist
  */
 export declare const exportImageToBase64: (elementId: string, imageType: string) => string | null;
+/**
+ * Export 3D image rendered in a canvas to base64
+ * @function exportImageToBase64
+ * @param elementId - Id of the div element containing the canvas
+ * @returns {String | null} base64 image (png full quality) or null if canvas does not exist
+ */
+export declare const export3DImageToBase64: (elementId: string, imageType: "png" | "jpeg") => Promise<string | null>;
 /**
  * Export image rendered in a canvas to base64
  * @function exportImageToBase64OriginalSizes

package/dist/imaging/imageManagers.d.ts

@@ -42,7 +42,7 @@ export declare const resetImageManager: () => void;
  * Remove a stored seriesId from the image manager
  * @instance
  * @function removeDataFromImageManager
- * @param {String} seriesId The Id of the series
+ * @param {String} uniqueUID The Id of the series
  */
 export declare const removeDataFromImageManager: (uniqueUID: string) => void;
 /**

package/dist/imaging/imageParsing.d.ts

@@ -4,7 +4,7 @@
 import { DataSet } from "dicom-parser";
 import { ImageObject, MetaData } from "./types";
 import { getImageManager } from "./imageManagers";
-import type { ExtendedMetaDataTypes } from "./MetaDataTypes";
+import { type ExtendedMetaDataTypes } from "./MetaDataTypes";
 /**
  * Reset series stack object and its internal data
  * @instance

package/dist/imaging/imageRendering.d.ts

@@ -3,7 +3,8 @@
  *         rendering images in html canvas using cornerstone
  */
 import cornerstone from "cornerstone-core";
-import { RenderProps, Series, StoreViewport, Viewport } from "./types";
+import { DisplayedArea, RenderProps, Series, StoreViewport, Viewport } from "./types";
+import { ViewportComplete } from "./tools/types";
 /**
  * Purge the cornestone internal cache
  * If seriesId is passed as argument only imageIds of the series are purged from internal cache
@@ -106,6 +107,23 @@ export declare const unloadViewport: (elementId: string) => void;
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
  */
 export declare const resizeViewport: (elementId: string | HTMLElement) => void;
+/**
+ * Check if the displayed image is anisotropic (row pixel spacing !== col pixel spacing)
+ * @instance
+ * @function isAnisotropic
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Boolean}
+ */
+export declare const isAnisotropic: (elementId: string) => boolean;
+/**
+ * Retrieves Anisotropic Viewport displayedArea properties
+ * @instance
+ * @function getAnisotropicDisplayedArea
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {ViewportComplete} viewport - The viewport
+ * @returns {DisplayedArea}
+ */
+export declare const getAnisotropicDisplayedArea: (id: string, viewport: ViewportComplete) => DisplayedArea | undefined;
 /**
  * Cache image and render it in a html div using cornerstone
  * @instance

package/dist/imaging/imageStore.d.ts

@@ -3,6 +3,7 @@
  *        for data config store.
  */
 import type { StoreViewport } from "./types";
+import { ICamera, VolumeViewport } from "../imaging3d/types";
 type StoreSeries = {
     imageIds: string[];
     progress: number;
@@ -25,14 +26,14 @@ type Store = {
     [key: string]: any;
 };
 type SetPayload = ["errorLog" | "leftActiveTool" | "rightActiveTool", string] | [
-    ("isColor" | "isMultiframe" | "isPDF" | "waveform" | "dsa" | "isTimeserie" | "isDSAEnabled" | "ready"),
+    ("isColor" | "isMultiframe" | "isVideo" | "isVideoSupported" | "isPDF" | "waveform" | "dsa" | "isTimeserie" | "isDSAEnabled" | "ready"),
     string,
     boolean
 ] | [
     ("progress" | "loading" | "minPixelValue" | "maxPixelValue" | "minSliceId" | "maxSliceId" | "minTimeId" | "maxTimeId" | "rotation" | "scale" | "sliceId" | "timeId" | "thickness" | "numberOfFrames" | "numberOfTemporalPositions"),
     string,
     number
-] | ["cached", string, string, boolean] | ["timestamp", string, number | undefined] | ["uniqueUID" | "modality", string, string | undefined] | ["pendingSliceId", string, number | undefined] | ["timestamps" | "timeIds", string, number[]] | ["pixelShift", string, number[] | undefined] | [
+] | ["cached", string, string, boolean] | ["timestamp", string, number | undefined] | ["uniqueUID" | "modality" | "filterName", string, string | undefined] | ["pendingSliceId", string, number | undefined] | ["timestamps" | "timeIds", string, number[]] | ["pixelShift", string, number[] | undefined] | [
     "contrast" | "dimensions" | "spacing" | "translation",
     string,
     number,
@@ -47,7 +48,7 @@ type SetPayload = ["errorLog" | "leftActiveTool" | "rightActiveTool", string] |
     number,
     number,
     boolean
-];
+] | ["camera", string, ICamera] | ["mpr", string, VolumeViewport];
 export declare const set: (payload: SetPayload) => void;
 declare const _default: {
     initialize: () => void;
@@ -62,6 +63,7 @@ declare const _default: {
     setTimeId: (elementId: string, timeIndex: number) => void;
     setDSAEnabled: (elementId: string, enabled: boolean) => void;
     setDSAPixelShift: (elementId: string, pixelShift?: number[]) => void;
+    setImageFilter: (elementId: string, filterName: string) => void;
     resetActiveTools(): void;
     get: (props: string | string[] | undefined) => any;
     addStoreListener: (listener: (data: Store) => {}) => (data: Store) => {};

package/dist/imaging/imageTools.d.ts

@@ -1,20 +1,145 @@
-export function addDefaultTools(toolToActivate: any): void;
-export function addDiameterTool(elementId: string, diameters: any[], seriesId: string): void;
-export function addContoursTool(rawContours: Object, maskName: string): void;
-export function addMaskEditingTool(mask: any[], callback: Function, targetViewport: string): void;
-export function setSegmentationConfig(config: Object): void;
-export function getCurrentMaskData(viewportId: string): any[];
-export function addStackStateToElement(seriesId: string, element: HTMLElement): void;
-export function addSeedsTool(preLoadSeeds: any[], initViewport: string): void;
-export function clearMeasurements(): void;
-export function setToolActive(toolName: string, options: Object, activeViewport: string, viewports: any[]): void;
-export function setToolDisabled(toolName: string, activeViewport: string, viewports: any[]): void;
-export function setToolEnabled(toolName: string, activeViewport: string, viewports: any[]): void;
-export function setToolPassive(toolName: string, activeViewport: string, viewports: any[]): void;
-export function getToolState(toolName: string): Object;
-export function clearToolStateByName(toolName: string, options: Object): void;
-export function updateDiameterTool(diameterId: string | number, value: Object, seriesId: string, viewportId: string): void;
-export function addToolStateSingleSlice(element: HTMLElement, toolName: string, data: Object | any[], slice: number, seriesId: string): void;
-export function clearCornerstoneElements(): void;
-export function syncToolStack(srcSliceNumber: number, toolName: string, viewport: string, seriesId: string): void;
-export function updateStackToolState(elementId: string, imageIndex: number): void;
+/** @module imaging/imageTools
+ *  @desc This file provides functionalities for
+ *        interacting with cornerstone tools
+ *        DEPRECATION WARNING: these are legacy functions
+ *        that will be removed soon. Use the corresponding
+ *        functions in /tools/main.js instead.
+ *        For this reason, this file will not be translated to TypeScript.
+ */
+import { DiameterStateData, SegmentationConfig } from "./tools/types";
+/**
+ * Add Diameter tool
+ * @function addDiameterTool
+ * @param {String} elementId - The target hmtl element id or its DOM HTMLElement
+ * @param {Array} diameters - The array of diameter objects.
+ * @param {String} seriesId - The id of the target serie.
+ */
+export declare const addDiameterTool: (elementId: string, diameters: number[], seriesId: string) => void;
+/**
+ * Add Contour tool
+ * @function addContoursTool
+ * @param {Object} rawContours - The contours object (generated from a segmentation mask).
+ * @param {String} maskName - The name tag that identify the mask
+ */
+/**
+ * Add Contour tool
+ * @function addContoursTool
+ * @param {Object} rawContours - The contours object (generated from a segmentation mask).
+ * @param {String} maskName - The name tag that identify the mask
+ */
+export declare const addContoursTool: (rawContours: {
+    [key: string]: Uint8Array;
+}, maskName: string) => void;
+/**
+ * Add mask editing tool
+ * @function addMaskEditingTool
+ * @param {Array} mask - The mask data.
+ * @param {Function} callback - The tool initialization callback
+ * @param {String} targetViewport - The target hmtl element id.
+ */
+export declare const addMaskEditingTool: (mask: string[], callback: () => void, targetViewport: string) => void;
+/**
+ * Modify configuration for cornerstone tools segmentation module
+ * @function setSegmentationConfig
+ * @param {Object} config - The custom configuration.
+ * @example
+ * Example of custom configuration
+ * config = {
+      renderOutline: true,
+      renderFill: true,
+      shouldRenderInactiveLabelmaps: true,
+      radius: 10,
+      minRadius: 1,
+      maxRadius: 50,
+      segmentsPerLabelmap: 65535,
+      fillAlpha: 0.7,
+      fillAlphaInactive: 0.1,
+      outlineAlpha: 0.7,
+      outlineAlphaInactive: 0.35,
+      outlineWidth: 3,
+      storeHistory: true
+    };
+ */
+export declare const setSegmentationConfig: (config: Partial<SegmentationConfig>) => void;
+/**
+ * Get mask editing tool current data from state
+ * @function getCurrentMaskData
+ * @param {String} viewportId - The target hmtl element id.
+ * @return {Array} labelmap3D - The mask array
+ */
+export declare const getCurrentMaskData: (viewportId: string) => unknown[];
+/**
+ * Add Stack State to a single hmtl element
+ * @function addStackStateToElement
+ * @param {String} seriesId - The id of the target serie.
+ * @param {HTMLElement} element - The target hmtl element.
+ */
+export declare const addStackStateToElement: (seriesId: string, element: HTMLElement) => void;
+/**
+ * Add seeds tool
+ * @function addSeedsTool
+ * @param {Array} preLoadSeeds - The array of seeds to load as initialization.
+ * @param {String} initViewport - The hmtl element id to be used for tool initialization.
+ */
+export declare const addSeedsTool: (preLoadSeeds: string[], initViewport: string) => void;
+/**
+ * Delete all measurements from tools state, for tools that have the "cleaneable" prop set to true in tools/default.js
+ * @function clearMeasurements
+ */
+export declare const clearMeasurements: () => void;
+/**
+ * Get tool data for all enabled elements
+ * @function getToolState
+ * @param {String} toolName - The tool name.
+ * @return {Object} - Tool data grouped by element id
+ */
+export declare const getToolState: (toolName: string) => any;
+/**
+ * Clear tool data for a subset of seeds
+ * @function clearToolStateByName
+ * @param {String} toolName - The tool name.
+ * @param {Object} options - Props used to select the data to delete (at the moment only {name : "targetName"} is implemented)
+ */
+export declare const clearToolStateByName: (toolName: string, options: any) => void;
+/**
+ * Update diameter tool with new value (removing old one)
+ * @function updateDiameterTool
+ * @param {String | Number} diameterId - The id that identify the diameter data.
+ * @param {Object} value - The object representing the new diameter data.
+ * @param {String} seriesId - The target serie id.
+ * @param {String} viewportId - The viewport id.
+ */
+export declare const updateDiameterTool: (diameterId: string, value: {
+    tool: DiameterStateData;
+}, seriesId: string, viewportId: string) => void;
+/**
+ * Add tool data for a single target slice
+ * @function addToolStateSingleSlice
+ * @param {HTMLElement} element - The target hmtl element.
+ * @param {String} toolName - The tool name.
+ * @param {Object | Array} data - The tool data to add (tool-specific)
+ * @param {Number} slice - The target slice to put the data in.
+ * @param {String} seriesId - The target serie id.
+ */
+export declare const addToolStateSingleSlice: (element: HTMLElement, toolName: string, data: Partial<DiameterStateData>, slice: number, seriesId?: string) => void;
+/**
+ * Clear tool state and disable all cornerstone elements
+ * @function clearCornerstoneElements
+ */
+export declare const clearCornerstoneElements: () => void;
+/**
+ * Sync the cornerstone tools stack given a slice as data source
+ * @function syncToolStack
+ * @param {Number} srcSliceNumber - The slice to be used as data source.
+ * @param {String} toolName - The name of the tool to sync.
+ * @param {String} viewport - The target viewport id.
+ * @param {String} seriesId - The target serie id.
+ */
+export declare const syncToolStack: (srcSliceNumber: number, toolName: string, viewport: string, seriesId: string) => void;
+/**
+ * Update slice index in cornerstone tools stack state
+ * @function updateStackToolState
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {Number} imageIndex - The new imageIndex value.
+ */
+export declare const updateStackToolState: (elementId: string | HTMLElement, imageIndex: number) => void;

package/dist/imaging/imageUtils.d.ts

@@ -2,7 +2,7 @@
  *  @desc This file provides utility functions for
  *        manipulating image pixels and image metadata
  */
-import type { CustomDataSet, MetaData, ReslicedInstance, Series } from "./types";
+import type { CustomDataSet, MetaData, ReslicedInstance, Series, TypedArray } from "./types";
 /**
  * @typedef {Object} CornerstoneSeries
  * @property {Array} imageIds Array of the instances imageIds
@@ -16,20 +16,30 @@ import type { CustomDataSet, MetaData, ReslicedInstance, Series } from "./types"
  * @param {Array} el - The image_orientation dicom tag
  */
 export declare const getNormalOrientation: (el: [number, number, number, number, number, number]) => number[];
+/**
+ * Get the min and max pixel value from pixelData
+ * @instance
+ * @function getMinPixelValue
+ * @param {Array} pixelData - Pixel data array
+ */
+export declare const getMinMaxPixelValue: (pixelData: number[] | TypedArray) => {
+    minPixelValue: number;
+    maxPixelValue: number;
+};
 /**
  * Get the min pixel value from pixelData
  * @instance
  * @function getMinPixelValue
  * @param {Array} pixelData - Pixel data array
  */
-export declare const getMinPixelValue: (pixelData: number[]) => number;
+export declare const getMinPixelValue: (pixelData: number[] | TypedArray) => number;
 /**
  * Get the max pixel value from pixelData
  * @instance
  * @function getMaxPixelValue
  * @param {Array} pixelData - Pixel data array
  */
-export declare const getMaxPixelValue: (pixelData: number[]) => number;
+export declare const getMaxPixelValue: (pixelData: number[] | TypedArray) => number;
 /**
  * Create the pixel representation string (type and length) from dicom tags
  * @instance
@@ -56,10 +66,11 @@ export declare const getTypedArrayFromDataType: (dataType: string) => Uint8Array
  * @function getSortedStack
  * @param {Object} seriesData - The dataset
  * @param {Array} sortPriorities - An array which represents the priority tasks
+ * @param {Bool} is3D - Boolean for 3D series
  * @param {Bool} returnSuccessMethod - Boolean for returning the success method
  * @return {Object} The sorted stack
  */
-export declare const getSortedStack: (seriesData: Series, sortPriorities: Array<"imagePosition" | "contentTime" | "instanceNumber">, returnSuccessMethod: boolean) => string[];
+export declare const getSortedStack: (seriesData: Series, sortPriorities: Array<"imagePosition" | "contentTime" | "instanceNumber">, returnSuccessMethod: boolean, is3D?: boolean) => string[];
 /**
  * Sort the array of instanceUIDs according to imageIds sorted using sortSeriesStack
  * @instance
@@ -70,6 +81,16 @@ export declare const getSortedStack: (seriesData: Series, sortPriorities: Array<
 export declare const getSortedUIDs: (seriesData: Series) => {
     [key: string]: string;
 };
+/**
+ * Sort the array of instanceUIDs3D according to imageIds3D sorted using sortSeriesStack
+ * @instance
+ * @function getSortedUIDs3D
+ * @param {Object} seriesData - The dataset
+ * @return {Object} The sorted instanceUIDs
+ */
+export declare const getSortedUIDs3D: (seriesData: Series) => {
+    [key: string]: string;
+};
 /**
  * Generate a randomUUID in the form 'uy0x2qz9jk9co642cjfus'
  * @instance

package/dist/imaging/loaders/commonLoader.d.ts

@@ -3,31 +3,13 @@
  *        custom DICOMImageLoaders
  */
 import { DataSet } from "dicom-parser";
-import type { MetaData } from "../types";
+import type { ImageFrame, MetaData } from "../types";
 /**
  * Compute and return image frame
  * @instance
  * @function getImageFrame
- * @param {Object} metadata metadata object
- * @param {Object} dataSet dicom dataset
+ * @param {MetaData} metadata metadata object
+ * @param {DataSet} dataSet dicom dataset
  * @returns {Object} specific image frame
  */
-export declare const getImageFrame: (metadata: MetaData, dataSet: DataSet) => {
-    samplesPerPixel: any;
-    photometricInterpretation: any;
-    planarConfiguration: any;
-    rows: any;
-    columns: any;
-    bitsAllocated: any;
-    pixelRepresentation: any;
-    smallestPixelValue: any;
-    largestPixelValue: any;
-    redPaletteColorLookupTableDescriptor: any;
-    greenPaletteColorLookupTableDescriptor: any;
-    bluePaletteColorLookupTableDescriptor: any;
-    redPaletteColorLookupTableData: any;
-    greenPaletteColorLookupTableData: any;
-    bluePaletteColorLookupTableData: any;
-    pixelData: undefined;
-    ImageData: undefined;
-};
+export declare const getImageFrame: (metadata: MetaData, dataSet?: DataSet) => ImageFrame;

package/dist/imaging/loaders/singleFrameLoader.d.ts

@@ -2,16 +2,26 @@
  *  @desc  This file is a custom DICOM loader for single frame of multiframe images
  */
 import { ImageLoader } from "cornerstone-core";
-import type { ImageObject, MetaData } from "../types";
+import type { ImageObject, MetaData, SingleFrameCache } from "../types";
+/**
+ * Get the single frame cache
+ * @export
+ * @function getSingleFrameCache
+ * @param {String} imageId - Optional Image tag
+ * @returns {Object} - Single frame cache object
+ */
+export declare const getSingleFrameCache: (imageId?: string) => {
+    [key: string]: SingleFrameCache;
+};
 /**
  * Set the single frame cache
  * @export
  * @function setSingleFrameCache
- * @param {Array} data - Pixel data array
+ * @param {Array} pixelData - Pixel data array
  * @param {MetaData} metadata - Metadata object
  * @returns {ImageObject} - Image object
  */
-export declare const setSingleFrameCache: (data: Uint8ClampedArray, metadata: MetaData) => Promise<ImageObject>;
+export declare const setSingleFrameCache: (pixelData: Uint8ClampedArray, metadata: MetaData) => Promise<ImageObject>;
 /**
  * Clear single frame cache
  * @export

package/dist/imaging/parsers/ecg.d.ts

@@ -2,14 +2,13 @@
  *  @desc  This file provides functionalities for
  *         handling ECG signales in DICOM files
  */
-import { DataSet } from "dicom-parser";
+import { MetaData } from "../types";
 /**
  * Generate an array of points representing the ECG signal
- * @instance
  * @function parseECG
- * @param {DataSet} dataSet - the DICOM dataset
- * @param {String} tag - the tag of the ECG signal
+ * @param {DataSet} seriesId - the series ID to which the ECG data belongs
+ * @param {MetaData} metadata - the metadata object containing the ECG signal data
  * @param {Number} nSampling - the sampling rate
  * @returns {void}
  */
-export declare function parseECG(seriesId: string, dataSet: DataSet, tag: string, nSampling?: number): void;
+export declare const parseECG: (seriesId: string, metadata: MetaData, nSampling?: number) => void;

package/dist/imaging/postProcessing/applyKernel.d.ts

@@ -0,0 +1,52 @@
+import { Image, TypedArray, KernelConfig } from "../types";
+/**
+ * Add custom kernel to the global object
+ * @function addCustomKernel
+ * @param {string} name - Name for the new kernel
+ * @param {KernelConfig} config - Kernel configuration (modality, label, size, kernel)
+ * @returns {void}
+ */
+export declare const addCustomKernel: (name: string, config: KernelConfig) => void;
+/**
+ * Get kernels
+ * @function getKernels
+ * @returns {ConvolutionKernels} - CONVOLUTION_KERNELS object
+ */
+export declare const getKernels: () => {
+    [x: string]: KernelConfig;
+};
+/**
+ * Apply convolution filter to DICOM image
+ * @function applyConvolutionFilter
+ * @param {Image} loadedImage - The DICOM image object
+ * @param {string} filterName - Name of the filter to apply
+ * @param {number} multiplier - Optional multiplier for kernel values (default: 1)
+ * @returns {TypedArray} - Convolved pixel data
+ */
+export declare const applyConvolutionFilter: (loadedImage: Image, filterName: string, generateImage?: boolean) => Partial<Image> | TypedArray;
+/**
+ * Create the filtered image
+ * @function createFilteredImage
+ * @param {Image} loadedImage - the source image
+ * @param {number[]} filteredPixelArray - filtered pixel data
+ * @returns {Partial<Image>} - Convolved pixel data
+ */
+export declare const createFilteredImage: (loadedImage: Image, filteredPixelArray: number[]) => Partial<Image>;
+/**
+ * Applies a Gaussian blur filter to a cornerstone image.
+ * @function applyGaussianBlur
+ * @param {Image} loadedImage - The cornerstone image object.
+ * @param {number} kernelSize - The size of the kernel.
+ * @param {number} strength - The sigma value for the Gaussian function.
+ * @returns {Partial<Image>} - The new, blurred cornerstone image object.
+ */
+export declare const applyGaussianBlur: (loadedImage: Image, kernelSize: number, strength: number) => Partial<Image>;
+/**
+ * Applies a sharpening filter to a cornerstone image.
+ * @function applySharpening
+ * @param {Image} loadedImage - The cornerstone image object.
+ * @param {number} kernelSize - The size of the kernel.
+ * @param {number} strength - The strength of the sharpening effect.
+ * @returns {Partial<Image>} - The new, sharpened cornerstone image object.
+ */
+export declare const applySharpening: (loadedImage: Image, kernelSize: number, strength: number) => Partial<Image>;

package/dist/imaging/tools/custom/BorderMagnifyTool.d.ts

@@ -1,21 +1,28 @@
-declare const BorderMagnifyTool_base: any;
-export default class BorderMagnifyTool extends BorderMagnifyTool_base {
-    [x: string]: any;
-    constructor(props?: {});
+import { EventData } from "../types";
+declare const MagnifyTool: any;
+export default class BorderMagnifyTool extends MagnifyTool {
+    static [x: string]: any;
+    constructor(props?: {
+        showBorders?: boolean;
+        showInfo?: boolean;
+        borderColor?: string;
+    });
+    activeCallback(element: HTMLElement): void;
+    disabledCallback(element: HTMLElement): void;
+    passiveCallback(element: HTMLElement): void;
     /**
      * Event handler for the "keydown" event to toggle the visibility of borders and info on "B" key press.
      * @param {KeyboardEvent} event
      * @returns {void}
      */
     handleKeyDown(event: KeyboardEvent): void;
-    activeCallback(element: any): void;
-    disabledCallback(element: any): void;
-    passiveCallback(element: any): void;
     /**
      * Overrides the _drawMagnificationTool method to add configurable borders and display zoom/ROI dimensions.
      * @param {*} evt
      * @returns {void}
      */
-    _drawMagnificationTool(evt: any): void;
+    _drawMagnificationTool(evt?: {
+        detail: EventData;
+    }): void;
 }
 export {};

package/dist/imaging/tools/custom/WwwcRemoveRegionTool.d.ts

@@ -1,3 +1,5 @@
+import { Coords, EventData, MeasurementData, MeasurementMouseEvent } from "../types";
+declare const BaseAnnotationTool: any;
 /**
  * @public
  * @class WwwcRemoveRegionTool
@@ -6,14 +8,10 @@
  * @classdesc Tool for setting wwwc based on a rectangular region.
  * @extends Tools.Base.BaseTool
  */
-export default class WwwcRemoveRegionTool {
+export default class WwwcRemoveRegionTool extends BaseAnnotationTool {
+    static [x: string]: any;
     constructor(props?: {});
-    dataHandles: any[];
-    element: any;
-    _drawingMouseUpCallback: (evt: any) => void;
-    _editMouseUpCallback: (evt: any) => void;
-    throttledUpdateCachedStats: any;
-    createNewMeasurement(eventData: any): {
+    createNewMeasurement(eventData: EventData): {
         computeMeasurements: any;
         visible: boolean;
         active: boolean;
@@ -21,18 +19,18 @@ export default class WwwcRemoveRegionTool {
         invalidated: boolean;
         handles: {
             start: {
-                x: any;
-                y: any;
+                x: number;
+                y: number;
                 highlight: boolean;
                 active: boolean;
             };
             end: {
-                x: any;
-                y: any;
+                x: number;
+                y: number;
                 highlight: boolean;
                 active: boolean;
             };
-            initialRotation: any;
+            initialRotation: number;
             textBox: {
                 active: boolean;
                 hasMoved: boolean;
@@ -43,20 +41,18 @@ export default class WwwcRemoveRegionTool {
             };
         };
     } | undefined;
-    originalWW: any;
-    originalWC: any;
-    pointNearTool(element: any, data: any, coords: any, interactionType: any): boolean;
-    updateCachedStats(image: any, element: any, data: any): void;
-    renderToolData(evt: any): void;
-    mode: any;
-    _withinHandleBoxes(startCanvas: any, endCanvas: any): boolean;
+    pointNearTool(element: Element, data: MeasurementData, coords: Coords, interactionType: string): boolean;
+    updateCachedStats(image: cornerstone.Image, element: Element, data: MeasurementData): void;
+    renderToolData(evt: MeasurementMouseEvent): void;
+    _withinHandleBoxes(startCanvas: Coords, endCanvas: Coords): boolean;
     /**
      * Event handler for MOUSE_UP/TOUCH_END during handle drag event loop.
      *
      * @private
      * @method _applyStrategy
-     * @param {(CornerstoneTools.event#MOUSE_UP|CornerstoneTools.event#TOUCH_END)} evt Interaction event emitted by an enabledElement
+     * @param {MeasurementMouseEvent} evt Interaction event emitted by an enabledElement
      * @returns {void}
      */
-    private _applyStrategy;
+    _applyStrategy(evt: MeasurementMouseEvent): void;
 }
+export {};