@cornerstonejs/core 2.0.0-beta.20 → 2.0.0-beta.21

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

@@ -0,0 +1,42 @@
+import type { ImageQualityStatus } from '../enums';
+import type { PixelDataTypedArray } from './PixelDataTypedArray';
+interface ImageFrame {
+    samplesPerPixel: number;
+    photometricInterpretation: string;
+    planarConfiguration: number;
+    rows: number;
+    columns: number;
+    bitsAllocated: number;
+    bitsStored: number;
+    pixelRepresentation: number;
+    smallestPixelValue: number;
+    largestPixelValue: number;
+    redPaletteColorLookupTableDescriptor: number[];
+    greenPaletteColorLookupTableDescriptor: number[];
+    bluePaletteColorLookupTableDescriptor: number[];
+    redPaletteColorLookupTableData: number[];
+    greenPaletteColorLookupTableData: number[];
+    bluePaletteColorLookupTableData: number[];
+    pixelData: PixelDataTypedArray;
+    imageData?: ImageData;
+    pixelDataLength?: number;
+    preScale?: {
+        enabled: boolean;
+        scaled: boolean;
+        scalingParameters?: {
+            intercept?: number;
+            slope?: number;
+            rescaleSlope?: number;
+            rescaleIntercept?: number;
+            modality?: string;
+            suvbw?: number;
+        };
+    };
+    imageId: string;
+    decodeTimeInMS?: number;
+    loadTimeInMS?: number;
+    imageQualityStatus?: ImageQualityStatus;
+    decodeLevel?: unknown;
+    transferSyntax?: string;
+}
+export type { ImageFrame as default };

package/dist/esm/types/IImageFrame.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,6 +1,11 @@
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
-import type { VoxelManager } from '../utilities';
-import { Metadata, PixelDataTypedArray, Point3, IImageLoadObject, Mat3, RGB } from '../types';
+import type Metadata from './Metadata';
+import type Point3 from './Point3';
+import type Mat3 from './Mat3';
+import type { PixelDataTypedArrayString } from './PixelDataTypedArray';
+import type RGB from './RGB';
+import type { vtkStreamingOpenGLTexture } from '../cache/classes/ImageVolume';
+import type { IVoxelManager } from './IVoxelManager';
 interface IImageVolume {
     readonly volumeId: string;
     dimensions: Point3;
@@ -16,28 +21,26 @@ interface IImageVolume {
             suvbwToSuvbsa?: number;
         };
     };
-    sizeInBytes?: number;
     spacing: Point3;
     numVoxels: number;
     imageData?: vtkImageData;
-    vtkOpenGLTexture: any;
-    loadStatus?: Record<string, any>;
-    imageIds: Array<string>;
+    vtkOpenGLTexture: vtkStreamingOpenGLTexture;
+    loadStatus?: Record<string, unknown>;
+    imageIds: string[];
     referencedVolumeId?: string;
-    referencedImageIds?: Array<string>;
+    referencedImageIds?: string[];
     hasPixelSpacing: boolean;
-    additionalDetails?: Record<string, any>;
+    additionalDetails?: Record<string, unknown>;
     isDynamicVolume(): boolean;
-    convertToCornerstoneImage?: (imageId: string, imageIdIndex: number) => IImageLoadObject;
     cancelLoading?: () => void;
-    getScalarData(): PixelDataTypedArray;
-    voxelManager?: VoxelManager<number> | VoxelManager<RGB>;
-    convertToImageSlicesAndCache(): string[];
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    dataType?: PixelDataTypedArrayString;
+    sizeInBytes?: number;
     getImageIdIndex(imageId: string): number;
     getImageURIIndex(imageURI: string): number;
     destroy(): void;
     decache?: (completelyRemove?: boolean) => void;
-    get imageCacheOffsetMap(): Map<string, any>;
     modified(): void;
+    load?: (callback?: (...args: unknown[]) => void) => void;
 }
-export default IImageVolume;
+export type { IImageVolume as default };

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

@@ -1,6 +1,6 @@
-import IGeometry from './IGeometry';
-import IImage from './IImage';
-import IImageVolume from './IImageVolume';
+import type IGeometry from './IGeometry';
+import type IImage from './IImage';
+import type IImageVolume from './IImageVolume';
 export interface IImageLoadObject {
     promise: Promise<IImage>;
     cancelFn?: () => void;

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

@@ -0,0 +1,23 @@
+import type { PointsXYZ } from './Point3';
+export interface IPointsManager<T> {
+    kIndex: number;
+    sources: IPointsManager<T>[];
+    data: Float32Array;
+    readonly length: number;
+    readonly dimensions: number;
+    readonly dimensionLength: number;
+    forEach(func: (value: T, index: number) => void): void;
+    getPoint(index: number): T | undefined;
+    getPointArray(index: number): T | undefined;
+    reverse(): void;
+    push(point: T): void;
+    map<R>(f: (value: T, index: number) => R): R[];
+    readonly points: T[];
+    toXYZ(): PointsXYZ;
+    subselect(count?: number, offset?: number): IPointsManager<T>;
+}
+export interface PolyDataPointConfiguration {
+    dimensions?: number;
+    initialSize?: number;
+    growSize?: number;
+}

package/dist/esm/types/IPointsManager.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import type { PixelDataTypedArray } from '../types';
+export interface RLERun<T> {
+    value: T;
+    start: number;
+    end: number;
+}
+export interface IRLEVoxelMap<T> {
+    defaultValue: T;
+    pixelDataConstructor: new (length: number) => PixelDataTypedArray;
+    get(index: number): T;
+    getRun(j: number, k: number): RLERun<T>[] | undefined;
+    set(index: number, value: T): void;
+    clear(): void;
+    keys(): number[];
+    getPixelData(k?: number, pixelData?: PixelDataTypedArray): PixelDataTypedArray;
+}

package/dist/esm/types/IRLEVoxelMap.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,5 @@
-import ImageLoaderFn from './ImageLoaderFn';
+import type ImageLoaderFn from './ImageLoaderFn';
 interface IRegisterImageLoader {
     registerImageLoader: (scheme: string, imageLoader: ImageLoaderFn) => void;
 }
-export default IRegisterImageLoader;
+export type { IRegisterImageLoader as default };

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

@@ -1,27 +1,26 @@
-import IStackViewport from './IStackViewport';
-import { PublicViewportInput } from './IViewport';
-import IVolumeViewport from './IVolumeViewport';
-import { IViewport } from './IViewport';
-import IVideoViewport from './IVideoViewport';
+import type IStackViewport from './IStackViewport';
+import type { PublicViewportInput } from './IViewport';
+import type IVolumeViewport from './IVolumeViewport';
+import type { IViewport } from './IViewport';
 export default interface IRenderingEngine {
     id: string;
     hasBeenDestroyed: boolean;
     offscreenMultiRenderWindow: any;
-    offScreenCanvasContainer: any;
-    setViewports(viewports: Array<PublicViewportInput>): void;
+    offScreenCanvasContainer: HTMLDivElement;
+    setViewports(viewports: PublicViewportInput[]): void;
     resize(immediate?: boolean, keepCamera?: boolean): void;
     getViewport(id: string): IViewport;
-    getViewports(): Array<IViewport>;
+    getViewports(): IViewport[];
     render(): void;
-    renderViewports(viewportIds: Array<string>): void;
+    renderViewports(viewportIds: string[]): void;
     renderViewport(viewportId: string): void;
     renderFrameOfReference(FrameOfReferenceUID: string): void;
     fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;
     enableElement(viewportInputEntry: PublicViewportInput): void;
     disableElement(viewportId: string): void;
-    getStackViewports(): Array<IStackViewport>;
-    getVolumeViewports(): Array<IVolumeViewport>;
-    getVideoViewports(): Array<IVideoViewport>;
+    getStackViewports(): IStackViewport[];
+    getVolumeViewports(): IVolumeViewport[];
+    getStackViewport(id: string): IStackViewport;
     destroy(): void;
     _debugRender(): void;
 }

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

@@ -1,5 +1,5 @@
-import { ImageQualityStatus, RequestType } from '../enums';
-import { ImageLoadListener } from './ImageLoadListener';
+import type { ImageQualityStatus, RequestType } from '../enums';
+import type { ImageLoadListener } from './ImageLoadListener';
 export interface RetrieveStage {
     id: string;
     positions?: number[];
@@ -10,16 +10,16 @@ export interface RetrieveStage {
     priority?: number;
     nearbyFrames?: NearbyFrames[];
 }
-export type NearbyFrames = {
+export interface NearbyFrames {
     offset: number;
     imageQualityStatus?: ImageQualityStatus;
-};
-export type BaseRetrieveOptions = {
+}
+export interface BaseRetrieveOptions {
     urlArguments?: string;
     framesPath?: string;
     decodeLevel?: number;
     imageQualityStatus?: ImageQualityStatus;
-};
+}
 export type RangeRetrieveOptions = BaseRetrieveOptions & {
     rangeIndex: number;
     chunkSize?: number | ((metadata: any) => number);

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

@@ -1,4 +1,4 @@
-import { ImageActor } from './IActor';
+import type { ImageActor } from './IActor';
 type StackInputCallback = (params: {
     imageActor: ImageActor;
     imageId: string;

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

@@ -1,2 +1,69 @@
-import type IStackViewport from '../RenderingEngine/StackViewport';
-export default IStackViewport;
+import type CPUIImageData from './CPUIImageData';
+import type { ActorEntry } from './IActor';
+import type ICamera from './ICamera';
+import type IImage from './IImage';
+import type IImageData from './IImageData';
+import type { IStackInput } from './IStackInput';
+import type { IViewport } from './IViewport';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type { Scaling } from './ScalingParameters';
+import type StackViewportProperties from './StackViewportProperties';
+import type { ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions } from '../types/IViewport';
+import type { ImageDataMetaData } from '../RenderingEngine/StackViewport';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+export default interface IStackViewport extends IViewport {
+    setUseCPURendering(value: boolean): void;
+    updateRenderingPipeline(): void;
+    getImageData(): IImageData | CPUIImageData;
+    getCamera(): ICamera;
+    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
+    getRotation(): number;
+    unsetColormap(): void;
+    getImageIds(): string[];
+    setStack(imageIds: string[], imageIdIndex?: number): Promise<string>;
+    resetCamera(options?: unknown): boolean;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getRenderer(): vtkRenderer;
+    getDefaultActor(): ActorEntry;
+    getActors(): ActorEntry[];
+    getActor(actorUID: string): ActorEntry;
+    setActors(actors: ActorEntry[]): void;
+    addActors(actors: ActorEntry[]): void;
+    addActor(actorEntry: ActorEntry): void;
+    removeAllActors(): void;
+    getFrameOfReferenceUID(): string;
+    addImages(images: IStackInput[], immediateRender?: boolean, suppressEvents?: boolean): void;
+    renderImageObject(image: unknown): void;
+    setProperties(properties: StackViewportProperties, suppressEvents?: boolean): void;
+    getCurrentImageId(): string;
+    getImageDataMetadata(image: IImage): ImageDataMetaData;
+    resize(): void;
+    setDefaultProperties(ViewportProperties: StackViewportProperties, imageId?: string): void;
+    clearDefaultProperties(imageId?: string): void;
+    getDefaultProperties(imageId?: string): StackViewportProperties;
+    getProperties(): StackViewportProperties;
+    getCurrentImageIdIndex(): number;
+    hasImageId(imageId: string): boolean;
+    hasImageURI(imageURI: string): boolean;
+    customRenderViewportToCanvas(): {
+        canvas: HTMLCanvasElement;
+        element: HTMLDivElement;
+        viewportId: string;
+        renderingEngineId: string;
+    };
+    getCornerstoneImage(): IImage;
+    resetToDefaultProperties(): void;
+    resetProperties(): void;
+    setImageIdIndex(imageIdIndex: number): Promise<string>;
+    calibrateSpacing(imageId: string): void;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    setViewReference(viewRef: ViewReference): void;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
+    modality: string;
+    scaling: Scaling;
+    stackActorReInitialized: boolean;
+    scroll(delta: number, debounceLoading?: boolean, loop?: boolean): void;
+}

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

@@ -1,6 +1,5 @@
-import { ImageVolume } from './../cache/classes/ImageVolume';
-export default interface IStreamingImageVolume extends ImageVolume {
+import type IImageVolume from './IImageVolume';
+export default interface IStreamingImageVolume extends IImageVolume {
     clearLoadCallbacks(): void;
-    convertToCornerstoneImage(imageId: string, imageIdIndex: number): any;
-    decache(completelyRemove: boolean): void;
+    decache(completelyRemove?: boolean): void;
 }

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

@@ -1,12 +1,12 @@
-import { ImageQualityStatus } from '../enums';
+import type { ImageQualityStatus } from '../enums';
 interface IStreamingVolumeProperties {
-    imageIds: Array<string>;
+    imageIds: string[];
     loadStatus: {
         loaded: boolean;
         loading: boolean;
         cancelled: boolean;
-        cachedFrames: Array<ImageQualityStatus>;
-        callbacks: Array<() => void>;
+        cachedFrames: ImageQualityStatus[];
+        callbacks: (() => void)[];
     };
 }
-export default IStreamingVolumeProperties;
+export type { IStreamingVolumeProperties as default };

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

@@ -1,4 +1,4 @@
-import Point3 from './Point3';
+import type Point3 from './Point3';
 export interface ISurface {
     readonly id: string;
     readonly sizeInBytes: number;

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

@@ -0,0 +1,9 @@
+export interface ITransferFunctionNode {
+    x: number;
+    r: number;
+    g: number;
+    b: number;
+    midpoint?: number;
+    sharpness?: number;
+}
+export type TransferFunctionNodes = ITransferFunctionNode[];

package/dist/esm/types/ITransferFunctionNode.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,2 +1,40 @@
-import type IVideoViewport from '../RenderingEngine/VideoViewport';
-export default IVideoViewport;
+import type { IViewport } from './IViewport';
+import type { PixelDataTypedArray } from './PixelDataTypedArray';
+import type VideoViewportProperties from './VideoViewportProperties';
+import type { VOIRange } from './voi';
+import type { SpeedUnit } from '../enums/VideoEnums';
+import type IImageData from './IImageData';
+import type CPUIImageData from './CPUIImageData';
+export interface IVideoViewport extends IViewport {
+    modality: string;
+    canvasContext: CanvasRenderingContext2D;
+    setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
+    setVideoURL(videoURL: string): Promise<unknown>;
+    togglePlayPause(): boolean;
+    play(): Promise<void>;
+    pause(): void;
+    scroll(delta?: number): Promise<void>;
+    start(): Promise<void>;
+    end(): Promise<void>;
+    setTime(timeInSeconds: number): Promise<void>;
+    setFrameNumber(frame: number): Promise<void>;
+    setFrameRange(frameRange: number[]): void;
+    getFrameRange(): [number, number];
+    setProperties(props: VideoViewportProperties): void;
+    setPlaybackRate(rate?: number): void;
+    setScrollSpeed(scrollSpeed?: number, unit?: SpeedUnit): void;
+    getProperties(): VideoViewportProperties;
+    resetProperties(): void;
+    setVOI(voiRange: VOIRange): void;
+    setWindowLevel(windowWidth?: number, windowCenter?: number): void;
+    setAverageWhite(averageWhite: [number, number, number]): void;
+    getFrameNumber(): number;
+    getFrameRate(): number;
+    getMiddleSliceData(): PixelDataTypedArray;
+    getImageData(): IImageData | CPUIImageData;
+    getCurrentImageId(): string;
+    hasImageURI(imageURI: string): boolean;
+    getNumberOfSlices(): number;
+    customRenderViewportToCanvas(): void;
+    useCustomRenderingPipeline: boolean;
+}

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

@@ -1,26 +1,31 @@
-import ICamera from './ICamera';
-import Point2 from './Point2';
-import Point3 from './Point3';
-import ViewportInputOptions from './ViewportInputOptions';
-import { ActorEntry } from './IActor';
-import ViewportType from '../enums/ViewportType';
-import ViewportStatus from '../enums/ViewportStatus';
-import DisplayArea from './displayArea';
-import BoundsLPS from './BoundsLPS';
-export type ViewReferenceSpecifier = {
+import type ICamera from './ICamera';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type ViewportInputOptions from './ViewportInputOptions';
+import type { ActorEntry } from './IActor';
+import type ViewportType from '../enums/ViewportType';
+import type ViewportStatus from '../enums/ViewportStatus';
+import type DisplayArea from './displayArea';
+import type { BoundsLPS } from './BoundsLPS';
+import type { mat4 } from 'gl-matrix';
+import type IRenderingEngine from './IRenderingEngine';
+import type IImageData from './IImageData';
+import type CPUIImageData from './CPUIImageData';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+export interface ViewReferenceSpecifier {
     sliceIndex?: number | [number, number];
     forFrameOfReference?: boolean;
     points?: Point3[];
     volumeId?: string;
-};
-export type ReferenceCompatibleOptions = {
+}
+export interface ReferenceCompatibleOptions {
     withNavigation?: boolean;
     asVolume?: boolean;
     withOrientation?: boolean;
     imageURI?: string;
     asOverlay?: boolean;
-};
-export type ViewReference = {
+}
+export interface ViewReference {
     FrameOfReferenceUID?: string;
     referencedImageId?: string;
     cameraFocalPoint?: Point3;
@@ -29,28 +34,34 @@ export type ViewReference = {
     sliceIndex?: number | [number, number];
     volumeId?: string;
     bounds?: BoundsLPS;
-};
-export type ViewPresentation = {
+}
+export interface ViewPresentation {
     slabThickness?: number;
     rotation?: number;
     displayArea?: DisplayArea;
     zoom?: number;
     pan?: Point2;
-};
-export type ViewPresentationSelector = {
-    slabThickness?: boolean;
+}
+export interface ViewPresentationSelector {
+    slabThickness?: number;
     rotation?: boolean;
     displayArea?: boolean;
     zoom?: boolean;
     pan?: boolean;
     windowLevel?: boolean;
     paletteLut?: boolean;
-};
+}
+export interface DataSetOptions {
+    groupId?: string;
+    viewSelector?: ViewPresentationSelector;
+    viewReference?: ViewReferenceSpecifier;
+}
 interface IViewport {
     id: string;
-    getWidget: (id: string) => any;
-    addWidget: (id: string, widget: any) => void;
-    getWidgets: () => any;
+    getImageData: () => IImageData | CPUIImageData | undefined;
+    getWidget: (id: string) => unknown;
+    addWidget: (id: string, widget: unknown) => void;
+    getWidgets: () => unknown;
     removeWidgets: () => void;
     renderingEngineId: string;
     type: ViewportType;
@@ -60,8 +71,8 @@ interface IViewport {
     sy: number;
     sWidth: number;
     sHeight: number;
-    _actors: Map<string, any>;
-    defaultOptions: any;
+    _actors: Map<string, unknown>;
+    defaultOptions: unknown;
     options: ViewportInputOptions;
     suppressEvents: boolean;
     isDisabled: boolean;
@@ -71,18 +82,18 @@ interface IViewport {
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
     getDefaultActor(): ActorEntry;
-    getActors(): Array<ActorEntry>;
+    getActors(): ActorEntry[];
     getActor(actorUID: string): ActorEntry;
     getActorUIDByIndex(index: number): string;
     getActorByIndex(index: number): ActorEntry;
-    setActors(actors: Array<ActorEntry>): void;
-    addActors(actors: Array<ActorEntry>): void;
+    setActors(actors: ActorEntry[]): void;
+    addActors(actors: ActorEntry[]): void;
     addActor(actorEntry: ActorEntry): void;
-    getActorUIDs(): Array<string>;
+    getActorUIDs(): string[];
     removeAllActors(): void;
-    removeActors(actorUIDs: Array<string>): void;
-    getRenderingEngine(): any;
-    getRenderer(): void;
+    removeActors(actorUIDs: string[]): void;
+    getRenderingEngine(): IRenderingEngine;
+    getRenderer(): vtkRenderer;
     render(): void;
     setOptions(options: ViewportInputOptions, immediate: boolean): void;
     setDisplayArea(displayArea: DisplayArea, callResetCamera?: boolean, suppressEvents?: boolean): any;
@@ -105,6 +116,14 @@ interface IViewport {
     getNumberOfSlices(): number;
     getCurrentImageIdIndex(): number;
     getSliceIndex(): number;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
     getViewReferenceId(viewRefSpecifier?: ViewReferenceSpecifier): string;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
@@ -112,29 +131,31 @@ interface IViewport {
     setViewReference(viewRef: ViewReference): any;
     setViewPresentation(viewPres: ViewPresentation): any;
     customRenderViewportToCanvas: () => unknown;
-    _getCorners(bounds: Array<number>): Array<number>[];
+    _getCorners(bounds: number[]): number[][];
     updateRenderingPipeline: () => void;
+    getTargetId?: () => string;
+    setDataIds(dataIds: string[], options?: DataSetOptions): void;
 }
-type PublicViewportInput = {
+interface PublicViewportInput {
     element: HTMLDivElement;
     viewportId: string;
     type: ViewportType;
     defaultOptions?: ViewportInputOptions;
-};
-type NormalizedViewportInput = {
+}
+interface NormalizedViewportInput {
     element: HTMLDivElement;
     viewportId: string;
     type: ViewportType;
     defaultOptions: ViewportInputOptions;
-};
-type InternalViewportInput = {
+}
+interface InternalViewportInput {
     element: HTMLDivElement;
     canvas: HTMLCanvasElement;
     viewportId: string;
     type: ViewportType;
     defaultOptions: ViewportInputOptions;
-};
-type ViewportInput = {
+}
+interface ViewportInput {
     id: string;
     element: HTMLDivElement;
     canvas: HTMLCanvasElement;
@@ -145,5 +166,5 @@ type ViewportInput = {
     sWidth: number;
     sHeight: number;
     defaultOptions: ViewportInputOptions;
-};
+}
 export type { IViewport, ViewportInput, PublicViewportInput, InternalViewportInput, NormalizedViewportInput, };

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

@@ -1,3 +1,3 @@
-import { ImageVolumeProps } from './ImageVolumeProps';
+import type { ImageVolumeProps } from './ImageVolumeProps';
 type IVolume = ImageVolumeProps;
-export { IVolume };
+export type { IVolume };

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

@@ -1,5 +1,5 @@
-import { VolumeActor } from './IActor';
-import BlendModes from '../enums/BlendModes';
+import type { VolumeActor } from './IActor';
+import type BlendModes from '../enums/BlendModes';
 type VolumeInputCallback = (params: {
     volumeActor: VolumeActor;
     volumeId: string;