import LocalEnvironment from "./LocalEnvironment";
import { Readable } from "stream";
import Player from "./../minecraft/Player";
import ServerManager, { IServerVersion } from "./ServerManager";
import ServerConfigManager from "./ServerConfigManager";
import ServerMessage from "./ServerMessage";
import ServerPropertiesManager from "../minecraft/ServerPropertiesManager";
import NodeStorage from "./NodeStorage";
import MCWorld from "../minecraft/MCWorld";
import IFolder from "../storage/IFolder";
import { IMinecraftStartMessage as IMinecraftServerStart, IMinecraftStartMessage } from "../app/IMinecraftStartMessage";
import NodeFolder from "./NodeFolder";
import IActionSetData from "../actions/IActionSetData";
import IStorage from "../storage/IStorage";
import MinecraftDebugClient from "../debugger/MinecraftDebugClient";
import { IStatData, IDebugSessionInfo, IProfilerCaptureEvent } from "../debugger/IMinecraftDebugProtocol";
import { IBackupResult } from "./IWorldBackupData";
export declare enum DedicatedServerStatus {
    stopped = 1,
    deploying = 2,
    launching = 3,
    starting = 4,
    started = 5
}
export interface OutputLine {
    message: string;
    received: number;
    isInternal?: boolean;
}
export declare enum DedicatedServerBackupStatus {
    none = 0,
    suspendingSaveCommandIssued = 1,
    suspendingQueryCommandIssued = 2,
    suspendingQueryResultsPending = 3,
    saveSuspended = 4,
    copyingFiles = 5,
    resumingSave = 6,
    saveResumed = 7
}
export declare const MaxTimeToWaitForServerToStart = 5000;
export default class DedicatedServer {
    #private;
    serverPath: string;
    name: string;
    version?: IServerVersion;
    updates: any[];
    startConfigurationHash?: string;
    outputLines: OutputLine[];
    get opList(): string[];
    set opList(newOps: string[]);
    get port(): number;
    /**
     * Get the script debugger port for this server instance.
     * The debug port is the base port + 12, ensuring each slot has a unique debug port.
     * Slot 0: port 19132 -> debug port 19144
     * Slot 1: port 19164 -> debug port 19176
     * etc.
     */
    get debugPort(): number;
    get lastResult(): string;
    set port(newPort: number);
    get editorMode(): boolean;
    set editorMode(value: boolean);
    get defaultWorldFolder(): NodeFolder;
    get behaviorPacksFolder(): NodeFolder;
    get resourcePacksFolder(): NodeFolder;
    /**
     * Get the behavior packs storage (NodeStorage) for file watching purposes.
     */
    get behaviorPacksStorage(): NodeStorage | undefined;
    /**
     * Get the default world storage (NodeStorage) for file watching purposes.
     */
    get defaultWorldStorage(): NodeStorage | undefined;
    /**
     * Get the resource packs storage (NodeStorage) for file watching purposes.
     */
    get resourcePacksStorage(): NodeStorage | undefined;
    config: ServerConfigManager;
    properties: ServerPropertiesManager;
    deployCount: number;
    constructor(name: string, dsm: ServerManager, env: LocalEnvironment, serverPath: string, worldBackupContainerFolder: IFolder);
    get worldStoragePath(): string;
    pushUpdates(additionalUpdates: any[]): void;
    get gameTest(): string;
    set gameTest(newGameTest: string);
    get status(): DedicatedServerStatus;
    get onServerStarting(): import("ste-events").IEvent<DedicatedServer, string>;
    get onServerStopping(): import("ste-events").IEvent<DedicatedServer, string>;
    get onServerStopped(): import("ste-events").IEvent<DedicatedServer, string>;
    get onServerRefreshed(): import("ste-events").IEvent<DedicatedServer, string>;
    get onServerOutput(): import("ste-events").IEvent<DedicatedServer, ServerMessage>;
    get onServerGameEvent(): import("ste-events").IEvent<DedicatedServer, object>;
    get onServerError(): import("ste-events").IEvent<DedicatedServer, string>;
    get onServerStarted(): import("ste-events").IEvent<DedicatedServer, string>;
    get onTestStarted(): import("ste-events").IEvent<DedicatedServer, string>;
    get onTestFailed(): import("ste-events").IEvent<DedicatedServer, string>;
    get onTestSucceeded(): import("ste-events").IEvent<DedicatedServer, string>;
    get onPlayerConnected(): import("ste-events").IEvent<DedicatedServer, Player>;
    get onPlayerDisconnected(): import("ste-events").IEvent<DedicatedServer, Player>;
    get onDebugConnected(): import("ste-events").IEvent<DedicatedServer, IDebugSessionInfo>;
    get onDebugDisconnected(): import("ste-events").IEvent<DedicatedServer, string>;
    get onDebugStats(): import("ste-events").IEvent<DedicatedServer, {
        tick: number;
        stats: IStatData[];
    }>;
    get onDebugPaused(): import("ste-events").IEvent<DedicatedServer, string>;
    get onDebugResumed(): import("ste-events").IEvent<DedicatedServer, void>;
    get onProfilerCapture(): import("ste-events").IEvent<DedicatedServer, IProfilerCaptureEvent>;
    get debugClient(): MinecraftDebugClient;
    get debuggerEnabled(): boolean;
    set debuggerEnabled(value: boolean);
    get debuggerStreamingEnabled(): boolean;
    set debuggerStreamingEnabled(value: boolean);
    /**
     * Get the managed world ID for this server.
     * If set, backups will use the WorldBackupManager system.
     */
    get managedWorldId(): string | undefined;
    /**
     * Set the managed world ID for this server.
     * @param worldId The world ID from WorldBackupManager, or undefined to use legacy backups
     */
    set managedWorldId(worldId: string | undefined);
    /**
     * Get the last backup result.
     */
    get lastBackupResult(): IBackupResult | undefined;
    handleCommandRequest(event: string, data: string): void;
    runActionSet(actionSet: IActionSetData, requestId?: string): Promise<void>;
    waitUntilStarted(): Promise<void>;
    runCommandImmediate(command: string, tokenId?: string, maxWaitMs?: number): Promise<string | undefined>;
    runCommand(command: string, requestId?: string, isInternal?: boolean): Promise<void>;
    /**
     * Run an internal command that doesn't show in logs.
     * Used for implementation details like querytarget polling.
     */
    runInternalCommand(command: string, requestId?: string): Promise<void>;
    writeToServer(commandLine: string): Promise<void>;
    ensureServerFolders(): Promise<void>;
    restoreLatestBackupWorld(): Promise<boolean>;
    /**
     * Restore the latest backup using the new WorldBackupManager system.
     */
    private restoreManagedWorld;
    applyWorldSettings(mcworld: MCWorld, startInfo?: IMinecraftStartMessage): Promise<void>;
    getStorageFromPath(path: string): Promise<IStorage | undefined>;
    ensureWorld(startInfo?: IMinecraftStartMessage): Promise<void>;
    ensureContentDeployed(startInfo?: IMinecraftStartMessage): Promise<void>;
    startServer(restartIfAlreadyRunning: boolean, start: IMinecraftServerStart | undefined): Promise<void>;
    executeNextCommand(): Promise<void>;
    doRunningBackup(): Promise<void>;
    doBackup(backupFileLine?: string): Promise<void>;
    /**
     * Create a backup using the new WorldBackupManager system.
     * This provides better organization, deduplication, and export capabilities.
     */
    private doManagedBackup;
    stopServer(): Promise<void>;
    private static readonly PID_FILE_NAME;
    /**
     * Kill stale bedrock_server processes left over from a previous crash.
     * Uses a PID file in the slot directory instead of platform-specific process
     * enumeration tools (wmic, PowerShell, pgrep), keeping this pure Node.js.
     */
    private _killStaleProcesses;
    private _writePidFile;
    private _removePidFile;
    private handleClose;
    private getRecentStarts;
    continueStopServer(): Promise<void>;
    finalizeStopServer(): Promise<void>;
    deploy(fromFolder: IFolder, isPatch: boolean, isReloadable?: boolean): Promise<void>;
    directOutput(readable: Readable): Promise<void>;
    handleServerStarted(line: string): void;
    /**
     * Connect to the Minecraft script debugger.
     * The server should already be listening on the debug port after
     * receiving the "script debugger listen <port>" command.
     */
    connectDebugClient(): Promise<void>;
    /**
     * Disconnect the debug client if connected.
     */
    disconnectDebugClient(): void;
    /**
     * Start polling for player positions.
     * Uses /querytarget @a to get all player positions periodically.
     */
    startPlayerPositionPolling(): void;
    /**
     * Stop player position polling.
     */
    stopPlayerPositionPolling(): void;
    /**
     * Get player name from uniqueId by looking up connected players.
     */
    getPlayerNameFromId(uniqueId: string): string | undefined;
    handlePlayerConnected(player: Player): void;
    handlePlayerDisconnected(player: Player): void;
    getTestIdFromLine(line: string): string;
    getPlayerIdFromLine(line: string): string;
    getPlayerXuidFromLine(line: string): string;
    directErrors(readable: Readable): Promise<void>;
}