import { LitElement } from 'lit';
import { ViewportActor } from '@itk-viewer/viewer/viewport.js';
export declare class ItkViewport extends LitElement {
    actor: ViewportActor | undefined;
    dispatched: boolean;
    getActor(): import("xstate").ActorRef<import("xstate").MachineSnapshot<{
        image?: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
        camera: import("@itk-viewer/viewer/camera.js").Camera;
        resolution: [number, number];
        views: import("xstate").AnyActorRef[];
    }, import("@itk-viewer/viewer/children.js").CreateChild | {
        type: "setImage";
        image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
    } | {
        type: "setCamera";
        camera: import("@itk-viewer/viewer/camera.js").Camera;
    } | {
        type: "cameraPoseUpdated";
        pose: import("gl-matrix").ReadonlyMat4;
    } | {
        type: "setResolution";
        resolution: [number, number];
    }, {
        [x: string]: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
            pose: import("@itk-viewer/viewer/camera.js").Pose;
            enableRotation: boolean;
            verticalFieldOfView: number;
            parallelScaleRatio: number;
            poseWatchers: Array<import("xstate").AnyActorRef>;
        }, {
            type: "setPose";
            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                parallelScale?: number;
            };
        } | {
            type: "watchPose";
            watcher: import("xstate").AnyActorRef;
        } | {
            type: "watchPoseStop";
            watcher: import("xstate").AnyActorRef;
        } | {
            type: "setEnableRotation";
            enable: boolean;
        }, {}, "active", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
            readonly id: "camera";
            readonly initial: "active";
            readonly context: () => {
                pose: {
                    center: import("gl-matrix").vec3;
                    rotation: import("gl-matrix").quat;
                    distance: number;
                };
                enableRotation: true;
                parallelScaleRatio: number;
                verticalFieldOfView: number;
                poseWatchers: never[];
            };
            readonly states: {
                readonly active: {
                    readonly on: {
                        readonly setPose: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>, {
                                readonly type: "emitNewPose";
                                readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                    context: {
                                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<import("xstate").AnyActorRef>;
                                    };
                                    event: {
                                        type: "setPose";
                                        pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    };
                                }) => {
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    parallelScaleRatio: number;
                                };
                            }];
                        };
                        readonly watchPose: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }>) => void];
                        };
                        readonly watchPoseStop: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>];
                        };
                        readonly setEnableRotation: {
                            readonly actions: import("xstate").ActionFunction<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>;
                        };
                    };
                };
            };
        }>, {
            type: "setPose";
            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                parallelScale?: number;
            };
        } | {
            type: "watchPose";
            watcher: import("xstate").AnyActorRef;
        } | {
            type: "watchPoseStop";
            watcher: import("xstate").AnyActorRef;
        } | {
            type: "setEnableRotation";
            enable: boolean;
        }, import("xstate").EventObject> | undefined;
    }, "active", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
        readonly id: "viewport";
        readonly context: ({ spawn }: {
            spawn: {
                <TSrc extends "camera">(logic: TSrc, ...[options]: {
                    src: "camera";
                    logic: import("xstate").StateMachine<{
                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                        enableRotation: boolean;
                        verticalFieldOfView: number;
                        parallelScaleRatio: number;
                        poseWatchers: Array<import("xstate").AnyActorRef>;
                    }, {
                        type: "setPose";
                        pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                            parallelScale?: number;
                        };
                    } | {
                        type: "watchPose";
                        watcher: import("xstate").AnyActorRef;
                    } | {
                        type: "watchPoseStop";
                        watcher: import("xstate").AnyActorRef;
                    } | {
                        type: "setEnableRotation";
                        enable: boolean;
                    }, {}, never, {
                        type: "emitNewPose";
                        params: {
                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                            parallelScaleRatio: number;
                        };
                    }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                        readonly id: "camera";
                        readonly initial: "active";
                        readonly context: () => {
                            pose: {
                                center: import("gl-matrix").vec3;
                                rotation: import("gl-matrix").quat;
                                distance: number;
                            };
                            enableRotation: true;
                            parallelScaleRatio: number;
                            verticalFieldOfView: number;
                            poseWatchers: never[];
                        };
                        readonly states: {
                            readonly active: {
                                readonly on: {
                                    readonly setPose: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>, {
                                            readonly type: "emitNewPose";
                                            readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                context: {
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                };
                                                event: {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                };
                                            }) => {
                                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                parallelScaleRatio: number;
                                            };
                                        }];
                                    };
                                    readonly watchPose: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }>) => void];
                                    };
                                    readonly watchPoseStop: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>];
                                    };
                                    readonly setEnableRotation: {
                                        readonly actions: import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>;
                                    };
                                };
                            };
                        };
                    }>;
                    id: string | undefined;
                } extends infer T ? T extends {
                    src: "camera";
                    logic: import("xstate").StateMachine<{
                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                        enableRotation: boolean;
                        verticalFieldOfView: number;
                        parallelScaleRatio: number;
                        poseWatchers: Array<import("xstate").AnyActorRef>;
                    }, {
                        type: "setPose";
                        pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                            parallelScale?: number;
                        };
                    } | {
                        type: "watchPose";
                        watcher: import("xstate").AnyActorRef;
                    } | {
                        type: "watchPoseStop";
                        watcher: import("xstate").AnyActorRef;
                    } | {
                        type: "setEnableRotation";
                        enable: boolean;
                    }, {}, never, {
                        type: "emitNewPose";
                        params: {
                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                            parallelScaleRatio: number;
                        };
                    }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                        readonly id: "camera";
                        readonly initial: "active";
                        readonly context: () => {
                            pose: {
                                center: import("gl-matrix").vec3;
                                rotation: import("gl-matrix").quat;
                                distance: number;
                            };
                            enableRotation: true;
                            parallelScaleRatio: number;
                            verticalFieldOfView: number;
                            poseWatchers: never[];
                        };
                        readonly states: {
                            readonly active: {
                                readonly on: {
                                    readonly setPose: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>, {
                                            readonly type: "emitNewPose";
                                            readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                context: {
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                };
                                                event: {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                };
                                            }) => {
                                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                parallelScaleRatio: number;
                                            };
                                        }];
                                    };
                                    readonly watchPose: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }>) => void];
                                    };
                                    readonly watchPoseStop: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>];
                                    };
                                    readonly setEnableRotation: {
                                        readonly actions: import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>;
                                    };
                                };
                            };
                        };
                    }>;
                    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): import("xstate").ActorRefFrom<import("xstate").GetConcreteByKey<{
                    src: "camera";
                    logic: import("xstate").StateMachine<{
                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                        enableRotation: boolean;
                        verticalFieldOfView: number;
                        parallelScaleRatio: number;
                        poseWatchers: Array<import("xstate").AnyActorRef>;
                    }, {
                        type: "setPose";
                        pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                            parallelScale?: number;
                        };
                    } | {
                        type: "watchPose";
                        watcher: import("xstate").AnyActorRef;
                    } | {
                        type: "watchPoseStop";
                        watcher: import("xstate").AnyActorRef;
                    } | {
                        type: "setEnableRotation";
                        enable: boolean;
                    }, {}, never, {
                        type: "emitNewPose";
                        params: {
                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                            parallelScaleRatio: number;
                        };
                    }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                        readonly id: "camera";
                        readonly initial: "active";
                        readonly context: () => {
                            pose: {
                                center: import("gl-matrix").vec3;
                                rotation: import("gl-matrix").quat;
                                distance: number;
                            };
                            enableRotation: true;
                            parallelScaleRatio: number;
                            verticalFieldOfView: number;
                            poseWatchers: never[];
                        };
                        readonly states: {
                            readonly active: {
                                readonly on: {
                                    readonly setPose: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>, {
                                            readonly type: "emitNewPose";
                                            readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                context: {
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                };
                                                event: {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                };
                                            }) => {
                                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                parallelScaleRatio: number;
                                            };
                                        }];
                                    };
                                    readonly watchPose: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }>) => void];
                                    };
                                    readonly watchPoseStop: {
                                        readonly actions: readonly [import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>];
                                    };
                                    readonly setEnableRotation: {
                                        readonly actions: import("xstate").ActionFunction<{
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        }, {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        } | {
                                            type: "watchPose";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "watchPoseStop";
                                            watcher: import("xstate").AnyActorRef;
                                        } | {
                                            type: "setEnableRotation";
                                            enable: boolean;
                                        }, undefined, never, never, never, never, never>;
                                    };
                                };
                            };
                        };
                    }>;
                    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): import("xstate").ActorRefFrom<TLogic>;
            };
            input: import("xstate").NonReducibleUnknown;
            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                image?: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                camera: import("@itk-viewer/viewer/camera.js").Camera;
                resolution: [number, number];
                views: import("xstate").AnyActorRef[];
            }, import("@itk-viewer/viewer/children.js").CreateChild | {
                type: "setImage";
                image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
            } | {
                type: "setCamera";
                camera: import("@itk-viewer/viewer/camera.js").Camera;
            } | {
                type: "cameraPoseUpdated";
                pose: import("gl-matrix").ReadonlyMat4;
            } | {
                type: "setResolution";
                resolution: [number, number];
            }, Record<string, import("xstate").AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, import("@itk-viewer/viewer/children.js").CreateChild | {
                type: "setImage";
                image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
            } | {
                type: "setCamera";
                camera: import("@itk-viewer/viewer/camera.js").Camera;
            } | {
                type: "cameraPoseUpdated";
                pose: import("gl-matrix").ReadonlyMat4;
            } | {
                type: "setResolution";
                resolution: [number, number];
            }, import("xstate").AnyEventObject>;
        }) => {
            resolution: [number, number];
            views: never[];
            camera: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
                pose: import("@itk-viewer/viewer/camera.js").Pose;
                enableRotation: boolean;
                verticalFieldOfView: number;
                parallelScaleRatio: number;
                poseWatchers: Array<import("xstate").AnyActorRef>;
            }, {
                type: "setPose";
                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                    parallelScale?: number;
                };
            } | {
                type: "watchPose";
                watcher: import("xstate").AnyActorRef;
            } | {
                type: "watchPoseStop";
                watcher: import("xstate").AnyActorRef;
            } | {
                type: "setEnableRotation";
                enable: boolean;
            }, {}, "active", string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
                readonly id: "camera";
                readonly initial: "active";
                readonly context: () => {
                    pose: {
                        center: import("gl-matrix").vec3;
                        rotation: import("gl-matrix").quat;
                        distance: number;
                    };
                    enableRotation: true;
                    parallelScaleRatio: number;
                    verticalFieldOfView: number;
                    poseWatchers: never[];
                };
                readonly states: {
                    readonly active: {
                        readonly on: {
                            readonly setPose: {
                                readonly actions: readonly [import("xstate").ActionFunction<{
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                }, {
                                    type: "setPose";
                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                }, {
                                    type: "setPose";
                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                } | {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "watchPoseStop";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "setEnableRotation";
                                    enable: boolean;
                                }, undefined, never, never, never, never, never>, {
                                    readonly type: "emitNewPose";
                                    readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                        context: {
                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                            enableRotation: boolean;
                                            verticalFieldOfView: number;
                                            parallelScaleRatio: number;
                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                        };
                                        event: {
                                            type: "setPose";
                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                parallelScale?: number;
                                            };
                                        };
                                    }) => {
                                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                                        parallelScaleRatio: number;
                                    };
                                }];
                            };
                            readonly watchPose: {
                                readonly actions: readonly [import("xstate").ActionFunction<{
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                }, {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                }, {
                                    type: "setPose";
                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                } | {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "watchPoseStop";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "setEnableRotation";
                                    enable: boolean;
                                }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                }, {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                }, {
                                    type: "setPose";
                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                } | {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "watchPoseStop";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "setEnableRotation";
                                    enable: boolean;
                                }>) => void];
                            };
                            readonly watchPoseStop: {
                                readonly actions: readonly [import("xstate").ActionFunction<{
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                }, {
                                    type: "watchPoseStop";
                                    watcher: import("xstate").AnyActorRef;
                                }, {
                                    type: "setPose";
                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                } | {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "watchPoseStop";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "setEnableRotation";
                                    enable: boolean;
                                }, undefined, never, never, never, never, never>];
                            };
                            readonly setEnableRotation: {
                                readonly actions: import("xstate").ActionFunction<{
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                }, {
                                    type: "setEnableRotation";
                                    enable: boolean;
                                }, {
                                    type: "setPose";
                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                } | {
                                    type: "watchPose";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "watchPoseStop";
                                    watcher: import("xstate").AnyActorRef;
                                } | {
                                    type: "setEnableRotation";
                                    enable: boolean;
                                }, undefined, never, never, never, never, never>;
                            };
                        };
                    };
                };
            }>, {
                type: "setPose";
                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                    parallelScale?: number;
                };
            } | {
                type: "watchPose";
                watcher: import("xstate").AnyActorRef;
            } | {
                type: "watchPoseStop";
                watcher: import("xstate").AnyActorRef;
            } | {
                type: "setEnableRotation";
                enable: boolean;
            }, import("xstate").EventObject>;
        };
        readonly initial: "active";
        readonly states: {
            readonly active: {
                readonly on: {
                    readonly createChild: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image?: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                            resolution: [number, number];
                            views: import("xstate").AnyActorRef[];
                        }, import("@itk-viewer/viewer/children.js").CreateChild, import("@itk-viewer/viewer/children.js").CreateChild | {
                            type: "setImage";
                            image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                        } | {
                            type: "setCamera";
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                        } | {
                            type: "cameraPoseUpdated";
                            pose: import("gl-matrix").ReadonlyMat4;
                        } | {
                            type: "setResolution";
                            resolution: [number, number];
                        }, undefined, {
                            src: "camera";
                            logic: import("xstate").StateMachine<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, {}, never, {
                                type: "emitNewPose";
                                params: {
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    parallelScaleRatio: number;
                                };
                            }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "camera";
                                readonly initial: "active";
                                readonly context: () => {
                                    pose: {
                                        center: import("gl-matrix").vec3;
                                        rotation: import("gl-matrix").quat;
                                        distance: number;
                                    };
                                    enableRotation: true;
                                    parallelScaleRatio: number;
                                    verticalFieldOfView: number;
                                    poseWatchers: never[];
                                };
                                readonly states: {
                                    readonly active: {
                                        readonly on: {
                                            readonly setPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, {
                                                    readonly type: "emitNewPose";
                                                    readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                        context: {
                                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                            enableRotation: boolean;
                                                            verticalFieldOfView: number;
                                                            parallelScaleRatio: number;
                                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                                        };
                                                        event: {
                                                            type: "setPose";
                                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                                parallelScale?: number;
                                                            };
                                                        };
                                                    }) => {
                                                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                        parallelScaleRatio: number;
                                                    };
                                                }];
                                            };
                                            readonly watchPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }>) => void];
                                            };
                                            readonly watchPoseStop: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>];
                                            };
                                            readonly setEnableRotation: {
                                                readonly actions: import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>;
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        }, never, never, never, never>];
                    };
                    readonly setImage: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image?: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                            resolution: [number, number];
                            views: import("xstate").AnyActorRef[];
                        }, {
                            type: "setImage";
                            image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                        }, import("@itk-viewer/viewer/children.js").CreateChild | {
                            type: "setImage";
                            image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                        } | {
                            type: "setCamera";
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                        } | {
                            type: "cameraPoseUpdated";
                            pose: import("gl-matrix").ReadonlyMat4;
                        } | {
                            type: "setResolution";
                            resolution: [number, number];
                        }, undefined, {
                            src: "camera";
                            logic: import("xstate").StateMachine<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, {}, never, {
                                type: "emitNewPose";
                                params: {
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    parallelScaleRatio: number;
                                };
                            }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "camera";
                                readonly initial: "active";
                                readonly context: () => {
                                    pose: {
                                        center: import("gl-matrix").vec3;
                                        rotation: import("gl-matrix").quat;
                                        distance: number;
                                    };
                                    enableRotation: true;
                                    parallelScaleRatio: number;
                                    verticalFieldOfView: number;
                                    poseWatchers: never[];
                                };
                                readonly states: {
                                    readonly active: {
                                        readonly on: {
                                            readonly setPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, {
                                                    readonly type: "emitNewPose";
                                                    readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                        context: {
                                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                            enableRotation: boolean;
                                                            verticalFieldOfView: number;
                                                            parallelScaleRatio: number;
                                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                                        };
                                                        event: {
                                                            type: "setPose";
                                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                                parallelScale?: number;
                                                            };
                                                        };
                                                    }) => {
                                                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                        parallelScaleRatio: number;
                                                    };
                                                }];
                                            };
                                            readonly watchPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }>) => void];
                                            };
                                            readonly watchPoseStop: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>];
                                            };
                                            readonly setEnableRotation: {
                                                readonly actions: import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>;
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        }, never, never, never, never>, "forwardToViews"];
                    };
                    readonly setCamera: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image?: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                            resolution: [number, number];
                            views: import("xstate").AnyActorRef[];
                        }, {
                            type: "setCamera";
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                        }, import("@itk-viewer/viewer/children.js").CreateChild | {
                            type: "setImage";
                            image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                        } | {
                            type: "setCamera";
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                        } | {
                            type: "cameraPoseUpdated";
                            pose: import("gl-matrix").ReadonlyMat4;
                        } | {
                            type: "setResolution";
                            resolution: [number, number];
                        }, undefined, {
                            src: "camera";
                            logic: import("xstate").StateMachine<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, {}, never, {
                                type: "emitNewPose";
                                params: {
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    parallelScaleRatio: number;
                                };
                            }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "camera";
                                readonly initial: "active";
                                readonly context: () => {
                                    pose: {
                                        center: import("gl-matrix").vec3;
                                        rotation: import("gl-matrix").quat;
                                        distance: number;
                                    };
                                    enableRotation: true;
                                    parallelScaleRatio: number;
                                    verticalFieldOfView: number;
                                    poseWatchers: never[];
                                };
                                readonly states: {
                                    readonly active: {
                                        readonly on: {
                                            readonly setPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, {
                                                    readonly type: "emitNewPose";
                                                    readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                        context: {
                                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                            enableRotation: boolean;
                                                            verticalFieldOfView: number;
                                                            parallelScaleRatio: number;
                                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                                        };
                                                        event: {
                                                            type: "setPose";
                                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                                parallelScale?: number;
                                                            };
                                                        };
                                                    }) => {
                                                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                        parallelScaleRatio: number;
                                                    };
                                                }];
                                            };
                                            readonly watchPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }>) => void];
                                            };
                                            readonly watchPoseStop: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>];
                                            };
                                            readonly setEnableRotation: {
                                                readonly actions: import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>;
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        }, never, never, never, never>, "forwardToViews"];
                    };
                    readonly setResolution: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            image?: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                            resolution: [number, number];
                            views: import("xstate").AnyActorRef[];
                        }, {
                            type: "setResolution";
                            resolution: [number, number];
                        }, import("@itk-viewer/viewer/children.js").CreateChild | {
                            type: "setImage";
                            image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
                        } | {
                            type: "setCamera";
                            camera: import("@itk-viewer/viewer/camera.js").Camera;
                        } | {
                            type: "cameraPoseUpdated";
                            pose: import("gl-matrix").ReadonlyMat4;
                        } | {
                            type: "setResolution";
                            resolution: [number, number];
                        }, undefined, {
                            src: "camera";
                            logic: import("xstate").StateMachine<{
                                pose: import("@itk-viewer/viewer/camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<import("xstate").AnyActorRef>;
                            }, {
                                type: "setPose";
                                pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: import("xstate").AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, {}, never, {
                                type: "emitNewPose";
                                params: {
                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                    parallelScaleRatio: number;
                                };
                            }, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
                                readonly id: "camera";
                                readonly initial: "active";
                                readonly context: () => {
                                    pose: {
                                        center: import("gl-matrix").vec3;
                                        rotation: import("gl-matrix").quat;
                                        distance: number;
                                    };
                                    enableRotation: true;
                                    parallelScaleRatio: number;
                                    verticalFieldOfView: number;
                                    poseWatchers: never[];
                                };
                                readonly states: {
                                    readonly active: {
                                        readonly on: {
                                            readonly setPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, {
                                                    readonly type: "emitNewPose";
                                                    readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                        context: {
                                                            pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                            enableRotation: boolean;
                                                            verticalFieldOfView: number;
                                                            parallelScaleRatio: number;
                                                            poseWatchers: Array<import("xstate").AnyActorRef>;
                                                        };
                                                        event: {
                                                            type: "setPose";
                                                            pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                                parallelScale?: number;
                                                            };
                                                        };
                                                    }) => {
                                                        pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                        parallelScaleRatio: number;
                                                    };
                                                }];
                                            };
                                            readonly watchPose: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }>) => void];
                                            };
                                            readonly watchPoseStop: {
                                                readonly actions: readonly [import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>];
                                            };
                                            readonly setEnableRotation: {
                                                readonly actions: import("xstate").ActionFunction<{
                                                    pose: import("@itk-viewer/viewer/camera.js").Pose;
                                                    enableRotation: boolean;
                                                    verticalFieldOfView: number;
                                                    parallelScaleRatio: number;
                                                    poseWatchers: Array<import("xstate").AnyActorRef>;
                                                }, {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, {
                                                    type: "setPose";
                                                    pose: import("@itk-viewer/viewer/camera.js").ReadonlyPose & {
                                                        parallelScale?: number;
                                                    };
                                                } | {
                                                    type: "watchPose";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "watchPoseStop";
                                                    watcher: import("xstate").AnyActorRef;
                                                } | {
                                                    type: "setEnableRotation";
                                                    enable: boolean;
                                                }, undefined, never, never, never, never, never>;
                                            };
                                        };
                                    };
                                };
                            }>;
                            id: string | undefined;
                        }, never, never, never, never>, "forwardToParent"];
                    };
                };
            };
        };
    }>, import("@itk-viewer/viewer/children.js").CreateChild | {
        type: "setImage";
        image: import("@itk-viewer/io/MultiscaleSpatialImage.js").MultiscaleSpatialImage;
    } | {
        type: "setCamera";
        camera: import("@itk-viewer/viewer/camera.js").Camera;
    } | {
        type: "cameraPoseUpdated";
        pose: import("gl-matrix").ReadonlyMat4;
    } | {
        type: "setResolution";
        resolution: [number, number];
    }, import("xstate").EventObject> | undefined;
    setActor(actor: ViewportActor): void;
    render(): import("lit").TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'itk-viewport': ItkViewport;
    }
}
//# sourceMappingURL=itk-viewport.d.ts.map