@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/editor/QuestEditor.d.ts

@@ -0,0 +1,252 @@
+/**
+ * @file QuestEditor.ts
+ * @description Quest Editor system with quest graphs, conditions, and rewards
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Quest definition with stages
+ * - Objectives (kill, collect, talk, explore, escort, etc.)
+ * - Conditions and prerequisites
+ * - Rewards (items, experience, reputation, unlocks)
+ * - Quest chains and branching paths
+ * - Time limits and failures
+ * - Quest tracking and progress
+ * - Journal/log system
+ * - Localization support
+ */
+export type QuestStatus = 'locked' | 'available' | 'active' | 'completed' | 'failed' | 'abandoned';
+export type ObjectiveType = 'kill' | 'collect' | 'talk' | 'interact' | 'explore' | 'escort' | 'deliver' | 'craft' | 'survive' | 'reach' | 'protect' | 'use' | 'custom';
+export type RewardType = 'item' | 'currency' | 'experience' | 'reputation' | 'skill' | 'unlock' | 'quest' | 'achievement' | 'custom';
+export type ConditionType = 'level' | 'quest' | 'item' | 'stat' | 'reputation' | 'skill' | 'flag' | 'time' | 'location' | 'custom';
+export interface LocalizedString {
+    key: string;
+    default: string;
+    translations: Map<string, string>;
+}
+export interface QuestCondition {
+    type: ConditionType;
+    target: string;
+    operator: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'has' | 'not_has';
+    value: string | number | boolean;
+    description?: LocalizedString;
+}
+export interface QuestReward {
+    type: RewardType;
+    target: string;
+    amount: number;
+    description?: LocalizedString;
+    chance?: number;
+    isHidden?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface QuestObjective {
+    id: string;
+    type: ObjectiveType;
+    description: LocalizedString;
+    target: string;
+    targetAmount: number;
+    currentAmount: number;
+    isOptional: boolean;
+    isHidden: boolean;
+    isCompleted: boolean;
+    trackingHint?: LocalizedString;
+    markerLocation?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    markerIcon?: string;
+    requiresObjectives?: string[];
+    rewards?: QuestReward[];
+    metadata?: Record<string, unknown>;
+}
+export interface QuestStage {
+    id: string;
+    name: LocalizedString;
+    description: LocalizedString;
+    objectives: QuestObjective[];
+    stageRewards?: QuestReward[];
+    nextStageId?: string;
+    branchConditions?: QuestStageBranch[];
+    onEnterDialogueId?: string;
+    onCompleteDialogueId?: string;
+    onEnterActions?: QuestAction[];
+    onCompleteActions?: QuestAction[];
+    timeLimit?: number;
+    onTimeoutStageId?: string;
+    onTimeoutActions?: QuestAction[];
+}
+export interface QuestStageBranch {
+    condition: QuestCondition;
+    targetStageId: string;
+}
+export interface QuestAction {
+    type: 'setFlag' | 'removeFlag' | 'giveItem' | 'removeItem' | 'teleport' | 'spawn' | 'dialogue' | 'cutscene' | 'custom';
+    target: string;
+    params?: Record<string, unknown>;
+}
+export interface Quest {
+    id: string;
+    name: LocalizedString;
+    description: LocalizedString;
+    shortDescription?: LocalizedString;
+    category: string;
+    tags: string[];
+    icon?: string;
+    color?: string;
+    priority: number;
+    isMainQuest: boolean;
+    isSideQuest: boolean;
+    isDailyQuest: boolean;
+    isRepeatable: boolean;
+    repeatCooldown?: number;
+    recommendedLevel?: number;
+    minLevel?: number;
+    maxLevel?: number;
+    prerequisites: QuestCondition[];
+    stages: Map<string, QuestStage>;
+    startStageId: string;
+    rewards: QuestReward[];
+    chainId?: string;
+    chainOrder?: number;
+    conflictingQuests?: string[];
+    requiredQuests?: string[];
+    questGiverId?: string;
+    questTurnInId?: string;
+    availableFrom?: number;
+    availableUntil?: number;
+    createdAt: number;
+    modifiedAt: number;
+    version: number;
+}
+export interface QuestChain {
+    id: string;
+    name: LocalizedString;
+    description: LocalizedString;
+    questIds: string[];
+    rewards?: QuestReward[];
+}
+export interface QuestProgress {
+    questId: string;
+    status: QuestStatus;
+    currentStageId: string;
+    objectiveProgress: Map<string, number>;
+    startedAt: number;
+    completedAt?: number;
+    failedAt?: number;
+    stageStartedAt: number;
+    flags: Set<string>;
+}
+export interface JournalEntry {
+    id: string;
+    questId: string;
+    stageId?: string;
+    objectiveId?: string;
+    type: 'start' | 'update' | 'complete' | 'fail' | 'reward' | 'note';
+    text: LocalizedString;
+    timestamp: number;
+    isRead: boolean;
+}
+export declare class QuestManager {
+    private quests;
+    private chains;
+    private activeProgress;
+    private completedQuests;
+    private journal;
+    private currentLanguage;
+    private playerLevel;
+    private playerFlags;
+    private playerStats;
+    private playerItems;
+    private playerReputation;
+    private onQuestAvailable?;
+    private onQuestStarted?;
+    private onQuestUpdated?;
+    private onQuestCompleted?;
+    private onQuestFailed?;
+    private onObjectiveUpdated?;
+    private onJournalEntry?;
+    private onReward?;
+    private customConditionEvaluator?;
+    private customActionExecutor?;
+    createQuest(name: string, description: string): Quest;
+    getQuest(id: string): Quest | undefined;
+    deleteQuest(id: string): boolean;
+    getAllQuests(): Quest[];
+    createStage(name: string, description: string): QuestStage;
+    addStage(questId: string, stage: QuestStage): boolean;
+    updateStage(questId: string, stageId: string, updates: Partial<QuestStage>): boolean;
+    connectStages(questId: string, fromStageId: string, toStageId: string, condition?: QuestCondition): boolean;
+    createObjective(type: ObjectiveType, description: string, target: string, amount?: number): QuestObjective;
+    addObjective(questId: string, stageId: string, objective: QuestObjective): boolean;
+    createReward(type: RewardType, target: string, amount: number): QuestReward;
+    addQuestReward(questId: string, reward: QuestReward): boolean;
+    addStageReward(questId: string, stageId: string, reward: QuestReward): boolean;
+    createChain(name: string, description: string): QuestChain;
+    addQuestToChain(chainId: string, questId: string): boolean;
+    getAvailableQuests(): Quest[];
+    isQuestAvailable(quest: Quest): boolean;
+    startQuest(questId: string): boolean;
+    updateObjective(questId: string, objectiveId: string, amount?: number): boolean;
+    private checkStageCompletion;
+    private advanceToStage;
+    completeQuest(questId: string): void;
+    failQuest(questId: string, reason?: string): void;
+    abandonQuest(questId: string): boolean;
+    private checkChainCompletion;
+    private evaluateCondition;
+    private executeAction;
+    private giveReward;
+    private addJournalEntry;
+    getJournal(questId?: string): JournalEntry[];
+    markJournalRead(entryId: string): void;
+    setPlayerLevel(level: number): void;
+    setPlayerFlag(flag: string, value?: boolean): void;
+    setPlayerStat(stat: string, value: number): void;
+    setPlayerItem(item: string, count: number): void;
+    setPlayerReputation(faction: string, value: number): void;
+    createLocalizedString(text: string): LocalizedString;
+    getString(ls: LocalizedString, language?: string): string;
+    setLanguage(language: string): void;
+    setOnQuestAvailable(callback: (quest: Quest) => void): void;
+    setOnQuestStarted(callback: (quest: Quest, progress: QuestProgress) => void): void;
+    setOnQuestUpdated(callback: (quest: Quest, progress: QuestProgress) => void): void;
+    setOnQuestCompleted(callback: (quest: Quest, rewards: QuestReward[]) => void): void;
+    setOnQuestFailed(callback: (quest: Quest) => void): void;
+    setOnObjectiveUpdated(callback: (quest: Quest, objective: QuestObjective) => void): void;
+    setOnJournalEntry(callback: (entry: JournalEntry) => void): void;
+    setOnReward(callback: (reward: QuestReward) => void): void;
+    setCustomConditionEvaluator(evaluator: (condition: QuestCondition) => boolean): void;
+    setCustomActionExecutor(executor: (action: QuestAction) => void): void;
+    getActiveQuests(): Quest[];
+    getQuestProgress(questId: string): QuestProgress | undefined;
+    isQuestActive(questId: string): boolean;
+    isQuestCompleted(questId: string): boolean;
+    getQuestsByCategory(category: string): Quest[];
+    getQuestChain(chainId: string): QuestChain | undefined;
+    exportQuest(questId: string): string | null;
+    importQuest(json: string): Quest | null;
+    exportProgress(): string;
+    importProgress(json: string): boolean;
+    getQuestGraph(questId: string): {
+        nodes: QuestGraphNode[];
+        edges: QuestGraphEdge[];
+    } | null;
+}
+export interface QuestGraphNode {
+    id: string;
+    name: string;
+    type: 'stage';
+    objectiveCount: number;
+    x: number;
+    y: number;
+}
+export interface QuestGraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'default' | 'conditional';
+    label?: string;
+}
+export declare function createQuestManager(): QuestManager;
+export declare function createQuestCondition(type: ConditionType, target: string, operator: QuestCondition['operator'], value: string | number | boolean): QuestCondition;

package/dist/types/editor/ReplaySystem.d.ts

@@ -0,0 +1,231 @@
+/**
+ * @file ReplaySystem.ts
+ * @description Replay System for recording and playback of gameplay
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Input recording
+ * - State snapshots
+ * - Replay playback with speed control
+ * - Seek functionality
+ * - Keyframe system
+ * - Compression
+ * - Export/import formats
+ * - Spectator mode
+ * - Highlight markers
+ * - Replay validation
+ */
+export type ReplayState = 'idle' | 'recording' | 'playing' | 'paused' | 'seeking';
+export type PlaybackSpeed = 0.25 | 0.5 | 1 | 1.5 | 2 | 4 | 8;
+export interface InputFrame {
+    frameNumber: number;
+    timestamp: number;
+    inputs: Map<string, InputData>;
+}
+export interface InputData {
+    playerId: string;
+    keys: Set<string>;
+    mouseX: number;
+    mouseY: number;
+    mouseButtons: number;
+    gamepadAxes?: number[];
+    gamepadButtons?: boolean[];
+    customData?: Record<string, unknown>;
+}
+export interface StateSnapshot {
+    frameNumber: number;
+    timestamp: number;
+    gameState: unknown;
+    entityStates: Map<string, EntityState>;
+    checksum: string;
+}
+export interface EntityState {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    rotation: number;
+    velocity?: {
+        x: number;
+        y: number;
+    };
+    health?: number;
+    customState?: Record<string, unknown>;
+}
+export interface ReplayMarker {
+    id: string;
+    frameNumber: number;
+    timestamp: number;
+    type: 'highlight' | 'kill' | 'death' | 'objective' | 'custom';
+    label: string;
+    description?: string;
+    thumbnailUrl?: string;
+    playerId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ReplayMetadata {
+    id: string;
+    name: string;
+    description?: string;
+    gameId: string;
+    gameVersion: string;
+    mapId?: string;
+    gameMode?: string;
+    players: ReplayParticipant[];
+    recordedAt: number;
+    duration: number;
+    totalFrames: number;
+    frameRate: number;
+    markers: ReplayMarker[];
+    keyframeCount: number;
+    compressionType: 'none' | 'lz4' | 'zstd' | 'custom';
+    fileSize: number;
+    checksum: string;
+    tags: string[];
+    isPublic: boolean;
+    thumbnailUrl?: string;
+}
+export interface ReplayParticipant {
+    playerId: string;
+    playerName: string;
+    team?: string | number;
+    character?: string;
+    finalScore?: number;
+    finalStats?: Record<string, number>;
+}
+export interface ReplayData {
+    metadata: ReplayMetadata;
+    inputFrames: InputFrame[];
+    snapshots: StateSnapshot[];
+}
+export declare class ReplayRecorder {
+    private isRecording;
+    private startTime;
+    private frameNumber;
+    private inputFrames;
+    private snapshots;
+    private markers;
+    private frameRate;
+    private keyframeInterval;
+    private maxDuration;
+    private gameId;
+    private gameVersion;
+    private players;
+    private mapId?;
+    private gameMode?;
+    private getGameState?;
+    private getEntityStates?;
+    private onRecordingStarted?;
+    private onRecordingStopped?;
+    private onMarkerAdded?;
+    setGameInfo(gameId: string, version: string, mapId?: string, gameMode?: string): void;
+    setPlayers(players: ReplayParticipant[]): void;
+    setFrameRate(fps: number): void;
+    setKeyframeInterval(interval: number): void;
+    setMaxDuration(ms: number): void;
+    setStateGetters(getGameState: () => unknown, getEntityStates: () => Map<string, EntityState>): void;
+    startRecording(): void;
+    stopRecording(): ReplayData | null;
+    recordFrame(inputs: Map<string, InputData>): void;
+    private captureSnapshot;
+    addMarker(type: ReplayMarker['type'], label: string, description?: string, playerId?: string): ReplayMarker | null;
+    getRecordingState(): {
+        isRecording: boolean;
+        duration: number;
+        frameCount: number;
+    };
+    private generateChecksum;
+    private generateSnapshotChecksum;
+    private hashString;
+    setOnRecordingStarted(callback: () => void): void;
+    setOnRecordingStopped(callback: (data: ReplayData) => void): void;
+    setOnMarkerAdded(callback: (marker: ReplayMarker) => void): void;
+}
+export declare class ReplayPlayer {
+    private state;
+    private replayData;
+    private currentFrame;
+    private currentTime;
+    private playbackSpeed;
+    private lastUpdateTime;
+    private frameTime;
+    private accumulatedTime;
+    private onStateChanged?;
+    private onFrameChanged?;
+    private onInputFrame?;
+    private onSnapshotReached?;
+    private onMarkerReached?;
+    private onPlaybackComplete?;
+    private applyGameState?;
+    private applyEntityStates?;
+    loadReplay(data: ReplayData): boolean;
+    unloadReplay(): void;
+    private validateReplay;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    togglePlayPause(): void;
+    setSpeed(speed: PlaybackSpeed): void;
+    seekToFrame(frame: number): void;
+    seekToTime(ms: number): void;
+    seekToMarker(markerId: string): void;
+    stepForward(frames?: number): void;
+    stepBackward(frames?: number): void;
+    private findNearestSnapshot;
+    update(): void;
+    private processFrame;
+    private reset;
+    getState(): ReplayState;
+    getCurrentFrame(): number;
+    getCurrentTime(): number;
+    getTotalFrames(): number;
+    getDuration(): number;
+    getProgress(): number;
+    getPlaybackSpeed(): PlaybackSpeed;
+    getMetadata(): ReplayMetadata | null;
+    getMarkers(): ReplayMarker[];
+    setApplyGameState(callback: (state: unknown) => void): void;
+    setApplyEntityStates(callback: (states: Map<string, EntityState>) => void): void;
+    setOnStateChanged(callback: (state: ReplayState) => void): void;
+    setOnFrameChanged(callback: (frame: number, timestamp: number) => void): void;
+    setOnInputFrame(callback: (inputs: Map<string, InputData>) => void): void;
+    setOnSnapshotReached(callback: (snapshot: StateSnapshot) => void): void;
+    setOnMarkerReached(callback: (marker: ReplayMarker) => void): void;
+    setOnPlaybackComplete(callback: () => void): void;
+}
+export declare class ReplayManager {
+    private recorder;
+    private player;
+    private savedReplays;
+    private onReplaySaved?;
+    private onReplayDeleted?;
+    private onReplayExported?;
+    getRecorder(): ReplayRecorder;
+    getPlayer(): ReplayPlayer;
+    saveReplay(data: ReplayData, name?: string): string;
+    loadReplayById(id: string): boolean;
+    deleteReplay(id: string): boolean;
+    getSavedReplays(): ReplayMetadata[];
+    getReplayById(id: string): ReplayData | undefined;
+    exportReplay(id: string, format?: 'json' | 'binary'): string | ArrayBuffer | null;
+    importReplay(data: string | ArrayBuffer): ReplayData | null;
+    startRecording(): void;
+    stopRecordingAndSave(name?: string): string | null;
+    playLatestReplay(): boolean;
+    searchReplays(query: string): ReplayMetadata[];
+    getReplaysByPlayer(playerId: string): ReplayMetadata[];
+    getReplaysByGameMode(gameMode: string): ReplayMetadata[];
+    getTotalStorageUsed(): number;
+    getReplayCount(): number;
+    setOnReplaySaved(callback: (replay: ReplayData) => void): void;
+    setOnReplayDeleted(callback: (id: string) => void): void;
+    setOnReplayExported(callback: (id: string, format: string) => void): void;
+    exportAllReplays(): string;
+    importAllReplays(json: string): number;
+}
+export declare function createReplayManager(): ReplayManager;
+export declare function createReplayRecorder(): ReplayRecorder;
+export declare function createReplayPlayer(): ReplayPlayer;

package/dist/types/editor/ScreenshotMode.d.ts

@@ -0,0 +1,203 @@
+/**
+ * @file ScreenshotMode.ts
+ * @description Screenshot/Photo Mode system with free camera and filters
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Free camera movement
+ * - Hide UI elements
+ * - Image filters and effects
+ * - Resolution settings
+ * - Depth of field
+ * - Frame composition guides
+ * - Screenshot capture and save
+ * - Animation/pose freeze
+ * - Focus points
+ * - Watermarks and overlays
+ */
+export type FilterType = 'none' | 'grayscale' | 'sepia' | 'vintage' | 'noir' | 'vibrant' | 'warm' | 'cool' | 'dramatic' | 'soft' | 'hdr' | 'cinematic' | 'custom';
+export type CompositionGuide = 'none' | 'rule_of_thirds' | 'golden_ratio' | 'diagonal' | 'center' | 'triangle' | 'symmetry';
+export type OutputFormat = 'png' | 'jpg' | 'webp';
+export type AspectRatio = '16:9' | '4:3' | '1:1' | '21:9' | '9:16' | 'custom';
+export interface CameraState {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    fov: number;
+    near: number;
+    far: number;
+}
+export interface FilterSettings {
+    type: FilterType;
+    intensity: number;
+    customSettings?: CustomFilterSettings;
+}
+export interface CustomFilterSettings {
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    hue: number;
+    gamma: number;
+    exposure: number;
+    temperature: number;
+    tint: number;
+    shadows: number;
+    highlights: number;
+    vignette: number;
+    vignetteColor: string;
+    grain: number;
+    blur: number;
+    sharpen: number;
+}
+export interface DepthOfFieldSettings {
+    enabled: boolean;
+    focusDistance: number;
+    aperture: number;
+    focalLength: number;
+    bokehSize: number;
+    bokehShape: 'circle' | 'hexagon' | 'octagon';
+    autoFocus: boolean;
+    focusPoint?: {
+        x: number;
+        y: number;
+    };
+}
+export interface ResolutionSettings {
+    width: number;
+    height: number;
+    aspectRatio: AspectRatio;
+    supersampling: 1 | 2 | 4;
+}
+export interface WatermarkSettings {
+    enabled: boolean;
+    text?: string;
+    imageUrl?: string;
+    position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+    opacity: number;
+    scale: number;
+    padding: number;
+}
+export interface ScreenshotSettings {
+    format: OutputFormat;
+    quality: number;
+    resolution: ResolutionSettings;
+    filter: FilterSettings;
+    dof: DepthOfFieldSettings;
+    compositionGuide: CompositionGuide;
+    watermark: WatermarkSettings;
+    includeTimestamp: boolean;
+    includeMetadata: boolean;
+}
+export interface ScreenshotResult {
+    id: string;
+    dataUrl: string;
+    blob?: Blob;
+    width: number;
+    height: number;
+    format: OutputFormat;
+    takenAt: number;
+    cameraState: CameraState;
+    settings: ScreenshotSettings;
+    metadata?: Record<string, unknown>;
+}
+export declare const DEFAULT_CUSTOM_FILTER: CustomFilterSettings;
+export declare const DEFAULT_DOF_SETTINGS: DepthOfFieldSettings;
+export declare const DEFAULT_RESOLUTION: ResolutionSettings;
+export declare const DEFAULT_WATERMARK: WatermarkSettings;
+export declare const FILTER_PRESETS: Record<FilterType, Partial<CustomFilterSettings>>;
+export declare class ScreenshotMode {
+    private isActive;
+    private isPaused;
+    private originalCamera;
+    private freeCamera;
+    private moveSpeed;
+    private rotateSpeed;
+    private smoothing;
+    private settings;
+    private hiddenUIElements;
+    private screenshots;
+    private savedCameraPositions;
+    private onModeActivated?;
+    private onModeDeactivated?;
+    private onCameraChanged?;
+    private onSettingsChanged?;
+    private onScreenshotTaken?;
+    private captureCanvas?;
+    private setRenderFilter?;
+    private setUIVisibility?;
+    private pauseGame?;
+    private resumeGame?;
+    activate(initialCamera?: CameraState): void;
+    deactivate(): void;
+    toggle(initialCamera?: CameraState): void;
+    isActivated(): boolean;
+    moveCamera(deltaX: number, deltaY: number, deltaZ: number): void;
+    rotateCamera(deltaPitch: number, deltaYaw: number, deltaRoll?: number): void;
+    setFOV(fov: number): void;
+    adjustFOV(delta: number): void;
+    resetCamera(): void;
+    getCameraState(): CameraState;
+    setCameraState(state: CameraState): void;
+    saveCameraPosition(name: string): void;
+    loadCameraPosition(name: string): boolean;
+    deleteCameraPosition(name: string): boolean;
+    getSavedPositions(): string[];
+    setMoveSpeed(speed: number): void;
+    setRotateSpeed(speed: number): void;
+    setSmoothing(smoothing: number): void;
+    setFilter(type: FilterType, intensity?: number): void;
+    setCustomFilter(settings: Partial<CustomFilterSettings>): void;
+    private applyFilter;
+    private lerp;
+    getFilter(): FilterSettings;
+    setDOF(settings: Partial<DepthOfFieldSettings>): void;
+    setFocusPoint(x: number, y: number): void;
+    enableAutoFocus(): void;
+    setResolution(width: number, height: number): void;
+    setAspectRatio(ratio: AspectRatio): void;
+    setSupersampling(factor: 1 | 2 | 4): void;
+    setCompositionGuide(guide: CompositionGuide): void;
+    setWatermark(settings: Partial<WatermarkSettings>): void;
+    hideUIElement(elementId: string): void;
+    showUIElement(elementId: string): void;
+    hideAllUI(): void;
+    showAllUI(): void;
+    takeScreenshot(metadata?: Record<string, unknown>): Promise<ScreenshotResult | null>;
+    private getMimeType;
+    private applyWatermark;
+    private loadImage;
+    getScreenshots(): ScreenshotResult[];
+    getScreenshotById(id: string): ScreenshotResult | undefined;
+    deleteScreenshot(id: string): boolean;
+    clearScreenshots(): void;
+    downloadScreenshot(id: string, filename?: string): Promise<boolean>;
+    getSettings(): ScreenshotSettings;
+    setSettings(settings: Partial<ScreenshotSettings>): void;
+    resetSettings(): void;
+    private getDefaultSettings;
+    renderCompositionGuide(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    private drawThirdsGrid;
+    private drawGoldenRatio;
+    private drawDiagonals;
+    private drawCenterGuides;
+    private drawTriangle;
+    private drawSymmetry;
+    setOnModeActivated(callback: () => void): void;
+    setOnModeDeactivated(callback: () => void): void;
+    setOnCameraChanged(callback: (camera: CameraState) => void): void;
+    setOnSettingsChanged(callback: (settings: ScreenshotSettings) => void): void;
+    setOnScreenshotTaken(callback: (result: ScreenshotResult) => void): void;
+    setCaptureCanvas(fn: () => HTMLCanvasElement | null): void;
+    setRenderFilterCallback(fn: (filter: CustomFilterSettings) => void): void;
+    setUIVisibilityCallback(fn: (visible: boolean) => void): void;
+    setPauseGame(fn: () => void): void;
+    setResumeGame(fn: () => void): void;
+}
+export declare function createScreenshotMode(): ScreenshotMode;