import { ActorRefFrom, AnyActorRef } from 'xstate';
import { MultiscaleSpatialImage, BuiltImage } from '@itk-viewer/io/MultiscaleSpatialImage.js';
import { CreateChild } from './children.js';
import { Camera } from './camera.js';
import { Image } from './image.js';
import { ViewportActor } from './viewport.js';
import { AxisType } from './slice-utils.js';
import { ImageBuilder } from './image-builder.js';
export declare const view2d: import("xstate").StateMachine<{
    slice: number;
    axis: AxisType;
    scale: number;
    image?: MultiscaleSpatialImage;
    spawned: AnyActorRef[];
    viewport?: ViewportActor;
    camera?: Camera;
    imageActor?: Image;
    imageBuilders: Array<ImageBuilder>;
}, CreateChild | {
    type: "setImage";
    image: MultiscaleSpatialImage;
} | {
    type: "setSlice";
    slice: number;
} | {
    type: "setAxis";
    axis: AxisType;
} | {
    type: "setScale";
    scale: number;
} | {
    type: "setViewport";
    viewport: ViewportActor;
} | {
    type: "setResolution";
    resolution: [number, number];
} | {
    type: "setCamera";
    camera: Camera;
} | {
    type: "imageBuilt";
    builtImage: BuiltImage;
    sliceIndex: number;
    actor: ImageBuilder;
}, {
    [x: string]: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
        image: MultiscaleSpatialImage;
        dataRanges: import("@itk-viewer/io/types.js").Ranges;
        colorRanges: import("@itk-viewer/io/types.js").Ranges;
        normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
        colorMaps: string[];
        opacityPoints: (readonly [number, number])[][];
        normalizedOpacityPoints: (readonly [number, number])[][];
    }, {
        type: "getWorker";
        receiver: AnyActorRef;
    } | {
        type: "builtImage";
        builtImage: BuiltImage;
    } | {
        type: "colorRange";
        range: readonly [number, number];
        component: number;
    } | {
        type: "normalizedColorRange";
        range: readonly [number, number];
        component: number;
    } | {
        type: "opacityPoints";
        points: (readonly [number, number])[];
        component: number;
    } | {
        type: "normalizedOpacityPoints";
        points: (readonly [number, number])[];
        component: number;
    } | {
        type: "colorMap";
        colorMap: string;
        component: number;
    }, {}, "active", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
        readonly id: "image";
        readonly initial: "active";
        readonly context: ({ input: image }: {
            spawn: {
                <TSrc extends never>(logic: TSrc, ...[options]: never): never;
                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                    id?: never;
                    systemId?: string;
                    input?: import("xstate").InputFrom<TLogic> | undefined;
                    syncSnapshot?: boolean;
                } | undefined): ActorRefFrom<TLogic>;
            };
            input: MultiscaleSpatialImage;
            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                image: MultiscaleSpatialImage;
                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                colorMaps: string[];
                opacityPoints: (readonly [number, number])[][];
                normalizedOpacityPoints: (readonly [number, number])[][];
            }, {
                type: "getWorker";
                receiver: AnyActorRef;
            } | {
                type: "builtImage";
                builtImage: BuiltImage;
            } | {
                type: "colorRange";
                range: readonly [number, number];
                component: number;
            } | {
                type: "normalizedColorRange";
                range: readonly [number, number];
                component: number;
            } | {
                type: "opacityPoints";
                points: (readonly [number, number])[];
                component: number;
            } | {
                type: "normalizedOpacityPoints";
                points: (readonly [number, number])[];
                component: number;
            } | {
                type: "colorMap";
                colorMap: string;
                component: number;
            }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                type: "getWorker";
                receiver: AnyActorRef;
            } | {
                type: "builtImage";
                builtImage: BuiltImage;
            } | {
                type: "colorRange";
                range: readonly [number, number];
                component: number;
            } | {
                type: "normalizedColorRange";
                range: readonly [number, number];
                component: number;
            } | {
                type: "opacityPoints";
                points: (readonly [number, number])[];
                component: number;
            } | {
                type: "normalizedOpacityPoints";
                points: (readonly [number, number])[];
                component: number;
            } | {
                type: "colorMap";
                colorMap: string;
                component: number;
            }, import("xstate").AnyEventObject>;
        }) => {
            image: MultiscaleSpatialImage;
            dataRanges: never[];
            colorRanges: never[];
            normalizedColorRanges: never[];
            colorMaps: never[];
            opacityPoints: never[];
            normalizedOpacityPoints: never[];
        };
        readonly states: {
            readonly active: {
                readonly on: {
                    readonly builtImage: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>, import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>, "updateNormalizedColorRanges", "updateNormalizedOpacityPoints", "ensureComponentDefaults"];
                    };
                    readonly colorRange: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>, "updateNormalizedColorRanges"];
                    };
                    readonly normalizedColorRange: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>, "updateColorRanges"];
                    };
                    readonly opacityPoints: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>, "updateNormalizedOpacityPoints"];
                    };
                    readonly normalizedOpacityPoints: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>, "updateOpacityPoints"];
                    };
                    readonly colorMap: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image: MultiscaleSpatialImage;
                            dataRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorRanges: import("@itk-viewer/io/types.js").Ranges;
                            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                            colorMaps: string[];
                            opacityPoints: (readonly [number, number])[][];
                            normalizedOpacityPoints: (readonly [number, number])[][];
                        }, {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, {
                            type: "getWorker";
                            receiver: AnyActorRef;
                        } | {
                            type: "builtImage";
                            builtImage: BuiltImage;
                        } | {
                            type: "colorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "normalizedColorRange";
                            range: readonly [number, number];
                            component: number;
                        } | {
                            type: "opacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "normalizedOpacityPoints";
                            points: (readonly [number, number])[];
                            component: number;
                        } | {
                            type: "colorMap";
                            colorMap: string;
                            component: number;
                        }, undefined, never, never, never, never, never>];
                    };
                };
            };
        };
    }>, {
        type: "getWorker";
        receiver: AnyActorRef;
    } | {
        type: "builtImage";
        builtImage: BuiltImage;
    } | {
        type: "colorRange";
        range: readonly [number, number];
        component: number;
    } | {
        type: "normalizedColorRange";
        range: readonly [number, number];
        component: number;
    } | {
        type: "opacityPoints";
        points: (readonly [number, number])[];
        component: number;
    } | {
        type: "normalizedOpacityPoints";
        points: (readonly [number, number])[];
        component: number;
    } | {
        type: "colorMap";
        colorMap: string;
        component: number;
    }, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").MachineSnapshot<{
        slice: number;
        axis: AxisType;
        scale: number;
        image: MultiscaleSpatialImage;
        imageActor?: Image;
        builtImage?: BuiltImage;
        worker?: import("./image-builder.js").ImageWorker;
    }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
            image: MultiscaleSpatialImage;
            listeners: AnyActorRef[];
        }, {
            type: "buildImageInImageSpace";
            scale: number;
            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
        }, {
            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                imageType: import("itk-wasm").ImageType;
                name: string;
                origin: number[];
                spacing: number[];
                direction: Float64Array;
                size: number[];
                data: ArrayBuffer;
                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                metadata: Map<any, any>;
            }, {
                image: MultiscaleSpatialImage;
                scale: number;
                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
            }>, {
                [k: string]: unknown;
                type: string;
            }, import("xstate").EventObject> | undefined;
        }, "idle" | "buildingImage", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
            readonly id: "imageWorker";
            readonly initial: "idle";
            readonly context: ({ input }: {
                spawn: {
                    <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                        src: "imageSpaceBuilder";
                        logic: import("xstate").PromiseActorLogic<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    } extends infer T ? T extends {
                        src: "imageSpaceBuilder";
                        logic: import("xstate").PromiseActorLogic<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    } ? T extends {
                        src: TSrc;
                    } ? import("xstate").ConditionalRequired<[options?: ({
                        id?: T["id"] | undefined;
                        systemId?: string;
                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                        syncSnapshot?: boolean;
                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                        src: "imageSpaceBuilder";
                        logic: import("xstate").PromiseActorLogic<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    }, "src", TSrc>["logic"]>;
                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                        id?: never;
                        systemId?: string;
                        input?: import("xstate").InputFrom<TLogic> | undefined;
                        syncSnapshot?: boolean;
                    } | undefined): ActorRefFrom<TLogic>;
                };
                input: {
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                };
                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                }, {
                    type: "buildImageInImageSpace";
                    scale: number;
                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                    type: "buildImageInImageSpace";
                    scale: number;
                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                }, import("xstate").AnyEventObject>;
            }) => {
                image: MultiscaleSpatialImage;
                listeners: AnyActorRef[];
            };
            readonly states: {
                readonly idle: {
                    readonly on: {
                        readonly buildImageInImageSpace: {
                            readonly target: "buildingImage";
                        };
                    };
                };
                readonly buildingImage: {
                    readonly invoke: {
                        readonly input: ({ context, event }: {
                            context: {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            event: {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            };
                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").AnyEventObject>;
                        }) => {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        };
                        readonly src: "imageSpaceBuilder";
                        readonly onDone: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, import("xstate").DoneActorEvent<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, string>, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, undefined, {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, never, never, never, import("xstate").EventObject>];
                            readonly target: "idle";
                        };
                    };
                };
            };
        }>, {
            type: "buildImageInImageSpace";
            scale: number;
            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
        }, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
            builtImage: BuiltImage;
            sliceIndex: number;
        }, {
            image: MultiscaleSpatialImage;
            builtImage: BuiltImage;
            scale: number;
            slice: number;
            axis: AxisType;
        }>, {
            [k: string]: unknown;
            type: string;
        }, import("xstate").EventObject> | undefined;
    }, "done" | "building" | "findingSliceIndex", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
        readonly id: "imageBuilder";
        readonly context: ({ input }: {
            spawn: {
                <TSrc extends "imageWorker" | "findSliceIndex">(logic: TSrc, ...[options]: ({
                    src: "imageWorker";
                    logic: import("xstate").StateMachine<{
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    }, {
                        type: "buildImageInImageSpace";
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, {
                        [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }>, {
                            [k: string]: unknown;
                            type: string;
                        }, import("xstate").EventObject> | undefined;
                    }, {
                        src: "imageSpaceBuilder";
                        logic: import("xstate").PromiseActorLogic<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    }, never, never, never, "idle" | "buildingImage", string, {
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                        readonly id: "imageWorker";
                        readonly initial: "idle";
                        readonly context: ({ input }: {
                            spawn: {
                                <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                } extends infer T ? T extends {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                } ? T extends {
                                    src: TSrc_1;
                                } ? import("xstate").ConditionalRequired<[options?: ({
                                    id?: T["id"] | undefined;
                                    systemId?: string;
                                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                    syncSnapshot?: boolean;
                                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                }, "src", TSrc_1>["logic"]>;
                                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                    id?: never;
                                    systemId?: string;
                                    input?: import("xstate").InputFrom<TLogic> | undefined;
                                    syncSnapshot?: boolean;
                                } | undefined): ActorRefFrom<TLogic>;
                            };
                            input: {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").AnyEventObject>;
                        }) => {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        };
                        readonly states: {
                            readonly idle: {
                                readonly on: {
                                    readonly buildImageInImageSpace: {
                                        readonly target: "buildingImage";
                                    };
                                };
                            };
                            readonly buildingImage: {
                                readonly invoke: {
                                    readonly input: ({ context, event }: {
                                        context: {
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        };
                                        event: {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        }, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").AnyEventObject>;
                                    }) => {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    };
                                    readonly src: "imageSpaceBuilder";
                                    readonly onDone: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        }, import("xstate").DoneActorEvent<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, string>, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, undefined, {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        }, never, never, never, import("xstate").EventObject>];
                                        readonly target: "idle";
                                    };
                                };
                            };
                        };
                    }>;
                    id: string | undefined;
                } extends infer T ? T extends {
                    src: "imageWorker";
                    logic: import("xstate").StateMachine<{
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    }, {
                        type: "buildImageInImageSpace";
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, {
                        [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }>, {
                            [k: string]: unknown;
                            type: string;
                        }, import("xstate").EventObject> | undefined;
                    }, {
                        src: "imageSpaceBuilder";
                        logic: import("xstate").PromiseActorLogic<{
                            imageType: import("itk-wasm").ImageType;
                            name: string;
                            origin: number[];
                            spacing: number[];
                            direction: Float64Array;
                            size: number[];
                            data: ArrayBuffer;
                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                            metadata: Map<any, any>;
                        }, {
                            image: MultiscaleSpatialImage;
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    }, never, never, never, "idle" | "buildingImage", string, {
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                        readonly id: "imageWorker";
                        readonly initial: "idle";
                        readonly context: ({ input }: {
                            spawn: {
                                <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                } extends infer T ? T extends {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                } ? T extends {
                                    src: TSrc_1;
                                } ? import("xstate").ConditionalRequired<[options?: ({
                                    id?: T["id"] | undefined;
                                    systemId?: string;
                                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                    syncSnapshot?: boolean;
                                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                }, "src", TSrc_1>["logic"]>;
                                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                    id?: never;
                                    systemId?: string;
                                    input?: import("xstate").InputFrom<TLogic> | undefined;
                                    syncSnapshot?: boolean;
                                } | undefined): ActorRefFrom<TLogic>;
                            };
                            input: {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").AnyEventObject>;
                        }) => {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        };
                        readonly states: {
                            readonly idle: {
                                readonly on: {
                                    readonly buildImageInImageSpace: {
                                        readonly target: "buildingImage";
                                    };
                                };
                            };
                            readonly buildingImage: {
                                readonly invoke: {
                                    readonly input: ({ context, event }: {
                                        context: {
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        };
                                        event: {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        }, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").AnyEventObject>;
                                    }) => {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    };
                                    readonly src: "imageSpaceBuilder";
                                    readonly onDone: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        }, import("xstate").DoneActorEvent<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, string>, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, undefined, {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        }, never, never, never, import("xstate").EventObject>];
                                        readonly target: "idle";
                                    };
                                };
                            };
                        };
                    }>;
                    id: string | undefined;
                } ? T extends {
                    src: TSrc;
                } ? import("xstate").ConditionalRequired<[options?: ({
                    id?: T["id"] | undefined;
                    systemId?: string;
                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
                    syncSnapshot?: boolean;
                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never) | ({
                    src: "findSliceIndex";
                    logic: import("xstate").PromiseActorLogic<{
                        builtImage: BuiltImage;
                        sliceIndex: number;
                    }, {
                        image: MultiscaleSpatialImage;
                        builtImage: BuiltImage;
                        scale: number;
                        slice: number;
                        axis: AxisType;
                    }, import("xstate").EventObject>;
                    id: string | undefined;
                } extends infer T_1 ? T_1 extends {
                    src: "findSliceIndex";
                    logic: import("xstate").PromiseActorLogic<{
                        builtImage: BuiltImage;
                        sliceIndex: number;
                    }, {
                        image: MultiscaleSpatialImage;
                        builtImage: BuiltImage;
                        scale: number;
                        slice: number;
                        axis: AxisType;
                    }, import("xstate").EventObject>;
                    id: string | undefined;
                } ? T_1 extends {
                    src: TSrc;
                } ? import("xstate").ConditionalRequired<[options?: ({
                    id?: T_1["id"] | undefined;
                    systemId?: string;
                    input?: import("xstate").InputFrom<T_1["logic"]> | undefined;
                    syncSnapshot?: boolean;
                } & { [K_1 in import("xstate").RequiredActorOptions<T_1>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFrom<import("xstate").GetConcreteByKey<import("xstate").Values<{
                    imageWorker: {
                        src: "imageWorker";
                        logic: import("xstate").StateMachine<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, {
                            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }>, {
                                [k: string]: unknown;
                                type: string;
                            }, import("xstate").EventObject> | undefined;
                        }, {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, never, never, never, "idle" | "buildingImage", string, {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                            readonly id: "imageWorker";
                            readonly initial: "idle";
                            readonly context: ({ input }: {
                                spawn: {
                                    <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } extends infer T ? T extends {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } ? T extends {
                                        src: TSrc_1;
                                    } ? import("xstate").ConditionalRequired<[options?: ({
                                        id?: T["id"] | undefined;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                        syncSnapshot?: boolean;
                                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, "src", TSrc_1>["logic"]>;
                                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                        id?: never;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<TLogic> | undefined;
                                        syncSnapshot?: boolean;
                                    } | undefined): ActorRefFrom<TLogic>;
                                };
                                input: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            readonly states: {
                                readonly idle: {
                                    readonly on: {
                                        readonly buildImageInImageSpace: {
                                            readonly target: "buildingImage";
                                        };
                                    };
                                };
                                readonly buildingImage: {
                                    readonly invoke: {
                                        readonly input: ({ context, event }: {
                                            context: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            event: {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        readonly src: "imageSpaceBuilder";
                                        readonly onDone: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, import("xstate").DoneActorEvent<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, string>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, undefined, {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, never, never, never, import("xstate").EventObject>];
                                            readonly target: "idle";
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    };
                    findSliceIndex: {
                        src: "findSliceIndex";
                        logic: import("xstate").PromiseActorLogic<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    };
                }>, "src", TSrc>["logic"]>;
                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                    id?: never;
                    systemId?: string;
                    input?: import("xstate").InputFrom<TLogic> | undefined;
                    syncSnapshot?: boolean;
                } | undefined): ActorRefFrom<TLogic>;
            };
            input: {
                image: MultiscaleSpatialImage;
                imageActor: Image;
                scale: number;
                slice: number;
                axis: AxisType;
            };
            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                slice: number;
                axis: AxisType;
                scale: number;
                image: MultiscaleSpatialImage;
                imageActor?: Image;
                builtImage?: BuiltImage;
                worker?: import("./image-builder.js").ImageWorker;
            }, import("xstate").AnyEventObject, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
        }) => {
            image: MultiscaleSpatialImage;
            imageActor: Image;
            scale: number;
            slice: number;
            axis: AxisType;
        };
        readonly on: {
            readonly cancel: {
                readonly target: ".done";
            };
        };
        readonly initial: "building";
        readonly states: {
            readonly building: {
                readonly entry: readonly [import("xstate").ActionFunction<{
                    slice: number;
                    axis: AxisType;
                    scale: number;
                    image: MultiscaleSpatialImage;
                    imageActor?: Image;
                    builtImage?: BuiltImage;
                    worker?: import("./image-builder.js").ImageWorker;
                }, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, import("xstate").Values<{
                    imageWorker: {
                        src: "imageWorker";
                        logic: import("xstate").StateMachine<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, {
                            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }>, {
                                [k: string]: unknown;
                                type: string;
                            }, import("xstate").EventObject> | undefined;
                        }, {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, never, never, never, "idle" | "buildingImage", string, {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                            readonly id: "imageWorker";
                            readonly initial: "idle";
                            readonly context: ({ input }: {
                                spawn: {
                                    <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } extends infer T ? T extends {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } ? T extends {
                                        src: TSrc;
                                    } ? import("xstate").ConditionalRequired<[options?: ({
                                        id?: T["id"] | undefined;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                        syncSnapshot?: boolean;
                                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, "src", TSrc>["logic"]>;
                                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                        id?: never;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<TLogic> | undefined;
                                        syncSnapshot?: boolean;
                                    } | undefined): ActorRefFrom<TLogic>;
                                };
                                input: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            readonly states: {
                                readonly idle: {
                                    readonly on: {
                                        readonly buildImageInImageSpace: {
                                            readonly target: "buildingImage";
                                        };
                                    };
                                };
                                readonly buildingImage: {
                                    readonly invoke: {
                                        readonly input: ({ context, event }: {
                                            context: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            event: {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        readonly src: "imageSpaceBuilder";
                                        readonly onDone: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, import("xstate").DoneActorEvent<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, string>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, undefined, {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, never, never, never, import("xstate").EventObject>];
                                            readonly target: "idle";
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    };
                    findSliceIndex: {
                        src: "findSliceIndex";
                        logic: import("xstate").PromiseActorLogic<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    };
                }>, never, never, never, never>, ({ context: { scale, slice, axis, worker } }: import("xstate").ActionArgs<{
                    slice: number;
                    axis: AxisType;
                    scale: number;
                    image: MultiscaleSpatialImage;
                    imageActor?: Image;
                    builtImage?: BuiltImage;
                    worker?: import("./image-builder.js").ImageWorker;
                }, import("xstate").AnyEventObject, import("xstate").AnyEventObject>) => void];
                readonly on: {
                    readonly builtImage: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            slice: number;
                            axis: AxisType;
                            scale: number;
                            image: MultiscaleSpatialImage;
                            imageActor?: Image;
                            builtImage?: BuiltImage;
                            worker?: import("./image-builder.js").ImageWorker;
                        }, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, import("xstate").Values<{
                            imageWorker: {
                                src: "imageWorker";
                                logic: import("xstate").StateMachine<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, {
                                    [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }>, {
                                        [k: string]: unknown;
                                        type: string;
                                    }, import("xstate").EventObject> | undefined;
                                }, {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                }, never, never, never, "idle" | "buildingImage", string, {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                    readonly id: "imageWorker";
                                    readonly initial: "idle";
                                    readonly context: ({ input }: {
                                        spawn: {
                                            <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            } extends infer T ? T extends {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            } ? T extends {
                                                src: TSrc;
                                            } ? import("xstate").ConditionalRequired<[options?: ({
                                                id?: T["id"] | undefined;
                                                systemId?: string;
                                                input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                                syncSnapshot?: boolean;
                                            } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, "src", TSrc>["logic"]>;
                                            <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                                id?: never;
                                                systemId?: string;
                                                input?: import("xstate").InputFrom<TLogic> | undefined;
                                                syncSnapshot?: boolean;
                                            } | undefined): ActorRefFrom<TLogic>;
                                        };
                                        input: {
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        };
                                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        }, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                            type: "buildImageInImageSpace";
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").AnyEventObject>;
                                    }) => {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    readonly states: {
                                        readonly idle: {
                                            readonly on: {
                                                readonly buildImageInImageSpace: {
                                                    readonly target: "buildingImage";
                                                };
                                            };
                                        };
                                        readonly buildingImage: {
                                            readonly invoke: {
                                                readonly input: ({ context, event }: {
                                                    context: {
                                                        image: MultiscaleSpatialImage;
                                                        listeners: AnyActorRef[];
                                                    };
                                                    event: {
                                                        type: "buildImageInImageSpace";
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    };
                                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                        image: MultiscaleSpatialImage;
                                                        listeners: AnyActorRef[];
                                                    }, {
                                                        type: "buildImageInImageSpace";
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                        type: "buildImageInImageSpace";
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").AnyEventObject>;
                                                }) => {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                };
                                                readonly src: "imageSpaceBuilder";
                                                readonly onDone: {
                                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                                        image: MultiscaleSpatialImage;
                                                        listeners: AnyActorRef[];
                                                    }, import("xstate").DoneActorEvent<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, string>, {
                                                        type: "buildImageInImageSpace";
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, undefined, {
                                                        src: "imageSpaceBuilder";
                                                        logic: import("xstate").PromiseActorLogic<{
                                                            imageType: import("itk-wasm").ImageType;
                                                            name: string;
                                                            origin: number[];
                                                            spacing: number[];
                                                            direction: Float64Array;
                                                            size: number[];
                                                            data: ArrayBuffer;
                                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                            metadata: Map<any, any>;
                                                        }, {
                                                            image: MultiscaleSpatialImage;
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, import("xstate").EventObject>;
                                                        id: string | undefined;
                                                    }, never, never, never, import("xstate").EventObject>];
                                                    readonly target: "idle";
                                                };
                                            };
                                        };
                                    };
                                }>;
                                id: string | undefined;
                            };
                            findSliceIndex: {
                                src: "findSliceIndex";
                                logic: import("xstate").PromiseActorLogic<{
                                    builtImage: BuiltImage;
                                    sliceIndex: number;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    builtImage: BuiltImage;
                                    scale: number;
                                    slice: number;
                                    axis: AxisType;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            };
                        }>, never, never, never, never>];
                        readonly target: "findingSliceIndex";
                    };
                };
            };
            readonly findingSliceIndex: {
                readonly invoke: {
                    readonly src: "findSliceIndex";
                    readonly input: ({ context }: {
                        context: {
                            slice: number;
                            axis: AxisType;
                            scale: number;
                            image: MultiscaleSpatialImage;
                            imageActor?: Image;
                            builtImage?: BuiltImage;
                            worker?: import("./image-builder.js").ImageWorker;
                        };
                        event: import("xstate").AnyEventObject;
                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                            slice: number;
                            axis: AxisType;
                            scale: number;
                            image: MultiscaleSpatialImage;
                            imageActor?: Image;
                            builtImage?: BuiltImage;
                            worker?: import("./image-builder.js").ImageWorker;
                        }, import("xstate").AnyEventObject, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
                    }) => {
                        image: MultiscaleSpatialImage;
                        builtImage: BuiltImage;
                        scale: number;
                        slice: number;
                        axis: AxisType;
                    };
                    readonly onDone: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            slice: number;
                            axis: AxisType;
                            scale: number;
                            image: MultiscaleSpatialImage;
                            imageActor?: Image;
                            builtImage?: BuiltImage;
                            worker?: import("./image-builder.js").ImageWorker;
                        }, import("xstate").DoneActorEvent<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, string>, import("xstate").AnyEventObject, undefined, never, never, never, never, never>];
                        readonly target: "done";
                    };
                };
            };
            readonly done: {
                readonly type: "final";
            };
        };
    }>, import("xstate").AnyEventObject, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<"I" | "J" | "K", {
        image: MultiscaleSpatialImage;
        scale: number;
    }>, {
        [k: string]: unknown;
        type: string;
    }, import("xstate").EventObject> | undefined;
}, import("xstate").Values<{
    image: {
        src: "image";
        logic: import("xstate").StateMachine<{
            image: MultiscaleSpatialImage;
            dataRanges: import("@itk-viewer/io/types.js").Ranges;
            colorRanges: import("@itk-viewer/io/types.js").Ranges;
            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
            colorMaps: string[];
            opacityPoints: (readonly [number, number])[][];
            normalizedOpacityPoints: (readonly [number, number])[][];
        }, {
            type: "getWorker";
            receiver: AnyActorRef;
        } | {
            type: "builtImage";
            builtImage: BuiltImage;
        } | {
            type: "colorRange";
            range: readonly [number, number];
            component: number;
        } | {
            type: "normalizedColorRange";
            range: readonly [number, number];
            component: number;
        } | {
            type: "opacityPoints";
            points: (readonly [number, number])[];
            component: number;
        } | {
            type: "normalizedOpacityPoints";
            points: (readonly [number, number])[];
            component: number;
        } | {
            type: "colorMap";
            colorMap: string;
            component: number;
        }, {}, never, import("xstate").Values<{
            updateColorRanges: {
                type: "updateColorRanges";
                params: import("xstate").NonReducibleUnknown;
            };
            updateNormalizedColorRanges: {
                type: "updateNormalizedColorRanges";
                params: import("xstate").NonReducibleUnknown;
            };
            updateOpacityPoints: {
                type: "updateOpacityPoints";
                params: import("xstate").NonReducibleUnknown;
            };
            updateNormalizedOpacityPoints: {
                type: "updateNormalizedOpacityPoints";
                params: import("xstate").NonReducibleUnknown;
            };
            ensureComponentDefaults: {
                type: "ensureComponentDefaults";
                params: import("xstate").NonReducibleUnknown;
            };
        }>, never, never, "active", string, MultiscaleSpatialImage, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
            readonly id: "image";
            readonly initial: "active";
            readonly context: ({ input: image }: {
                spawn: {
                    <TSrc extends never>(logic: TSrc, ...[options]: never): never;
                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                        id?: never;
                        systemId?: string;
                        input?: import("xstate").InputFrom<TLogic> | undefined;
                        syncSnapshot?: boolean;
                    } | undefined): ActorRefFrom<TLogic>;
                };
                input: MultiscaleSpatialImage;
                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                    image: MultiscaleSpatialImage;
                    dataRanges: import("@itk-viewer/io/types.js").Ranges;
                    colorRanges: import("@itk-viewer/io/types.js").Ranges;
                    normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                    colorMaps: string[];
                    opacityPoints: (readonly [number, number])[][];
                    normalizedOpacityPoints: (readonly [number, number])[][];
                }, {
                    type: "getWorker";
                    receiver: AnyActorRef;
                } | {
                    type: "builtImage";
                    builtImage: BuiltImage;
                } | {
                    type: "colorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "normalizedColorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "opacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "normalizedOpacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "colorMap";
                    colorMap: string;
                    component: number;
                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                    type: "getWorker";
                    receiver: AnyActorRef;
                } | {
                    type: "builtImage";
                    builtImage: BuiltImage;
                } | {
                    type: "colorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "normalizedColorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "opacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "normalizedOpacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "colorMap";
                    colorMap: string;
                    component: number;
                }, import("xstate").AnyEventObject>;
            }) => {
                image: MultiscaleSpatialImage;
                dataRanges: never[];
                colorRanges: never[];
                normalizedColorRanges: never[];
                colorMaps: never[];
                opacityPoints: never[];
                normalizedOpacityPoints: never[];
            };
            readonly states: {
                readonly active: {
                    readonly on: {
                        readonly builtImage: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateNormalizedColorRanges", "updateNormalizedOpacityPoints", "ensureComponentDefaults"];
                        };
                        readonly colorRange: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateNormalizedColorRanges"];
                        };
                        readonly normalizedColorRange: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateColorRanges"];
                        };
                        readonly opacityPoints: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateNormalizedOpacityPoints"];
                        };
                        readonly normalizedOpacityPoints: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateOpacityPoints"];
                        };
                        readonly colorMap: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>];
                        };
                    };
                };
            };
        }>;
        id: string | undefined;
    };
    imageBuilder: {
        src: "imageBuilder";
        logic: import("xstate").StateMachine<{
            slice: number;
            axis: AxisType;
            scale: number;
            image: MultiscaleSpatialImage;
            imageActor?: Image;
            builtImage?: BuiltImage;
            worker?: import("./image-builder.js").ImageWorker;
        }, import("xstate").AnyEventObject, {
            [x: string]: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                image: MultiscaleSpatialImage;
                listeners: AnyActorRef[];
            }, {
                type: "buildImageInImageSpace";
                scale: number;
                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
            }, {
                [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                    imageType: import("itk-wasm").ImageType;
                    name: string;
                    origin: number[];
                    spacing: number[];
                    direction: Float64Array;
                    size: number[];
                    data: ArrayBuffer;
                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                    metadata: Map<any, any>;
                }, {
                    image: MultiscaleSpatialImage;
                    scale: number;
                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                }>, {
                    [k: string]: unknown;
                    type: string;
                }, import("xstate").EventObject> | undefined;
            }, "idle" | "buildingImage", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
                readonly id: "imageWorker";
                readonly initial: "idle";
                readonly context: ({ input }: {
                    spawn: {
                        <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        } extends infer T ? T extends {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        } ? T extends {
                            src: TSrc;
                        } ? import("xstate").ConditionalRequired<[options?: ({
                            id?: T["id"] | undefined;
                            systemId?: string;
                            input?: import("xstate").InputFrom<T["logic"]> | undefined;
                            syncSnapshot?: boolean;
                        } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, "src", TSrc>["logic"]>;
                        <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                            id?: never;
                            systemId?: string;
                            input?: import("xstate").InputFrom<TLogic> | undefined;
                            syncSnapshot?: boolean;
                        } | undefined): ActorRefFrom<TLogic>;
                    };
                    input: {
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    };
                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    }, {
                        type: "buildImageInImageSpace";
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                        type: "buildImageInImageSpace";
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, import("xstate").AnyEventObject>;
                }) => {
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                };
                readonly states: {
                    readonly idle: {
                        readonly on: {
                            readonly buildImageInImageSpace: {
                                readonly target: "buildingImage";
                            };
                        };
                    };
                    readonly buildingImage: {
                        readonly invoke: {
                            readonly input: ({ context, event }: {
                                context: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                event: {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            };
                            readonly src: "imageSpaceBuilder";
                            readonly onDone: {
                                readonly actions: readonly [import("xstate").ActionFunction<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, import("xstate").DoneActorEvent<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, string>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, undefined, {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                }, never, never, never, import("xstate").EventObject>];
                                readonly target: "idle";
                            };
                        };
                    };
                };
            }>, {
                type: "buildImageInImageSpace";
                scale: number;
                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
            }, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                builtImage: BuiltImage;
                sliceIndex: number;
            }, {
                image: MultiscaleSpatialImage;
                builtImage: BuiltImage;
                scale: number;
                slice: number;
                axis: AxisType;
            }>, {
                [k: string]: unknown;
                type: string;
            }, import("xstate").EventObject> | undefined;
        }, import("xstate").Values<{
            imageWorker: {
                src: "imageWorker";
                logic: import("xstate").StateMachine<{
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                }, {
                    type: "buildImageInImageSpace";
                    scale: number;
                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                }, {
                    [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                        imageType: import("itk-wasm").ImageType;
                        name: string;
                        origin: number[];
                        spacing: number[];
                        direction: Float64Array;
                        size: number[];
                        data: ArrayBuffer;
                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                        metadata: Map<any, any>;
                    }, {
                        image: MultiscaleSpatialImage;
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }>, {
                        [k: string]: unknown;
                        type: string;
                    }, import("xstate").EventObject> | undefined;
                }, {
                    src: "imageSpaceBuilder";
                    logic: import("xstate").PromiseActorLogic<{
                        imageType: import("itk-wasm").ImageType;
                        name: string;
                        origin: number[];
                        spacing: number[];
                        direction: Float64Array;
                        size: number[];
                        data: ArrayBuffer;
                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                        metadata: Map<any, any>;
                    }, {
                        image: MultiscaleSpatialImage;
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, import("xstate").EventObject>;
                    id: string | undefined;
                }, never, never, never, "idle" | "buildingImage", string, {
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                    readonly id: "imageWorker";
                    readonly initial: "idle";
                    readonly context: ({ input }: {
                        spawn: {
                            <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            } extends infer T ? T extends {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            } ? T extends {
                                src: TSrc;
                            } ? import("xstate").ConditionalRequired<[options?: ({
                                id?: T["id"] | undefined;
                                systemId?: string;
                                input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                syncSnapshot?: boolean;
                            } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, "src", TSrc>["logic"]>;
                            <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                id?: never;
                                systemId?: string;
                                input?: import("xstate").InputFrom<TLogic> | undefined;
                                syncSnapshot?: boolean;
                            } | undefined): ActorRefFrom<TLogic>;
                        };
                        input: {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        };
                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").AnyEventObject>;
                    }) => {
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    };
                    readonly states: {
                        readonly idle: {
                            readonly on: {
                                readonly buildImageInImageSpace: {
                                    readonly target: "buildingImage";
                                };
                            };
                        };
                        readonly buildingImage: {
                            readonly invoke: {
                                readonly input: ({ context, event }: {
                                    context: {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    event: {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    };
                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").AnyEventObject>;
                                }) => {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                };
                                readonly src: "imageSpaceBuilder";
                                readonly onDone: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, import("xstate").DoneActorEvent<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, string>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, undefined, {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, never, never, never, import("xstate").EventObject>];
                                    readonly target: "idle";
                                };
                            };
                        };
                    };
                }>;
                id: string | undefined;
            };
            findSliceIndex: {
                src: "findSliceIndex";
                logic: import("xstate").PromiseActorLogic<{
                    builtImage: BuiltImage;
                    sliceIndex: number;
                }, {
                    image: MultiscaleSpatialImage;
                    builtImage: BuiltImage;
                    scale: number;
                    slice: number;
                    axis: AxisType;
                }, import("xstate").EventObject>;
                id: string | undefined;
            };
        }>, never, never, never, "done" | "building" | "findingSliceIndex", string, {
            image: MultiscaleSpatialImage;
            imageActor: Image;
            scale: number;
            slice: number;
            axis: AxisType;
        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
            readonly id: "imageBuilder";
            readonly context: ({ input }: {
                spawn: {
                    <TSrc extends "imageWorker" | "findSliceIndex">(logic: TSrc, ...[options]: ({
                        src: "imageWorker";
                        logic: import("xstate").StateMachine<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, {
                            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }>, {
                                [k: string]: unknown;
                                type: string;
                            }, import("xstate").EventObject> | undefined;
                        }, {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, never, never, never, "idle" | "buildingImage", string, {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                            readonly id: "imageWorker";
                            readonly initial: "idle";
                            readonly context: ({ input }: {
                                spawn: {
                                    <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } extends infer T ? T extends {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } ? T extends {
                                        src: TSrc_1;
                                    } ? import("xstate").ConditionalRequired<[options?: ({
                                        id?: T["id"] | undefined;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                        syncSnapshot?: boolean;
                                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, "src", TSrc_1>["logic"]>;
                                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                        id?: never;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<TLogic> | undefined;
                                        syncSnapshot?: boolean;
                                    } | undefined): ActorRefFrom<TLogic>;
                                };
                                input: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            readonly states: {
                                readonly idle: {
                                    readonly on: {
                                        readonly buildImageInImageSpace: {
                                            readonly target: "buildingImage";
                                        };
                                    };
                                };
                                readonly buildingImage: {
                                    readonly invoke: {
                                        readonly input: ({ context, event }: {
                                            context: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            event: {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        readonly src: "imageSpaceBuilder";
                                        readonly onDone: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, import("xstate").DoneActorEvent<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, string>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, undefined, {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, never, never, never, import("xstate").EventObject>];
                                            readonly target: "idle";
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    } extends infer T ? T extends {
                        src: "imageWorker";
                        logic: import("xstate").StateMachine<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, {
                            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }>, {
                                [k: string]: unknown;
                                type: string;
                            }, import("xstate").EventObject> | undefined;
                        }, {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, never, never, never, "idle" | "buildingImage", string, {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                            readonly id: "imageWorker";
                            readonly initial: "idle";
                            readonly context: ({ input }: {
                                spawn: {
                                    <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } extends infer T ? T extends {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } ? T extends {
                                        src: TSrc_1;
                                    } ? import("xstate").ConditionalRequired<[options?: ({
                                        id?: T["id"] | undefined;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                        syncSnapshot?: boolean;
                                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, "src", TSrc_1>["logic"]>;
                                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                        id?: never;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<TLogic> | undefined;
                                        syncSnapshot?: boolean;
                                    } | undefined): ActorRefFrom<TLogic>;
                                };
                                input: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            readonly states: {
                                readonly idle: {
                                    readonly on: {
                                        readonly buildImageInImageSpace: {
                                            readonly target: "buildingImage";
                                        };
                                    };
                                };
                                readonly buildingImage: {
                                    readonly invoke: {
                                        readonly input: ({ context, event }: {
                                            context: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            event: {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        readonly src: "imageSpaceBuilder";
                                        readonly onDone: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, import("xstate").DoneActorEvent<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, string>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, undefined, {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, never, never, never, import("xstate").EventObject>];
                                            readonly target: "idle";
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    } ? T extends {
                        src: TSrc;
                    } ? import("xstate").ConditionalRequired<[options?: ({
                        id?: T["id"] | undefined;
                        systemId?: string;
                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                        syncSnapshot?: boolean;
                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never) | ({
                        src: "findSliceIndex";
                        logic: import("xstate").PromiseActorLogic<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    } extends infer T_1 ? T_1 extends {
                        src: "findSliceIndex";
                        logic: import("xstate").PromiseActorLogic<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    } ? T_1 extends {
                        src: TSrc;
                    } ? import("xstate").ConditionalRequired<[options?: ({
                        id?: T_1["id"] | undefined;
                        systemId?: string;
                        input?: import("xstate").InputFrom<T_1["logic"]> | undefined;
                        syncSnapshot?: boolean;
                    } & { [K_1 in import("xstate").RequiredActorOptions<T_1>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFrom<import("xstate").GetConcreteByKey<import("xstate").Values<{
                        imageWorker: {
                            src: "imageWorker";
                            logic: import("xstate").StateMachine<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, {
                                [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }>, {
                                    [k: string]: unknown;
                                    type: string;
                                }, import("xstate").EventObject> | undefined;
                            }, {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, never, never, never, "idle" | "buildingImage", string, {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "imageWorker";
                                readonly initial: "idle";
                                readonly context: ({ input }: {
                                    spawn: {
                                        <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } extends infer T ? T extends {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } ? T extends {
                                            src: TSrc_1;
                                        } ? import("xstate").ConditionalRequired<[options?: ({
                                            id?: T["id"] | undefined;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                            syncSnapshot?: boolean;
                                        } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        }, "src", TSrc_1>["logic"]>;
                                        <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                            id?: never;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<TLogic> | undefined;
                                            syncSnapshot?: boolean;
                                        } | undefined): ActorRefFrom<TLogic>;
                                    };
                                    input: {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").AnyEventObject>;
                                }) => {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                readonly states: {
                                    readonly idle: {
                                        readonly on: {
                                            readonly buildImageInImageSpace: {
                                                readonly target: "buildingImage";
                                            };
                                        };
                                    };
                                    readonly buildingImage: {
                                        readonly invoke: {
                                            readonly input: ({ context, event }: {
                                                context: {
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                };
                                                event: {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                };
                                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").AnyEventObject>;
                                            }) => {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            readonly src: "imageSpaceBuilder";
                                            readonly onDone: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, import("xstate").DoneActorEvent<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, string>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, undefined, {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                }, never, never, never, import("xstate").EventObject>];
                                                readonly target: "idle";
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        };
                        findSliceIndex: {
                            src: "findSliceIndex";
                            logic: import("xstate").PromiseActorLogic<{
                                builtImage: BuiltImage;
                                sliceIndex: number;
                            }, {
                                image: MultiscaleSpatialImage;
                                builtImage: BuiltImage;
                                scale: number;
                                slice: number;
                                axis: AxisType;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        };
                    }>, "src", TSrc>["logic"]>;
                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                        id?: never;
                        systemId?: string;
                        input?: import("xstate").InputFrom<TLogic> | undefined;
                        syncSnapshot?: boolean;
                    } | undefined): ActorRefFrom<TLogic>;
                };
                input: {
                    image: MultiscaleSpatialImage;
                    imageActor: Image;
                    scale: number;
                    slice: number;
                    axis: AxisType;
                };
                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                    slice: number;
                    axis: AxisType;
                    scale: number;
                    image: MultiscaleSpatialImage;
                    imageActor?: Image;
                    builtImage?: BuiltImage;
                    worker?: import("./image-builder.js").ImageWorker;
                }, import("xstate").AnyEventObject, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
            }) => {
                image: MultiscaleSpatialImage;
                imageActor: Image;
                scale: number;
                slice: number;
                axis: AxisType;
            };
            readonly on: {
                readonly cancel: {
                    readonly target: ".done";
                };
            };
            readonly initial: "building";
            readonly states: {
                readonly building: {
                    readonly entry: readonly [import("xstate").ActionFunction<{
                        slice: number;
                        axis: AxisType;
                        scale: number;
                        image: MultiscaleSpatialImage;
                        imageActor?: Image;
                        builtImage?: BuiltImage;
                        worker?: import("./image-builder.js").ImageWorker;
                    }, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, import("xstate").Values<{
                        imageWorker: {
                            src: "imageWorker";
                            logic: import("xstate").StateMachine<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, {
                                [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }>, {
                                    [k: string]: unknown;
                                    type: string;
                                }, import("xstate").EventObject> | undefined;
                            }, {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, never, never, never, "idle" | "buildingImage", string, {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "imageWorker";
                                readonly initial: "idle";
                                readonly context: ({ input }: {
                                    spawn: {
                                        <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } extends infer T ? T extends {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } ? T extends {
                                            src: TSrc;
                                        } ? import("xstate").ConditionalRequired<[options?: ({
                                            id?: T["id"] | undefined;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                            syncSnapshot?: boolean;
                                        } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        }, "src", TSrc>["logic"]>;
                                        <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                            id?: never;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<TLogic> | undefined;
                                            syncSnapshot?: boolean;
                                        } | undefined): ActorRefFrom<TLogic>;
                                    };
                                    input: {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").AnyEventObject>;
                                }) => {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                readonly states: {
                                    readonly idle: {
                                        readonly on: {
                                            readonly buildImageInImageSpace: {
                                                readonly target: "buildingImage";
                                            };
                                        };
                                    };
                                    readonly buildingImage: {
                                        readonly invoke: {
                                            readonly input: ({ context, event }: {
                                                context: {
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                };
                                                event: {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                };
                                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").AnyEventObject>;
                                            }) => {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            readonly src: "imageSpaceBuilder";
                                            readonly onDone: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, import("xstate").DoneActorEvent<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, string>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, undefined, {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                }, never, never, never, import("xstate").EventObject>];
                                                readonly target: "idle";
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        };
                        findSliceIndex: {
                            src: "findSliceIndex";
                            logic: import("xstate").PromiseActorLogic<{
                                builtImage: BuiltImage;
                                sliceIndex: number;
                            }, {
                                image: MultiscaleSpatialImage;
                                builtImage: BuiltImage;
                                scale: number;
                                slice: number;
                                axis: AxisType;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        };
                    }>, never, never, never, never>, ({ context: { scale, slice, axis, worker } }: import("xstate").ActionArgs<{
                        slice: number;
                        axis: AxisType;
                        scale: number;
                        image: MultiscaleSpatialImage;
                        imageActor?: Image;
                        builtImage?: BuiltImage;
                        worker?: import("./image-builder.js").ImageWorker;
                    }, import("xstate").AnyEventObject, import("xstate").AnyEventObject>) => void];
                    readonly on: {
                        readonly builtImage: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            }, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, import("xstate").Values<{
                                imageWorker: {
                                    src: "imageWorker";
                                    logic: import("xstate").StateMachine<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, {
                                        [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }>, {
                                            [k: string]: unknown;
                                            type: string;
                                        }, import("xstate").EventObject> | undefined;
                                    }, {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, never, never, never, "idle" | "buildingImage", string, {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                        readonly id: "imageWorker";
                                        readonly initial: "idle";
                                        readonly context: ({ input }: {
                                            spawn: {
                                                <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                } extends infer T ? T extends {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                } ? T extends {
                                                    src: TSrc;
                                                } ? import("xstate").ConditionalRequired<[options?: ({
                                                    id?: T["id"] | undefined;
                                                    systemId?: string;
                                                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                                    syncSnapshot?: boolean;
                                                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                }, "src", TSrc>["logic"]>;
                                                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                                    id?: never;
                                                    systemId?: string;
                                                    input?: import("xstate").InputFrom<TLogic> | undefined;
                                                    syncSnapshot?: boolean;
                                                } | undefined): ActorRefFrom<TLogic>;
                                            };
                                            input: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        };
                                        readonly states: {
                                            readonly idle: {
                                                readonly on: {
                                                    readonly buildImageInImageSpace: {
                                                        readonly target: "buildingImage";
                                                    };
                                                };
                                            };
                                            readonly buildingImage: {
                                                readonly invoke: {
                                                    readonly input: ({ context, event }: {
                                                        context: {
                                                            image: MultiscaleSpatialImage;
                                                            listeners: AnyActorRef[];
                                                        };
                                                        event: {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        };
                                                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                            image: MultiscaleSpatialImage;
                                                            listeners: AnyActorRef[];
                                                        }, {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, import("xstate").AnyEventObject>;
                                                    }) => {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    };
                                                    readonly src: "imageSpaceBuilder";
                                                    readonly onDone: {
                                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                                            image: MultiscaleSpatialImage;
                                                            listeners: AnyActorRef[];
                                                        }, import("xstate").DoneActorEvent<{
                                                            imageType: import("itk-wasm").ImageType;
                                                            name: string;
                                                            origin: number[];
                                                            spacing: number[];
                                                            direction: Float64Array;
                                                            size: number[];
                                                            data: ArrayBuffer;
                                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                            metadata: Map<any, any>;
                                                        }, string>, {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, undefined, {
                                                            src: "imageSpaceBuilder";
                                                            logic: import("xstate").PromiseActorLogic<{
                                                                imageType: import("itk-wasm").ImageType;
                                                                name: string;
                                                                origin: number[];
                                                                spacing: number[];
                                                                direction: Float64Array;
                                                                size: number[];
                                                                data: ArrayBuffer;
                                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                                metadata: Map<any, any>;
                                                            }, {
                                                                image: MultiscaleSpatialImage;
                                                                scale: number;
                                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                            }, import("xstate").EventObject>;
                                                            id: string | undefined;
                                                        }, never, never, never, import("xstate").EventObject>];
                                                        readonly target: "idle";
                                                    };
                                                };
                                            };
                                        };
                                    }>;
                                    id: string | undefined;
                                };
                                findSliceIndex: {
                                    src: "findSliceIndex";
                                    logic: import("xstate").PromiseActorLogic<{
                                        builtImage: BuiltImage;
                                        sliceIndex: number;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        builtImage: BuiltImage;
                                        scale: number;
                                        slice: number;
                                        axis: AxisType;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                };
                            }>, never, never, never, never>];
                            readonly target: "findingSliceIndex";
                        };
                    };
                };
                readonly findingSliceIndex: {
                    readonly invoke: {
                        readonly src: "findSliceIndex";
                        readonly input: ({ context }: {
                            context: {
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            };
                            event: import("xstate").AnyEventObject;
                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            }, import("xstate").AnyEventObject, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
                        }) => {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        };
                        readonly onDone: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            }, import("xstate").DoneActorEvent<{
                                builtImage: BuiltImage;
                                sliceIndex: number;
                            }, string>, import("xstate").AnyEventObject, undefined, never, never, never, never, never>];
                            readonly target: "done";
                        };
                    };
                };
                readonly done: {
                    readonly type: "final";
                };
            };
        }>;
        id: string | undefined;
    };
    findDefaultAxis: {
        src: "findDefaultAxis";
        logic: import("xstate").PromiseActorLogic<"I" | "J" | "K", {
            image: MultiscaleSpatialImage;
            scale: number;
        }, import("xstate").EventObject>;
        id: string | undefined;
    };
}>, import("xstate").Values<{
    forwardToSpawned: {
        type: "forwardToSpawned";
        params: unknown;
    };
    resetCameraPose: {
        type: "resetCameraPose";
        params: unknown;
    };
}>, never, never, {}, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, import("xstate").MachineConfig<{
    slice: number;
    axis: AxisType;
    scale: number;
    image?: MultiscaleSpatialImage;
    spawned: AnyActorRef[];
    viewport?: ViewportActor;
    camera?: Camera;
    imageActor?: Image;
    imageBuilders: Array<ImageBuilder>;
}, CreateChild | {
    type: "setImage";
    image: MultiscaleSpatialImage;
} | {
    type: "setSlice";
    slice: number;
} | {
    type: "setAxis";
    axis: AxisType;
} | {
    type: "setScale";
    scale: number;
} | {
    type: "setViewport";
    viewport: ViewportActor;
} | {
    type: "setResolution";
    resolution: [number, number];
} | {
    type: "setCamera";
    camera: Camera;
} | {
    type: "imageBuilt";
    builtImage: BuiltImage;
    sliceIndex: number;
    actor: ImageBuilder;
}, import("xstate").Values<{
    image: {
        src: "image";
        logic: import("xstate").StateMachine<{
            image: MultiscaleSpatialImage;
            dataRanges: import("@itk-viewer/io/types.js").Ranges;
            colorRanges: import("@itk-viewer/io/types.js").Ranges;
            normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
            colorMaps: string[];
            opacityPoints: (readonly [number, number])[][];
            normalizedOpacityPoints: (readonly [number, number])[][];
        }, {
            type: "getWorker";
            receiver: AnyActorRef;
        } | {
            type: "builtImage";
            builtImage: BuiltImage;
        } | {
            type: "colorRange";
            range: readonly [number, number];
            component: number;
        } | {
            type: "normalizedColorRange";
            range: readonly [number, number];
            component: number;
        } | {
            type: "opacityPoints";
            points: (readonly [number, number])[];
            component: number;
        } | {
            type: "normalizedOpacityPoints";
            points: (readonly [number, number])[];
            component: number;
        } | {
            type: "colorMap";
            colorMap: string;
            component: number;
        }, {}, never, import("xstate").Values<{
            updateColorRanges: {
                type: "updateColorRanges";
                params: import("xstate").NonReducibleUnknown;
            };
            updateNormalizedColorRanges: {
                type: "updateNormalizedColorRanges";
                params: import("xstate").NonReducibleUnknown;
            };
            updateOpacityPoints: {
                type: "updateOpacityPoints";
                params: import("xstate").NonReducibleUnknown;
            };
            updateNormalizedOpacityPoints: {
                type: "updateNormalizedOpacityPoints";
                params: import("xstate").NonReducibleUnknown;
            };
            ensureComponentDefaults: {
                type: "ensureComponentDefaults";
                params: import("xstate").NonReducibleUnknown;
            };
        }>, never, never, "active", string, MultiscaleSpatialImage, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
            readonly id: "image";
            readonly initial: "active";
            readonly context: ({ input: image }: {
                spawn: {
                    <TSrc extends never>(logic: TSrc, ...[options]: never): never;
                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                        id?: never;
                        systemId?: string;
                        input?: import("xstate").InputFrom<TLogic> | undefined;
                        syncSnapshot?: boolean;
                    } | undefined): ActorRefFrom<TLogic>;
                };
                input: MultiscaleSpatialImage;
                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                    image: MultiscaleSpatialImage;
                    dataRanges: import("@itk-viewer/io/types.js").Ranges;
                    colorRanges: import("@itk-viewer/io/types.js").Ranges;
                    normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                    colorMaps: string[];
                    opacityPoints: (readonly [number, number])[][];
                    normalizedOpacityPoints: (readonly [number, number])[][];
                }, {
                    type: "getWorker";
                    receiver: AnyActorRef;
                } | {
                    type: "builtImage";
                    builtImage: BuiltImage;
                } | {
                    type: "colorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "normalizedColorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "opacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "normalizedOpacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "colorMap";
                    colorMap: string;
                    component: number;
                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                    type: "getWorker";
                    receiver: AnyActorRef;
                } | {
                    type: "builtImage";
                    builtImage: BuiltImage;
                } | {
                    type: "colorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "normalizedColorRange";
                    range: readonly [number, number];
                    component: number;
                } | {
                    type: "opacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "normalizedOpacityPoints";
                    points: (readonly [number, number])[];
                    component: number;
                } | {
                    type: "colorMap";
                    colorMap: string;
                    component: number;
                }, import("xstate").AnyEventObject>;
            }) => {
                image: MultiscaleSpatialImage;
                dataRanges: never[];
                colorRanges: never[];
                normalizedColorRanges: never[];
                colorMaps: never[];
                opacityPoints: never[];
                normalizedOpacityPoints: never[];
            };
            readonly states: {
                readonly active: {
                    readonly on: {
                        readonly builtImage: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateNormalizedColorRanges", "updateNormalizedOpacityPoints", "ensureComponentDefaults"];
                        };
                        readonly colorRange: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateNormalizedColorRanges"];
                        };
                        readonly normalizedColorRange: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateColorRanges"];
                        };
                        readonly opacityPoints: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateNormalizedOpacityPoints"];
                        };
                        readonly normalizedOpacityPoints: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>, "updateOpacityPoints"];
                        };
                        readonly colorMap: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                image: MultiscaleSpatialImage;
                                dataRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorRanges: import("@itk-viewer/io/types.js").Ranges;
                                normalizedColorRanges: import("@itk-viewer/io/types.js").Ranges;
                                colorMaps: string[];
                                opacityPoints: (readonly [number, number])[][];
                                normalizedOpacityPoints: (readonly [number, number])[][];
                            }, {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, {
                                type: "getWorker";
                                receiver: AnyActorRef;
                            } | {
                                type: "builtImage";
                                builtImage: BuiltImage;
                            } | {
                                type: "colorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "normalizedColorRange";
                                range: readonly [number, number];
                                component: number;
                            } | {
                                type: "opacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "normalizedOpacityPoints";
                                points: (readonly [number, number])[];
                                component: number;
                            } | {
                                type: "colorMap";
                                colorMap: string;
                                component: number;
                            }, undefined, never, never, never, never, never>];
                        };
                    };
                };
            };
        }>;
        id: string | undefined;
    };
    imageBuilder: {
        src: "imageBuilder";
        logic: import("xstate").StateMachine<{
            slice: number;
            axis: AxisType;
            scale: number;
            image: MultiscaleSpatialImage;
            imageActor?: Image;
            builtImage?: BuiltImage;
            worker?: import("./image-builder.js").ImageWorker;
        }, import("xstate").AnyEventObject, {
            [x: string]: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                image: MultiscaleSpatialImage;
                listeners: AnyActorRef[];
            }, {
                type: "buildImageInImageSpace";
                scale: number;
                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
            }, {
                [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                    imageType: import("itk-wasm").ImageType;
                    name: string;
                    origin: number[];
                    spacing: number[];
                    direction: Float64Array;
                    size: number[];
                    data: ArrayBuffer;
                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                    metadata: Map<any, any>;
                }, {
                    image: MultiscaleSpatialImage;
                    scale: number;
                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                }>, {
                    [k: string]: unknown;
                    type: string;
                }, import("xstate").EventObject> | undefined;
            }, "idle" | "buildingImage", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
                readonly id: "imageWorker";
                readonly initial: "idle";
                readonly context: ({ input }: {
                    spawn: {
                        <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        } extends infer T ? T extends {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        } ? T extends {
                            src: TSrc;
                        } ? import("xstate").ConditionalRequired<[options?: ({
                            id?: T["id"] | undefined;
                            systemId?: string;
                            input?: import("xstate").InputFrom<T["logic"]> | undefined;
                            syncSnapshot?: boolean;
                        } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, "src", TSrc>["logic"]>;
                        <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                            id?: never;
                            systemId?: string;
                            input?: import("xstate").InputFrom<TLogic> | undefined;
                            syncSnapshot?: boolean;
                        } | undefined): ActorRefFrom<TLogic>;
                    };
                    input: {
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    };
                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    }, {
                        type: "buildImageInImageSpace";
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                        type: "buildImageInImageSpace";
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, import("xstate").AnyEventObject>;
                }) => {
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                };
                readonly states: {
                    readonly idle: {
                        readonly on: {
                            readonly buildImageInImageSpace: {
                                readonly target: "buildingImage";
                            };
                        };
                    };
                    readonly buildingImage: {
                        readonly invoke: {
                            readonly input: ({ context, event }: {
                                context: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                event: {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            };
                            readonly src: "imageSpaceBuilder";
                            readonly onDone: {
                                readonly actions: readonly [import("xstate").ActionFunction<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, import("xstate").DoneActorEvent<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, string>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, undefined, {
                                    src: "imageSpaceBuilder";
                                    logic: import("xstate").PromiseActorLogic<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                }, never, never, never, import("xstate").EventObject>];
                                readonly target: "idle";
                            };
                        };
                    };
                };
            }>, {
                type: "buildImageInImageSpace";
                scale: number;
                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
            }, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                builtImage: BuiltImage;
                sliceIndex: number;
            }, {
                image: MultiscaleSpatialImage;
                builtImage: BuiltImage;
                scale: number;
                slice: number;
                axis: AxisType;
            }>, {
                [k: string]: unknown;
                type: string;
            }, import("xstate").EventObject> | undefined;
        }, import("xstate").Values<{
            imageWorker: {
                src: "imageWorker";
                logic: import("xstate").StateMachine<{
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                }, {
                    type: "buildImageInImageSpace";
                    scale: number;
                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                }, {
                    [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                        imageType: import("itk-wasm").ImageType;
                        name: string;
                        origin: number[];
                        spacing: number[];
                        direction: Float64Array;
                        size: number[];
                        data: ArrayBuffer;
                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                        metadata: Map<any, any>;
                    }, {
                        image: MultiscaleSpatialImage;
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }>, {
                        [k: string]: unknown;
                        type: string;
                    }, import("xstate").EventObject> | undefined;
                }, {
                    src: "imageSpaceBuilder";
                    logic: import("xstate").PromiseActorLogic<{
                        imageType: import("itk-wasm").ImageType;
                        name: string;
                        origin: number[];
                        spacing: number[];
                        direction: Float64Array;
                        size: number[];
                        data: ArrayBuffer;
                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                        metadata: Map<any, any>;
                    }, {
                        image: MultiscaleSpatialImage;
                        scale: number;
                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                    }, import("xstate").EventObject>;
                    id: string | undefined;
                }, never, never, never, "idle" | "buildingImage", string, {
                    image: MultiscaleSpatialImage;
                    listeners: AnyActorRef[];
                }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                    readonly id: "imageWorker";
                    readonly initial: "idle";
                    readonly context: ({ input }: {
                        spawn: {
                            <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            } extends infer T ? T extends {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            } ? T extends {
                                src: TSrc;
                            } ? import("xstate").ConditionalRequired<[options?: ({
                                id?: T["id"] | undefined;
                                systemId?: string;
                                input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                syncSnapshot?: boolean;
                            } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, "src", TSrc>["logic"]>;
                            <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                id?: never;
                                systemId?: string;
                                input?: import("xstate").InputFrom<TLogic> | undefined;
                                syncSnapshot?: boolean;
                            } | undefined): ActorRefFrom<TLogic>;
                        };
                        input: {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        };
                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, import("xstate").AnyEventObject>;
                    }) => {
                        image: MultiscaleSpatialImage;
                        listeners: AnyActorRef[];
                    };
                    readonly states: {
                        readonly idle: {
                            readonly on: {
                                readonly buildImageInImageSpace: {
                                    readonly target: "buildingImage";
                                };
                            };
                        };
                        readonly buildingImage: {
                            readonly invoke: {
                                readonly input: ({ context, event }: {
                                    context: {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    event: {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    };
                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").AnyEventObject>;
                                }) => {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                };
                                readonly src: "imageSpaceBuilder";
                                readonly onDone: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, import("xstate").DoneActorEvent<{
                                        imageType: import("itk-wasm").ImageType;
                                        name: string;
                                        origin: number[];
                                        spacing: number[];
                                        direction: Float64Array;
                                        size: number[];
                                        data: ArrayBuffer;
                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                        metadata: Map<any, any>;
                                    }, string>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, undefined, {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, never, never, never, import("xstate").EventObject>];
                                    readonly target: "idle";
                                };
                            };
                        };
                    };
                }>;
                id: string | undefined;
            };
            findSliceIndex: {
                src: "findSliceIndex";
                logic: import("xstate").PromiseActorLogic<{
                    builtImage: BuiltImage;
                    sliceIndex: number;
                }, {
                    image: MultiscaleSpatialImage;
                    builtImage: BuiltImage;
                    scale: number;
                    slice: number;
                    axis: AxisType;
                }, import("xstate").EventObject>;
                id: string | undefined;
            };
        }>, never, never, never, "done" | "building" | "findingSliceIndex", string, {
            image: MultiscaleSpatialImage;
            imageActor: Image;
            scale: number;
            slice: number;
            axis: AxisType;
        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
            readonly id: "imageBuilder";
            readonly context: ({ input }: {
                spawn: {
                    <TSrc extends "imageWorker" | "findSliceIndex">(logic: TSrc, ...[options]: ({
                        src: "imageWorker";
                        logic: import("xstate").StateMachine<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, {
                            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }>, {
                                [k: string]: unknown;
                                type: string;
                            }, import("xstate").EventObject> | undefined;
                        }, {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, never, never, never, "idle" | "buildingImage", string, {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                            readonly id: "imageWorker";
                            readonly initial: "idle";
                            readonly context: ({ input }: {
                                spawn: {
                                    <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } extends infer T ? T extends {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } ? T extends {
                                        src: TSrc_1;
                                    } ? import("xstate").ConditionalRequired<[options?: ({
                                        id?: T["id"] | undefined;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                        syncSnapshot?: boolean;
                                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, "src", TSrc_1>["logic"]>;
                                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                        id?: never;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<TLogic> | undefined;
                                        syncSnapshot?: boolean;
                                    } | undefined): ActorRefFrom<TLogic>;
                                };
                                input: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            readonly states: {
                                readonly idle: {
                                    readonly on: {
                                        readonly buildImageInImageSpace: {
                                            readonly target: "buildingImage";
                                        };
                                    };
                                };
                                readonly buildingImage: {
                                    readonly invoke: {
                                        readonly input: ({ context, event }: {
                                            context: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            event: {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        readonly src: "imageSpaceBuilder";
                                        readonly onDone: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, import("xstate").DoneActorEvent<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, string>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, undefined, {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, never, never, never, import("xstate").EventObject>];
                                            readonly target: "idle";
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    } extends infer T ? T extends {
                        src: "imageWorker";
                        logic: import("xstate").StateMachine<{
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, {
                            type: "buildImageInImageSpace";
                            scale: number;
                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                        }, {
                            [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }>, {
                                [k: string]: unknown;
                                type: string;
                            }, import("xstate").EventObject> | undefined;
                        }, {
                            src: "imageSpaceBuilder";
                            logic: import("xstate").PromiseActorLogic<{
                                imageType: import("itk-wasm").ImageType;
                                name: string;
                                origin: number[];
                                spacing: number[];
                                direction: Float64Array;
                                size: number[];
                                data: ArrayBuffer;
                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                metadata: Map<any, any>;
                            }, {
                                image: MultiscaleSpatialImage;
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        }, never, never, never, "idle" | "buildingImage", string, {
                            image: MultiscaleSpatialImage;
                            listeners: AnyActorRef[];
                        }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                            readonly id: "imageWorker";
                            readonly initial: "idle";
                            readonly context: ({ input }: {
                                spawn: {
                                    <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } extends infer T ? T extends {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    } ? T extends {
                                        src: TSrc_1;
                                    } ? import("xstate").ConditionalRequired<[options?: ({
                                        id?: T["id"] | undefined;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                        syncSnapshot?: boolean;
                                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, "src", TSrc_1>["logic"]>;
                                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                        id?: never;
                                        systemId?: string;
                                        input?: import("xstate").InputFrom<TLogic> | undefined;
                                        syncSnapshot?: boolean;
                                    } | undefined): ActorRefFrom<TLogic>;
                                };
                                input: {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                }, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                    type: "buildImageInImageSpace";
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").AnyEventObject>;
                            }) => {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            };
                            readonly states: {
                                readonly idle: {
                                    readonly on: {
                                        readonly buildImageInImageSpace: {
                                            readonly target: "buildingImage";
                                        };
                                    };
                                };
                                readonly buildingImage: {
                                    readonly invoke: {
                                        readonly input: ({ context, event }: {
                                            context: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            event: {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        };
                                        readonly src: "imageSpaceBuilder";
                                        readonly onDone: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, import("xstate").DoneActorEvent<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, string>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, undefined, {
                                                src: "imageSpaceBuilder";
                                                logic: import("xstate").PromiseActorLogic<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, {
                                                    image: MultiscaleSpatialImage;
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").EventObject>;
                                                id: string | undefined;
                                            }, never, never, never, import("xstate").EventObject>];
                                            readonly target: "idle";
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    } ? T extends {
                        src: TSrc;
                    } ? import("xstate").ConditionalRequired<[options?: ({
                        id?: T["id"] | undefined;
                        systemId?: string;
                        input?: import("xstate").InputFrom<T["logic"]> | undefined;
                        syncSnapshot?: boolean;
                    } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never) | ({
                        src: "findSliceIndex";
                        logic: import("xstate").PromiseActorLogic<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    } extends infer T_1 ? T_1 extends {
                        src: "findSliceIndex";
                        logic: import("xstate").PromiseActorLogic<{
                            builtImage: BuiltImage;
                            sliceIndex: number;
                        }, {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        }, import("xstate").EventObject>;
                        id: string | undefined;
                    } ? T_1 extends {
                        src: TSrc;
                    } ? import("xstate").ConditionalRequired<[options?: ({
                        id?: T_1["id"] | undefined;
                        systemId?: string;
                        input?: import("xstate").InputFrom<T_1["logic"]> | undefined;
                        syncSnapshot?: boolean;
                    } & { [K_1 in import("xstate").RequiredActorOptions<T_1>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFrom<import("xstate").GetConcreteByKey<import("xstate").Values<{
                        imageWorker: {
                            src: "imageWorker";
                            logic: import("xstate").StateMachine<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, {
                                [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }>, {
                                    [k: string]: unknown;
                                    type: string;
                                }, import("xstate").EventObject> | undefined;
                            }, {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, never, never, never, "idle" | "buildingImage", string, {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "imageWorker";
                                readonly initial: "idle";
                                readonly context: ({ input }: {
                                    spawn: {
                                        <TSrc_1 extends "imageSpaceBuilder">(logic: TSrc_1, ...[options]: {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } extends infer T ? T extends {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } ? T extends {
                                            src: TSrc_1;
                                        } ? import("xstate").ConditionalRequired<[options?: ({
                                            id?: T["id"] | undefined;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                            syncSnapshot?: boolean;
                                        } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        }, "src", TSrc_1>["logic"]>;
                                        <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                            id?: never;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<TLogic> | undefined;
                                            syncSnapshot?: boolean;
                                        } | undefined): ActorRefFrom<TLogic>;
                                    };
                                    input: {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").AnyEventObject>;
                                }) => {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                readonly states: {
                                    readonly idle: {
                                        readonly on: {
                                            readonly buildImageInImageSpace: {
                                                readonly target: "buildingImage";
                                            };
                                        };
                                    };
                                    readonly buildingImage: {
                                        readonly invoke: {
                                            readonly input: ({ context, event }: {
                                                context: {
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                };
                                                event: {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                };
                                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").AnyEventObject>;
                                            }) => {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            readonly src: "imageSpaceBuilder";
                                            readonly onDone: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, import("xstate").DoneActorEvent<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, string>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, undefined, {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                }, never, never, never, import("xstate").EventObject>];
                                                readonly target: "idle";
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        };
                        findSliceIndex: {
                            src: "findSliceIndex";
                            logic: import("xstate").PromiseActorLogic<{
                                builtImage: BuiltImage;
                                sliceIndex: number;
                            }, {
                                image: MultiscaleSpatialImage;
                                builtImage: BuiltImage;
                                scale: number;
                                slice: number;
                                axis: AxisType;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        };
                    }>, "src", TSrc>["logic"]>;
                    <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                        id?: never;
                        systemId?: string;
                        input?: import("xstate").InputFrom<TLogic> | undefined;
                        syncSnapshot?: boolean;
                    } | undefined): ActorRefFrom<TLogic>;
                };
                input: {
                    image: MultiscaleSpatialImage;
                    imageActor: Image;
                    scale: number;
                    slice: number;
                    axis: AxisType;
                };
                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                    slice: number;
                    axis: AxisType;
                    scale: number;
                    image: MultiscaleSpatialImage;
                    imageActor?: Image;
                    builtImage?: BuiltImage;
                    worker?: import("./image-builder.js").ImageWorker;
                }, import("xstate").AnyEventObject, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
            }) => {
                image: MultiscaleSpatialImage;
                imageActor: Image;
                scale: number;
                slice: number;
                axis: AxisType;
            };
            readonly on: {
                readonly cancel: {
                    readonly target: ".done";
                };
            };
            readonly initial: "building";
            readonly states: {
                readonly building: {
                    readonly entry: readonly [import("xstate").ActionFunction<{
                        slice: number;
                        axis: AxisType;
                        scale: number;
                        image: MultiscaleSpatialImage;
                        imageActor?: Image;
                        builtImage?: BuiltImage;
                        worker?: import("./image-builder.js").ImageWorker;
                    }, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, import("xstate").Values<{
                        imageWorker: {
                            src: "imageWorker";
                            logic: import("xstate").StateMachine<{
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, {
                                type: "buildImageInImageSpace";
                                scale: number;
                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                            }, {
                                [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }>, {
                                    [k: string]: unknown;
                                    type: string;
                                }, import("xstate").EventObject> | undefined;
                            }, {
                                src: "imageSpaceBuilder";
                                logic: import("xstate").PromiseActorLogic<{
                                    imageType: import("itk-wasm").ImageType;
                                    name: string;
                                    origin: number[];
                                    spacing: number[];
                                    direction: Float64Array;
                                    size: number[];
                                    data: ArrayBuffer;
                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                    metadata: Map<any, any>;
                                }, {
                                    image: MultiscaleSpatialImage;
                                    scale: number;
                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                }, import("xstate").EventObject>;
                                id: string | undefined;
                            }, never, never, never, "idle" | "buildingImage", string, {
                                image: MultiscaleSpatialImage;
                                listeners: AnyActorRef[];
                            }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "imageWorker";
                                readonly initial: "idle";
                                readonly context: ({ input }: {
                                    spawn: {
                                        <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } extends infer T ? T extends {
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        } ? T extends {
                                            src: TSrc;
                                        } ? import("xstate").ConditionalRequired<[options?: ({
                                            id?: T["id"] | undefined;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                            syncSnapshot?: boolean;
                                        } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                            src: "imageSpaceBuilder";
                                            logic: import("xstate").PromiseActorLogic<{
                                                imageType: import("itk-wasm").ImageType;
                                                name: string;
                                                origin: number[];
                                                spacing: number[];
                                                direction: Float64Array;
                                                size: number[];
                                                data: ArrayBuffer;
                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                metadata: Map<any, any>;
                                            }, {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").EventObject>;
                                            id: string | undefined;
                                        }, "src", TSrc>["logic"]>;
                                        <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                            id?: never;
                                            systemId?: string;
                                            input?: import("xstate").InputFrom<TLogic> | undefined;
                                            syncSnapshot?: boolean;
                                        } | undefined): ActorRefFrom<TLogic>;
                                    };
                                    input: {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    };
                                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, import("xstate").AnyEventObject>;
                                }) => {
                                    image: MultiscaleSpatialImage;
                                    listeners: AnyActorRef[];
                                };
                                readonly states: {
                                    readonly idle: {
                                        readonly on: {
                                            readonly buildImageInImageSpace: {
                                                readonly target: "buildingImage";
                                            };
                                        };
                                    };
                                    readonly buildingImage: {
                                        readonly invoke: {
                                            readonly input: ({ context, event }: {
                                                context: {
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                };
                                                event: {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                };
                                                self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, import("xstate").AnyEventObject>;
                                            }) => {
                                                image: MultiscaleSpatialImage;
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            };
                                            readonly src: "imageSpaceBuilder";
                                            readonly onDone: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    image: MultiscaleSpatialImage;
                                                    listeners: AnyActorRef[];
                                                }, import("xstate").DoneActorEvent<{
                                                    imageType: import("itk-wasm").ImageType;
                                                    name: string;
                                                    origin: number[];
                                                    spacing: number[];
                                                    direction: Float64Array;
                                                    size: number[];
                                                    data: ArrayBuffer;
                                                    ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                    metadata: Map<any, any>;
                                                }, string>, {
                                                    type: "buildImageInImageSpace";
                                                    scale: number;
                                                    normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                }, undefined, {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                }, never, never, never, import("xstate").EventObject>];
                                                readonly target: "idle";
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        };
                        findSliceIndex: {
                            src: "findSliceIndex";
                            logic: import("xstate").PromiseActorLogic<{
                                builtImage: BuiltImage;
                                sliceIndex: number;
                            }, {
                                image: MultiscaleSpatialImage;
                                builtImage: BuiltImage;
                                scale: number;
                                slice: number;
                                axis: AxisType;
                            }, import("xstate").EventObject>;
                            id: string | undefined;
                        };
                    }>, never, never, never, never>, ({ context: { scale, slice, axis, worker } }: import("xstate").ActionArgs<{
                        slice: number;
                        axis: AxisType;
                        scale: number;
                        image: MultiscaleSpatialImage;
                        imageActor?: Image;
                        builtImage?: BuiltImage;
                        worker?: import("./image-builder.js").ImageWorker;
                    }, import("xstate").AnyEventObject, import("xstate").AnyEventObject>) => void];
                    readonly on: {
                        readonly builtImage: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            }, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, import("xstate").Values<{
                                imageWorker: {
                                    src: "imageWorker";
                                    logic: import("xstate").StateMachine<{
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, {
                                        type: "buildImageInImageSpace";
                                        scale: number;
                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                    }, {
                                        [x: string]: import("xstate").ActorRef<import("xstate").PromiseSnapshot<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }>, {
                                            [k: string]: unknown;
                                            type: string;
                                        }, import("xstate").EventObject> | undefined;
                                    }, {
                                        src: "imageSpaceBuilder";
                                        logic: import("xstate").PromiseActorLogic<{
                                            imageType: import("itk-wasm").ImageType;
                                            name: string;
                                            origin: number[];
                                            spacing: number[];
                                            direction: Float64Array;
                                            size: number[];
                                            data: ArrayBuffer;
                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                            metadata: Map<any, any>;
                                        }, {
                                            image: MultiscaleSpatialImage;
                                            scale: number;
                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                        }, import("xstate").EventObject>;
                                        id: string | undefined;
                                    }, never, never, never, "idle" | "buildingImage", string, {
                                        image: MultiscaleSpatialImage;
                                        listeners: AnyActorRef[];
                                    }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                        readonly id: "imageWorker";
                                        readonly initial: "idle";
                                        readonly context: ({ input }: {
                                            spawn: {
                                                <TSrc extends "imageSpaceBuilder">(logic: TSrc, ...[options]: {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                } extends infer T ? T extends {
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                } ? T extends {
                                                    src: TSrc;
                                                } ? import("xstate").ConditionalRequired<[options?: ({
                                                    id?: T["id"] | undefined;
                                                    systemId?: string;
                                                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
                                                    syncSnapshot?: boolean;
                                                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): ActorRefFrom<import("xstate").GetConcreteByKey<{
                                                    src: "imageSpaceBuilder";
                                                    logic: import("xstate").PromiseActorLogic<{
                                                        imageType: import("itk-wasm").ImageType;
                                                        name: string;
                                                        origin: number[];
                                                        spacing: number[];
                                                        direction: Float64Array;
                                                        size: number[];
                                                        data: ArrayBuffer;
                                                        ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                        metadata: Map<any, any>;
                                                    }, {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    }, import("xstate").EventObject>;
                                                    id: string | undefined;
                                                }, "src", TSrc>["logic"]>;
                                                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
                                                    id?: never;
                                                    systemId?: string;
                                                    input?: import("xstate").InputFrom<TLogic> | undefined;
                                                    syncSnapshot?: boolean;
                                                } | undefined): ActorRefFrom<TLogic>;
                                            };
                                            input: {
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            };
                                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                image: MultiscaleSpatialImage;
                                                listeners: AnyActorRef[];
                                            }, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
                                                type: "buildImageInImageSpace";
                                                scale: number;
                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                            }, import("xstate").AnyEventObject>;
                                        }) => {
                                            image: MultiscaleSpatialImage;
                                            listeners: AnyActorRef[];
                                        };
                                        readonly states: {
                                            readonly idle: {
                                                readonly on: {
                                                    readonly buildImageInImageSpace: {
                                                        readonly target: "buildingImage";
                                                    };
                                                };
                                            };
                                            readonly buildingImage: {
                                                readonly invoke: {
                                                    readonly input: ({ context, event }: {
                                                        context: {
                                                            image: MultiscaleSpatialImage;
                                                            listeners: AnyActorRef[];
                                                        };
                                                        event: {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        };
                                                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                                            image: MultiscaleSpatialImage;
                                                            listeners: AnyActorRef[];
                                                        }, {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, import("xstate").AnyEventObject>;
                                                    }) => {
                                                        image: MultiscaleSpatialImage;
                                                        scale: number;
                                                        normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                    };
                                                    readonly src: "imageSpaceBuilder";
                                                    readonly onDone: {
                                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                                            image: MultiscaleSpatialImage;
                                                            listeners: AnyActorRef[];
                                                        }, import("xstate").DoneActorEvent<{
                                                            imageType: import("itk-wasm").ImageType;
                                                            name: string;
                                                            origin: number[];
                                                            spacing: number[];
                                                            direction: Float64Array;
                                                            size: number[];
                                                            data: ArrayBuffer;
                                                            ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                            metadata: Map<any, any>;
                                                        }, string>, {
                                                            type: "buildImageInImageSpace";
                                                            scale: number;
                                                            normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                        }, undefined, {
                                                            src: "imageSpaceBuilder";
                                                            logic: import("xstate").PromiseActorLogic<{
                                                                imageType: import("itk-wasm").ImageType;
                                                                name: string;
                                                                origin: number[];
                                                                spacing: number[];
                                                                direction: Float64Array;
                                                                size: number[];
                                                                data: ArrayBuffer;
                                                                ranges: import("@itk-viewer/io/types.js").Ranges | number[][] | undefined;
                                                                metadata: Map<any, any>;
                                                            }, {
                                                                image: MultiscaleSpatialImage;
                                                                scale: number;
                                                                normalizedImageBounds: import("@itk-viewer/utils/bounding-box.js").Bounds;
                                                            }, import("xstate").EventObject>;
                                                            id: string | undefined;
                                                        }, never, never, never, import("xstate").EventObject>];
                                                        readonly target: "idle";
                                                    };
                                                };
                                            };
                                        };
                                    }>;
                                    id: string | undefined;
                                };
                                findSliceIndex: {
                                    src: "findSliceIndex";
                                    logic: import("xstate").PromiseActorLogic<{
                                        builtImage: BuiltImage;
                                        sliceIndex: number;
                                    }, {
                                        image: MultiscaleSpatialImage;
                                        builtImage: BuiltImage;
                                        scale: number;
                                        slice: number;
                                        axis: AxisType;
                                    }, import("xstate").EventObject>;
                                    id: string | undefined;
                                };
                            }>, never, never, never, never>];
                            readonly target: "findingSliceIndex";
                        };
                    };
                };
                readonly findingSliceIndex: {
                    readonly invoke: {
                        readonly src: "findSliceIndex";
                        readonly input: ({ context }: {
                            context: {
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            };
                            event: import("xstate").AnyEventObject;
                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            }, import("xstate").AnyEventObject, Record<string, AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
                        }) => {
                            image: MultiscaleSpatialImage;
                            builtImage: BuiltImage;
                            scale: number;
                            slice: number;
                            axis: AxisType;
                        };
                        readonly onDone: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                slice: number;
                                axis: AxisType;
                                scale: number;
                                image: MultiscaleSpatialImage;
                                imageActor?: Image;
                                builtImage?: BuiltImage;
                                worker?: import("./image-builder.js").ImageWorker;
                            }, import("xstate").DoneActorEvent<{
                                builtImage: BuiltImage;
                                sliceIndex: number;
                            }, string>, import("xstate").AnyEventObject, undefined, never, never, never, never, never>];
                            readonly target: "done";
                        };
                    };
                };
                readonly done: {
                    readonly type: "final";
                };
            };
        }>;
        id: string | undefined;
    };
    findDefaultAxis: {
        src: "findDefaultAxis";
        logic: import("xstate").PromiseActorLogic<"I" | "J" | "K", {
            image: MultiscaleSpatialImage;
            scale: number;
        }, import("xstate").EventObject>;
        id: string | undefined;
    };
}>, import("xstate").Values<{
    forwardToSpawned: {
        type: "forwardToSpawned";
        params: unknown;
    };
    resetCameraPose: {
        type: "resetCameraPose";
        params: unknown;
    };
}>, never, never, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject>>;
export type View2dActor = ActorRefFrom<typeof view2d>;
//# sourceMappingURL=view-2d.d.ts.map