import { ActorRefFrom, AnyActorRef } from 'xstate';
import { ReadonlyMat4 } from 'gl-matrix';
import { MultiscaleSpatialImage } from '@itk-viewer/io/MultiscaleSpatialImage.js';
import { Camera } from './camera.js';
import { CreateChild } from './children.js';
type Context = {
    image?: MultiscaleSpatialImage;
    camera: Camera;
    resolution: [number, number];
    views: AnyActorRef[];
};
type SetImageEvent = {
    type: 'setImage';
    image: MultiscaleSpatialImage;
};
type SetCameraEvent = {
    type: 'setCamera';
    camera: Camera;
};
type CameraPoseUpdatedEvent = {
    type: 'cameraPoseUpdated';
    pose: ReadonlyMat4;
};
export type Events = SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
    type: 'setResolution';
    resolution: [number, number];
} | CreateChild;
export declare const viewportMachine: import("xstate").StateMachine<Context, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
    type: "setResolution";
    resolution: [number, number];
}, {
    [x: string]: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
        pose: import("./camera.js").Pose;
        enableRotation: boolean;
        verticalFieldOfView: number;
        parallelScaleRatio: number;
        poseWatchers: Array<AnyActorRef>;
    }, {
        type: "setPose";
        pose: import("./camera.js").ReadonlyPose & {
            parallelScale?: number;
        };
    } | {
        type: "watchPose";
        watcher: AnyActorRef;
    } | {
        type: "watchPoseStop";
        watcher: 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("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>, {
                            readonly type: "emitNewPose";
                            readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                context: {
                                    pose: import("./camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<AnyActorRef>;
                                };
                                event: {
                                    type: "setPose";
                                    pose: import("./camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                };
                            }) => {
                                pose: import("./camera.js").Pose;
                                parallelScaleRatio: number;
                            };
                        }];
                    };
                    readonly watchPose: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }>) => void];
                    };
                    readonly watchPoseStop: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>];
                    };
                    readonly setEnableRotation: {
                        readonly actions: import("xstate").ActionFunction<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>;
                    };
                };
            };
        };
    }>, {
        type: "setPose";
        pose: import("./camera.js").ReadonlyPose & {
            parallelScale?: number;
        };
    } | {
        type: "watchPose";
        watcher: AnyActorRef;
    } | {
        type: "watchPoseStop";
        watcher: AnyActorRef;
    } | {
        type: "setEnableRotation";
        enable: boolean;
    }, import("xstate").EventObject> | undefined;
}, {
    src: "camera";
    logic: import("xstate").StateMachine<{
        pose: import("./camera.js").Pose;
        enableRotation: boolean;
        verticalFieldOfView: number;
        parallelScaleRatio: number;
        poseWatchers: Array<AnyActorRef>;
    }, {
        type: "setPose";
        pose: import("./camera.js").ReadonlyPose & {
            parallelScale?: number;
        };
    } | {
        type: "watchPose";
        watcher: AnyActorRef;
    } | {
        type: "watchPoseStop";
        watcher: AnyActorRef;
    } | {
        type: "setEnableRotation";
        enable: boolean;
    }, {}, never, {
        type: "emitNewPose";
        params: {
            pose: import("./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("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>, {
                            readonly type: "emitNewPose";
                            readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                context: {
                                    pose: import("./camera.js").Pose;
                                    enableRotation: boolean;
                                    verticalFieldOfView: number;
                                    parallelScaleRatio: number;
                                    poseWatchers: Array<AnyActorRef>;
                                };
                                event: {
                                    type: "setPose";
                                    pose: import("./camera.js").ReadonlyPose & {
                                        parallelScale?: number;
                                    };
                                };
                            }) => {
                                pose: import("./camera.js").Pose;
                                parallelScaleRatio: number;
                            };
                        }];
                    };
                    readonly watchPose: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }>) => void];
                    };
                    readonly watchPoseStop: {
                        readonly actions: readonly [import("xstate").ActionFunction<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>];
                    };
                    readonly setEnableRotation: {
                        readonly actions: import("xstate").ActionFunction<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, undefined, never, never, never, never, never>;
                    };
                };
            };
        };
    }>;
    id: string | undefined;
}, import("xstate").Values<{
    forwardToParent: {
        type: "forwardToParent";
        params: import("xstate").NonReducibleUnknown;
    };
    forwardToViews: {
        type: "forwardToViews";
        params: unknown;
    };
}>, never, never, "active", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    readonly id: "viewport";
    readonly context: ({ spawn }: {
        spawn: {
            <TSrc extends "camera">(logic: TSrc, ...[options]: {
                src: "camera";
                logic: import("xstate").StateMachine<{
                    pose: import("./camera.js").Pose;
                    enableRotation: boolean;
                    verticalFieldOfView: number;
                    parallelScaleRatio: number;
                    poseWatchers: Array<AnyActorRef>;
                }, {
                    type: "setPose";
                    pose: import("./camera.js").ReadonlyPose & {
                        parallelScale?: number;
                    };
                } | {
                    type: "watchPose";
                    watcher: AnyActorRef;
                } | {
                    type: "watchPoseStop";
                    watcher: AnyActorRef;
                } | {
                    type: "setEnableRotation";
                    enable: boolean;
                }, {}, never, {
                    type: "emitNewPose";
                    params: {
                        pose: import("./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("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>, {
                                        readonly type: "emitNewPose";
                                        readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                            context: {
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            };
                                            event: {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            };
                                        }) => {
                                            pose: import("./camera.js").Pose;
                                            parallelScaleRatio: number;
                                        };
                                    }];
                                };
                                readonly watchPose: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }>) => void];
                                };
                                readonly watchPoseStop: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>];
                                };
                                readonly setEnableRotation: {
                                    readonly actions: import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: 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("./camera.js").Pose;
                    enableRotation: boolean;
                    verticalFieldOfView: number;
                    parallelScaleRatio: number;
                    poseWatchers: Array<AnyActorRef>;
                }, {
                    type: "setPose";
                    pose: import("./camera.js").ReadonlyPose & {
                        parallelScale?: number;
                    };
                } | {
                    type: "watchPose";
                    watcher: AnyActorRef;
                } | {
                    type: "watchPoseStop";
                    watcher: AnyActorRef;
                } | {
                    type: "setEnableRotation";
                    enable: boolean;
                }, {}, never, {
                    type: "emitNewPose";
                    params: {
                        pose: import("./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("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>, {
                                        readonly type: "emitNewPose";
                                        readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                            context: {
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            };
                                            event: {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            };
                                        }) => {
                                            pose: import("./camera.js").Pose;
                                            parallelScaleRatio: number;
                                        };
                                    }];
                                };
                                readonly watchPose: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }>) => void];
                                };
                                readonly watchPoseStop: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>];
                                };
                                readonly setEnableRotation: {
                                    readonly actions: import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: 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): ActorRefFrom<import("xstate").GetConcreteByKey<{
                src: "camera";
                logic: import("xstate").StateMachine<{
                    pose: import("./camera.js").Pose;
                    enableRotation: boolean;
                    verticalFieldOfView: number;
                    parallelScaleRatio: number;
                    poseWatchers: Array<AnyActorRef>;
                }, {
                    type: "setPose";
                    pose: import("./camera.js").ReadonlyPose & {
                        parallelScale?: number;
                    };
                } | {
                    type: "watchPose";
                    watcher: AnyActorRef;
                } | {
                    type: "watchPoseStop";
                    watcher: AnyActorRef;
                } | {
                    type: "setEnableRotation";
                    enable: boolean;
                }, {}, never, {
                    type: "emitNewPose";
                    params: {
                        pose: import("./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("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>, {
                                        readonly type: "emitNewPose";
                                        readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                            context: {
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            };
                                            event: {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            };
                                        }) => {
                                            pose: import("./camera.js").Pose;
                                            parallelScaleRatio: number;
                                        };
                                    }];
                                };
                                readonly watchPose: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }>) => void];
                                };
                                readonly watchPoseStop: {
                                    readonly actions: readonly [import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, undefined, never, never, never, never, never>];
                                };
                                readonly setEnableRotation: {
                                    readonly actions: import("xstate").ActionFunction<{
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    }, {
                                        type: "setEnableRotation";
                                        enable: boolean;
                                    }, {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    } | {
                                        type: "watchPose";
                                        watcher: AnyActorRef;
                                    } | {
                                        type: "watchPoseStop";
                                        watcher: 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): ActorRefFrom<TLogic>;
        };
        input: import("xstate").NonReducibleUnknown;
        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<Context, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
            type: "setResolution";
            resolution: [number, number];
        }, Record<string, AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
            type: "setResolution";
            resolution: [number, number];
        }, import("xstate").AnyEventObject>;
    }) => {
        resolution: [number, number];
        views: never[];
        camera: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
            pose: import("./camera.js").Pose;
            enableRotation: boolean;
            verticalFieldOfView: number;
            parallelScaleRatio: number;
            poseWatchers: Array<AnyActorRef>;
        }, {
            type: "setPose";
            pose: import("./camera.js").ReadonlyPose & {
                parallelScale?: number;
            };
        } | {
            type: "watchPose";
            watcher: AnyActorRef;
        } | {
            type: "watchPoseStop";
            watcher: 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("./camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<AnyActorRef>;
                            }, {
                                type: "setPose";
                                pose: import("./camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            }, {
                                type: "setPose";
                                pose: import("./camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>, {
                                readonly type: "emitNewPose";
                                readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                    context: {
                                        pose: import("./camera.js").Pose;
                                        enableRotation: boolean;
                                        verticalFieldOfView: number;
                                        parallelScaleRatio: number;
                                        poseWatchers: Array<AnyActorRef>;
                                    };
                                    event: {
                                        type: "setPose";
                                        pose: import("./camera.js").ReadonlyPose & {
                                            parallelScale?: number;
                                        };
                                    };
                                }) => {
                                    pose: import("./camera.js").Pose;
                                    parallelScaleRatio: number;
                                };
                            }];
                        };
                        readonly watchPose: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                pose: import("./camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<AnyActorRef>;
                            }, {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            }, {
                                type: "setPose";
                                pose: import("./camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                pose: import("./camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<AnyActorRef>;
                            }, {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            }, {
                                type: "setPose";
                                pose: import("./camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }>) => void];
                        };
                        readonly watchPoseStop: {
                            readonly actions: readonly [import("xstate").ActionFunction<{
                                pose: import("./camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<AnyActorRef>;
                            }, {
                                type: "watchPoseStop";
                                watcher: AnyActorRef;
                            }, {
                                type: "setPose";
                                pose: import("./camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>];
                        };
                        readonly setEnableRotation: {
                            readonly actions: import("xstate").ActionFunction<{
                                pose: import("./camera.js").Pose;
                                enableRotation: boolean;
                                verticalFieldOfView: number;
                                parallelScaleRatio: number;
                                poseWatchers: Array<AnyActorRef>;
                            }, {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, {
                                type: "setPose";
                                pose: import("./camera.js").ReadonlyPose & {
                                    parallelScale?: number;
                                };
                            } | {
                                type: "watchPose";
                                watcher: AnyActorRef;
                            } | {
                                type: "watchPoseStop";
                                watcher: AnyActorRef;
                            } | {
                                type: "setEnableRotation";
                                enable: boolean;
                            }, undefined, never, never, never, never, never>;
                        };
                    };
                };
            };
        }>, {
            type: "setPose";
            pose: import("./camera.js").ReadonlyPose & {
                parallelScale?: number;
            };
        } | {
            type: "watchPose";
            watcher: AnyActorRef;
        } | {
            type: "watchPoseStop";
            watcher: 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<Context, CreateChild, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
                        type: "setResolution";
                        resolution: [number, number];
                    }, undefined, {
                        src: "camera";
                        logic: import("xstate").StateMachine<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, {}, never, {
                            type: "emitNewPose";
                            params: {
                                pose: import("./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("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, {
                                                readonly type: "emitNewPose";
                                                readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                    context: {
                                                        pose: import("./camera.js").Pose;
                                                        enableRotation: boolean;
                                                        verticalFieldOfView: number;
                                                        parallelScaleRatio: number;
                                                        poseWatchers: Array<AnyActorRef>;
                                                    };
                                                    event: {
                                                        type: "setPose";
                                                        pose: import("./camera.js").ReadonlyPose & {
                                                            parallelScale?: number;
                                                        };
                                                    };
                                                }) => {
                                                    pose: import("./camera.js").Pose;
                                                    parallelScaleRatio: number;
                                                };
                                            }];
                                        };
                                        readonly watchPose: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }>) => void];
                                        };
                                        readonly watchPoseStop: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>];
                                        };
                                        readonly setEnableRotation: {
                                            readonly actions: import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: 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<Context, SetImageEvent, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
                        type: "setResolution";
                        resolution: [number, number];
                    }, undefined, {
                        src: "camera";
                        logic: import("xstate").StateMachine<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, {}, never, {
                            type: "emitNewPose";
                            params: {
                                pose: import("./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("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, {
                                                readonly type: "emitNewPose";
                                                readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                    context: {
                                                        pose: import("./camera.js").Pose;
                                                        enableRotation: boolean;
                                                        verticalFieldOfView: number;
                                                        parallelScaleRatio: number;
                                                        poseWatchers: Array<AnyActorRef>;
                                                    };
                                                    event: {
                                                        type: "setPose";
                                                        pose: import("./camera.js").ReadonlyPose & {
                                                            parallelScale?: number;
                                                        };
                                                    };
                                                }) => {
                                                    pose: import("./camera.js").Pose;
                                                    parallelScaleRatio: number;
                                                };
                                            }];
                                        };
                                        readonly watchPose: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }>) => void];
                                        };
                                        readonly watchPoseStop: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>];
                                        };
                                        readonly setEnableRotation: {
                                            readonly actions: import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: 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<Context, SetCameraEvent, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
                        type: "setResolution";
                        resolution: [number, number];
                    }, undefined, {
                        src: "camera";
                        logic: import("xstate").StateMachine<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, {}, never, {
                            type: "emitNewPose";
                            params: {
                                pose: import("./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("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, {
                                                readonly type: "emitNewPose";
                                                readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                    context: {
                                                        pose: import("./camera.js").Pose;
                                                        enableRotation: boolean;
                                                        verticalFieldOfView: number;
                                                        parallelScaleRatio: number;
                                                        poseWatchers: Array<AnyActorRef>;
                                                    };
                                                    event: {
                                                        type: "setPose";
                                                        pose: import("./camera.js").ReadonlyPose & {
                                                            parallelScale?: number;
                                                        };
                                                    };
                                                }) => {
                                                    pose: import("./camera.js").Pose;
                                                    parallelScaleRatio: number;
                                                };
                                            }];
                                        };
                                        readonly watchPose: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }>) => void];
                                        };
                                        readonly watchPoseStop: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>];
                                        };
                                        readonly setEnableRotation: {
                                            readonly actions: import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: 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<Context, {
                        type: "setResolution";
                        resolution: [number, number];
                    }, CreateChild | SetImageEvent | SetCameraEvent | CameraPoseUpdatedEvent | {
                        type: "setResolution";
                        resolution: [number, number];
                    }, undefined, {
                        src: "camera";
                        logic: import("xstate").StateMachine<{
                            pose: import("./camera.js").Pose;
                            enableRotation: boolean;
                            verticalFieldOfView: number;
                            parallelScaleRatio: number;
                            poseWatchers: Array<AnyActorRef>;
                        }, {
                            type: "setPose";
                            pose: import("./camera.js").ReadonlyPose & {
                                parallelScale?: number;
                            };
                        } | {
                            type: "watchPose";
                            watcher: AnyActorRef;
                        } | {
                            type: "watchPoseStop";
                            watcher: AnyActorRef;
                        } | {
                            type: "setEnableRotation";
                            enable: boolean;
                        }, {}, never, {
                            type: "emitNewPose";
                            params: {
                                pose: import("./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("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, {
                                                readonly type: "emitNewPose";
                                                readonly params: ({ context: { pose, parallelScaleRatio } }: {
                                                    context: {
                                                        pose: import("./camera.js").Pose;
                                                        enableRotation: boolean;
                                                        verticalFieldOfView: number;
                                                        parallelScaleRatio: number;
                                                        poseWatchers: Array<AnyActorRef>;
                                                    };
                                                    event: {
                                                        type: "setPose";
                                                        pose: import("./camera.js").ReadonlyPose & {
                                                            parallelScale?: number;
                                                        };
                                                    };
                                                }) => {
                                                    pose: import("./camera.js").Pose;
                                                    parallelScaleRatio: number;
                                                };
                                            }];
                                        };
                                        readonly watchPose: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>, ({ context: { pose, parallelScaleRatio }, event: { watcher } }: import("xstate").ActionArgs<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }>) => void];
                                        };
                                        readonly watchPoseStop: {
                                            readonly actions: readonly [import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>];
                                        };
                                        readonly setEnableRotation: {
                                            readonly actions: import("xstate").ActionFunction<{
                                                pose: import("./camera.js").Pose;
                                                enableRotation: boolean;
                                                verticalFieldOfView: number;
                                                parallelScaleRatio: number;
                                                poseWatchers: Array<AnyActorRef>;
                                            }, {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, {
                                                type: "setPose";
                                                pose: import("./camera.js").ReadonlyPose & {
                                                    parallelScale?: number;
                                                };
                                            } | {
                                                type: "watchPose";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "watchPoseStop";
                                                watcher: AnyActorRef;
                                            } | {
                                                type: "setEnableRotation";
                                                enable: boolean;
                                            }, undefined, never, never, never, never, never>;
                                        };
                                    };
                                };
                            };
                        }>;
                        id: string | undefined;
                    }, never, never, never, never>, "forwardToParent"];
                };
            };
        };
    };
}>;
export type ViewportActor = ActorRefFrom<typeof viewportMachine>;
export {};
//# sourceMappingURL=viewport.d.ts.map