@kzheart_/mc-pilot 0.1.0

package/dist/commands/request-helpers.d.ts

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import type { CommandContext, GlobalOptions } from "../util/context.js";
+export interface RequestPayload<TOptions> {
+    args: string[];
+    options: TOptions;
+    globalOptions: GlobalOptions;
+}
+export declare function sendClientRequest(context: CommandContext, clientName: string | undefined, action: string, params: Record<string, unknown>, timeoutSeconds?: number): Promise<unknown>;
+export declare function createRequestAction<TOptions = Record<string, any>>(action: string, buildParams: (payload: RequestPayload<TOptions>) => Record<string, unknown>, timeoutSelector?: (payload: RequestPayload<TOptions>, context: CommandContext) => number | undefined): (this: Command, ...input: unknown[]) => Promise<void>;
+export declare function parseJson(text: string, fieldName: string): Record<string, unknown>;
+export declare function parseNumberList(text: string): number[];
+export declare function withTransportTimeoutBuffer(requestedTimeout: number | undefined, fallbackTimeout: number): number;
+export declare function buildEntityFilter(options: {
+    type?: string;
+    name?: string;
+    nearest?: boolean;
+    id?: number;
+    maxDistance?: number;
+}): {
+    type: string | undefined;
+    name: string | undefined;
+    nearest: boolean | undefined;
+    id: number | undefined;
+    maxDistance: number | undefined;
+};
+export declare function command(name: string, description: string): Command;

package/dist/commands/request-helpers.js

@@ -0,0 +1,58 @@
+import { Command } from "commander";
+import { ClientManager } from "../client/ClientManager.js";
+import { WebSocketClient } from "../client/WebSocketClient.js";
+import { MctError } from "../util/errors.js";
+import { wrapCommand } from "../util/command.js";
+export async function sendClientRequest(context, clientName, action, params, timeoutSeconds) {
+    const manager = new ClientManager(context);
+    const client = await manager.getClient(clientName);
+    const ws = new WebSocketClient(manager.getWsUrl(client.wsPort));
+    return ws.send(action, params, timeoutSeconds ?? context.config.timeout.default);
+}
+export function createRequestAction(action, buildParams, timeoutSelector) {
+    return wrapCommand(async (context, payload) => {
+        const timeout = timeoutSelector?.(payload, context);
+        return sendClientRequest(context, payload.globalOptions.client, action, buildParams(payload), timeout);
+    });
+}
+export function parseJson(text, fieldName) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new MctError({
+            code: "INVALID_PARAMS",
+            message: `${fieldName} must be valid JSON`
+        }, 4);
+    }
+}
+export function parseNumberList(text) {
+    return text
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => Number(value));
+}
+export function withTransportTimeoutBuffer(requestedTimeout, fallbackTimeout) {
+    const effectiveTimeout = requestedTimeout ?? fallbackTimeout;
+    return Math.max(effectiveTimeout + 10, fallbackTimeout);
+}
+export function buildEntityFilter(options) {
+    const filter = {
+        type: options.type,
+        name: options.name,
+        nearest: options.nearest,
+        id: options.id,
+        maxDistance: options.maxDistance
+    };
+    if (!filter.type && !filter.name && !filter.nearest && !filter.id && !filter.maxDistance) {
+        throw new MctError({
+            code: "INVALID_PARAMS",
+            message: "At least one entity filter option is required"
+        }, 4);
+    }
+    return filter;
+}
+export function command(name, description) {
+    return new Command(name).description(description);
+}

package/dist/commands/resourcepack.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createResourcepackCommand(): Command;

package/dist/commands/resourcepack.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createResourcepackCommand() {
+    const command = new Command("resourcepack").description("Resource pack operations");
+    command.command("status").description("Get resource pack status").action(createRequestAction("resourcepack.status", () => ({})));
+    command.command("accept").description("Accept the pending resource pack").action(createRequestAction("resourcepack.accept", () => ({})));
+    command.command("reject").description("Reject the pending resource pack").action(createRequestAction("resourcepack.reject", () => ({})));
+    return command;
+}

package/dist/commands/rotation.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createRotationCommand(): Command;

package/dist/commands/rotation.js

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createRotationCommand() {
+    const command = new Command("rotation").description("View direction query");
+    command.command("get").description("Get current view direction (yaw, pitch)").action(createRequestAction("rotation.get", () => ({})));
+    return command;
+}

package/dist/commands/screen.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createScreenCommand(): Command;

package/dist/commands/screen.js

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createScreenCommand() {
+    const command = new Command("screen").description("Screen info");
+    command.command("size").description("Get screen dimensions (width, height)").action(createRequestAction("screen.size", () => ({})));
+    return command;
+}

package/dist/commands/screenshot.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createScreenshotCommand(): Command;

package/dist/commands/screenshot.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createScreenshotCommand() {
+    return new Command("screenshot")
+        .description("Take a screenshot")
+        .requiredOption("--output <path>", "Output file path (e.g. ./screenshots/test.png)")
+        .option("--region <region>", "Capture a sub-region, format: x,y,w,h")
+        .option("--gui", "Capture the current GUI screen")
+        .action(createRequestAction("capture.screenshot", ({ options }) => ({
+        output: options.output,
+        region: options.region,
+        gui: Boolean(options.gui)
+    })));
+}

package/dist/commands/server.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createServerCommand(): Command;

package/dist/commands/server.js

@@ -0,0 +1,66 @@
+import { Command } from "commander";
+import { buildServerSearchResults } from "../download/SearchCommand.js";
+import { downloadServerJar } from "../download/server/ServerDownloader.js";
+import { wrapCommand } from "../util/command.js";
+import { ServerManager } from "../server/ServerManager.js";
+export function createServerCommand() {
+    const command = new Command("server").description("Manage Minecraft server");
+    command
+        .command("search")
+        .description("Search available server versions")
+        .option("--type <type>", "Server type: vanilla|paper|purpur|spigot")
+        .option("--version <version>", "Minecraft version")
+        .action(wrapCommand(async (_context, { options }) => {
+        return {
+            results: buildServerSearchResults({
+                type: options.type,
+                version: options.version
+            })
+        };
+    }));
+    command
+        .command("download")
+        .description("Download server jar and update config")
+        .option("--type <type>", "Server type: vanilla|paper|purpur|spigot")
+        .option("--version <version>", "Minecraft version")
+        .option("--build <build>", "Specific build number")
+        .option("--dir <path>", "Download target directory")
+        .option("--fixtures <path>", "Fixture plugin jar, auto-copied to plugins/")
+        .action(wrapCommand(async (context, { options }) => {
+        return downloadServerJar(context, options);
+    }));
+    command
+        .command("start")
+        .description("Start the server")
+        .option("--jar <path>", "Server jar path (default: from config server.jar)")
+        .option("--dir <path>", "Server directory (default: from config server.dir)")
+        .option("--port <number>", "Server port (default: 25565)", Number)
+        .option("--eula", "Auto-accept EULA")
+        .action(wrapCommand(async (context, { options }) => {
+        const manager = new ServerManager(context);
+        return manager.start(options);
+    }));
+    command
+        .command("stop")
+        .description("Stop the server")
+        .action(wrapCommand(async (context) => {
+        const manager = new ServerManager(context);
+        return manager.stop();
+    }));
+    command
+        .command("status")
+        .description("Show server status")
+        .action(wrapCommand(async (context) => {
+        const manager = new ServerManager(context);
+        return manager.status();
+    }));
+    command
+        .command("wait-ready")
+        .description("Wait until server port is connectable")
+        .option("--timeout <seconds>", "Timeout in seconds", Number)
+        .action(wrapCommand(async (context, { options }) => {
+        const manager = new ServerManager(context);
+        return manager.waitReady(options.timeout ?? context.config.timeout.serverReady);
+    }));
+    return command;
+}

package/dist/commands/sign.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createSignCommand(): Command;

package/dist/commands/sign.js

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createSignCommand() {
+    const command = new Command("sign").description("Sign block operations (reads/writes directly, no GUI interaction needed)");
+    command
+        .command("read")
+        .description("Read sign text")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .action(createRequestAction("sign.read", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2])
+    })));
+    command
+        .command("edit")
+        .description("Edit sign text")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .requiredOption("--lines <lines...>", "Four lines of text, e.g. --lines \"Line 1\" \"Line 2\" \"Line 3\" \"Line 4\"")
+        .action(createRequestAction("sign.edit", ({ args, options }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2]),
+        lines: options.lines
+    })));
+    return command;
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createStatusCommand(): Command;

package/dist/commands/status.js

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createStatusCommand() {
+    const command = new Command("status").description("Player status queries");
+    const statusLabels = {
+        health: "Get health and hunger",
+        effects: "Get active potion effects",
+        experience: "Get XP level and progress",
+        gamemode: "Get current game mode",
+        world: "Get current world info",
+        all: "Get all status at once"
+    };
+    for (const sub of ["health", "effects", "experience", "gamemode", "world", "all"]) {
+        command.command(sub).description(statusLabels[sub]).action(createRequestAction(`status.${sub}`, () => ({})));
+    }
+    return command;
+}

package/dist/commands/wait.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createWaitCommand(): Command;

package/dist/commands/wait.js

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+import { createRequestAction, withTransportTimeoutBuffer } from "./request-helpers.js";
+export function createWaitCommand() {
+    return new Command("wait")
+        .description("Wait and synchronization")
+        .argument("[seconds]", "Wait for a number of seconds")
+        .option("--ticks <ticks>", "Wait for a number of game ticks", Number)
+        .option("--until-health-above <value>", "Wait until health is above this value", Number)
+        .option("--until-gui-open", "Wait until a GUI opens")
+        .option("--until-on-ground", "Wait until the player is on the ground")
+        .option("--timeout <seconds>", "Timeout in seconds", Number)
+        .action(createRequestAction("wait.perform", ({ args, options }) => ({
+        seconds: args[0] ? Number(args[0]) : undefined,
+        ticks: options.ticks,
+        untilHealthAbove: options.untilHealthAbove,
+        untilGuiOpen: Boolean(options.untilGuiOpen),
+        untilOnGround: Boolean(options.untilOnGround),
+        timeout: options.timeout
+    }), ({ options, args }, context) => {
+        const requested = options.timeout ? Number(options.timeout) : args[0] ? Number(args[0]) : context.config.timeout.default;
+        return withTransportTimeoutBuffer(requested, context.config.timeout.default);
+    }));
+}

package/dist/download/CacheManager.d.ts

@@ -0,0 +1,20 @@
+import type { ServerType } from "./VersionMatrix.js";
+import type { LoaderType } from "./types.js";
+export declare function resolveCacheRoot(): string;
+export declare class CacheManager {
+    private readonly rootDir;
+    constructor(rootDir?: string);
+    getRootDir(): string;
+    getServerJarPath(type: ServerType, version: string, build: string): string;
+    getServerFile(type: ServerType, version: string, build: string): string;
+    getMinecraftDir(version: string): string;
+    getClientMetadataFile(scope: "version-manifest" | "minecraft-version" | "fabric-loader-profile", id: string): string;
+    getClientLibraryFile(relativePath: string): string;
+    getClientJarPath(version: string): string;
+    getClientAssetIndexPath(assetIndexId: string): string;
+    getClientAssetObjectPath(hash: string): string;
+    getClientAssetsRoot(): string;
+    getClientLoggingConfigPath(fileName: string): string;
+    getLoaderDir(loader: LoaderType): string;
+    getModFile(fileName: string): string;
+}

package/dist/download/CacheManager.js

@@ -0,0 +1,50 @@
+import os from "node:os";
+import path from "node:path";
+export function resolveCacheRoot() {
+    return process.env.MCT_CACHE_DIR || path.join(os.homedir(), ".mct", "cache");
+}
+export class CacheManager {
+    rootDir;
+    constructor(rootDir = resolveCacheRoot()) {
+        this.rootDir = rootDir;
+    }
+    getRootDir() {
+        return this.rootDir;
+    }
+    getServerJarPath(type, version, build) {
+        return path.join(this.rootDir, "server", type, `${version}-${build}.jar`);
+    }
+    getServerFile(type, version, build) {
+        return this.getServerJarPath(type, version, build);
+    }
+    getMinecraftDir(version) {
+        return path.join(this.rootDir, "client", "minecraft", version);
+    }
+    getClientMetadataFile(scope, id) {
+        return path.join(this.rootDir, "client", "metadata", scope, `${id}.json`);
+    }
+    getClientLibraryFile(relativePath) {
+        return path.join(this.rootDir, "client", "libraries", relativePath);
+    }
+    getClientJarPath(version) {
+        return path.join(this.rootDir, "client", "jars", `minecraft-client-${version}.jar`);
+    }
+    getClientAssetIndexPath(assetIndexId) {
+        return path.join(this.rootDir, "client", "assets", "indexes", `${assetIndexId}.json`);
+    }
+    getClientAssetObjectPath(hash) {
+        return path.join(this.rootDir, "client", "assets", "objects", hash.slice(0, 2), hash);
+    }
+    getClientAssetsRoot() {
+        return path.join(this.rootDir, "client", "assets");
+    }
+    getClientLoggingConfigPath(fileName) {
+        return path.join(this.rootDir, "client", "logging", fileName);
+    }
+    getLoaderDir(loader) {
+        return path.join(this.rootDir, "client", loader);
+    }
+    getModFile(fileName) {
+        return path.join(this.rootDir, "mod", fileName);
+    }
+}

package/dist/download/DownloadUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function copyFileIfMissing(sourcePath: string, targetPath: string): Promise<void>;
+export declare function downloadFile(url: string, targetPath: string, fetchImpl?: typeof fetch): Promise<void>;

package/dist/download/DownloadUtils.js

@@ -0,0 +1,23 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { MctError } from "../util/errors.js";
+export async function copyFileIfMissing(sourcePath, targetPath) {
+    const content = await readFile(sourcePath);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, content);
+}
+export async function downloadFile(url, targetPath, fetchImpl = fetch) {
+    const response = await fetchImpl(url);
+    if (!response.ok) {
+        throw new MctError({
+            code: "DOWNLOAD_FAILED",
+            message: `Failed to download ${url}`,
+            details: {
+                status: response.status
+            }
+        }, 2);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, Buffer.from(arrayBuffer));
+}

package/dist/download/JavaDetector.d.ts

@@ -0,0 +1,7 @@
+export interface JavaDetectionResult {
+    available: boolean;
+    command: string;
+    majorVersion?: number;
+}
+export declare function parseJavaMajorVersion(output: string): number | undefined;
+export declare function detectJava(command?: string): Promise<JavaDetectionResult>;

package/dist/download/JavaDetector.js

@@ -0,0 +1,31 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export function parseJavaMajorVersion(output) {
+    const match = output.match(/version "(?<version>[^"]+)"/);
+    if (!match?.groups?.version) {
+        return undefined;
+    }
+    const [first, second] = match.groups.version.split(".");
+    if (first === "1" && second) {
+        return Number.parseInt(second, 10);
+    }
+    return Number.parseInt(first, 10);
+}
+export async function detectJava(command = "java") {
+    try {
+        const result = await execFileAsync(command, ["-version"]);
+        const output = `${result.stdout}\n${result.stderr}`;
+        return {
+            available: true,
+            command,
+            majorVersion: parseJavaMajorVersion(output)
+        };
+    }
+    catch {
+        return {
+            available: false,
+            command
+        };
+    }
+}

package/dist/download/ModVariantCatalog.d.ts

@@ -0,0 +1,10 @@
+import type { ModVariantCatalog, ModVariant } from "./types.js";
+export declare function loadModVariantCatalog(filePath?: string): Promise<ModVariantCatalog>;
+export declare function loadModVariantCatalogSync(filePath?: string): ModVariantCatalog;
+export declare function sortVariants(variants: ModVariant[]): ModVariant[];
+export declare function findVariant(catalog: ModVariantCatalog, variantId: string): ModVariant | undefined;
+export declare function getDefaultVariant(catalog: ModVariantCatalog): ModVariant | undefined;
+export declare function findVariantByVersionAndLoader(catalog: ModVariantCatalog, minecraftVersion: string, loader: ModVariant["loader"]): ModVariant | undefined;
+export declare function getBuildableFabricVariants(catalog: ModVariantCatalog): ModVariant[];
+export declare function getSupportedMinecraftVersions(catalog: ModVariantCatalog): string[];
+export declare function getModArtifactFileName(variant: ModVariant): string;

package/dist/download/ModVariantCatalog.js

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+const DEFAULT_VARIANTS_PATH = fileURLToPath(new URL("../../data/variants.json", import.meta.url));
+function compareVersions(left, right) {
+    const leftParts = left.split(".").map((value) => Number.parseInt(value, 10));
+    const rightParts = right.split(".").map((value) => Number.parseInt(value, 10));
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const delta = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (delta !== 0) {
+            return delta;
+        }
+    }
+    return 0;
+}
+export async function loadModVariantCatalog(filePath = DEFAULT_VARIANTS_PATH) {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+}
+export function loadModVariantCatalogSync(filePath = DEFAULT_VARIANTS_PATH) {
+    const raw = readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+}
+export function sortVariants(variants) {
+    return [...variants].sort((left, right) => {
+        const versionDelta = compareVersions(right.minecraftVersion, left.minecraftVersion);
+        if (versionDelta !== 0) {
+            return versionDelta;
+        }
+        return left.loader.localeCompare(right.loader);
+    });
+}
+export function findVariant(catalog, variantId) {
+    return catalog.variants.find((variant) => variant.id === variantId);
+}
+export function getDefaultVariant(catalog) {
+    return findVariant(catalog, catalog.defaultVariant);
+}
+export function findVariantByVersionAndLoader(catalog, minecraftVersion, loader) {
+    return catalog.variants.find((variant) => variant.minecraftVersion === minecraftVersion && variant.loader === loader);
+}
+export function getBuildableFabricVariants(catalog) {
+    return sortVariants(catalog.variants.filter((variant) => variant.loader === "fabric" && variant.yarnMappings && variant.fabricLoaderVersion
+        && (variant.support === "ready" || variant.support === "configured")));
+}
+export function getSupportedMinecraftVersions(catalog) {
+    return [...new Set(catalog.variants.map((variant) => variant.minecraftVersion))].sort(compareVersions).reverse();
+}
+export function getModArtifactFileName(variant) {
+    return `mct-client-mod-${variant.loader}-${variant.minecraftVersion}.jar`;
+}

package/dist/download/SearchCommand.d.ts

@@ -0,0 +1,29 @@
+import { type ClientLoader, type ServerType } from "./VersionMatrix.js";
+export interface ServerSearchCommandResult {
+    type: ServerType;
+    versions: Array<{
+        version: string;
+        build?: string;
+        requiresBuildTools?: boolean;
+    }>;
+}
+export interface ClientSearchCommandResult {
+    version: string;
+    javaVersion: string;
+    loaders: Array<{
+        loader: ClientLoader;
+        supported: boolean;
+        loaderVersion?: string;
+        modVersion?: string;
+        validation?: "verified" | "limited" | "planned";
+        notes?: string;
+    }>;
+}
+export declare function buildServerSearchResults(filter?: {
+    type?: ServerType;
+    version?: string;
+}): ServerSearchCommandResult[];
+export declare function buildClientSearchResults(filter?: {
+    loader?: ClientLoader;
+    version?: string;
+}): ClientSearchCommandResult[];

package/dist/download/SearchCommand.js

@@ -0,0 +1,37 @@
+import { searchClientVersions, searchServerVersions } from "./VersionMatrix.js";
+export function buildServerSearchResults(filter) {
+    const grouped = new Map();
+    for (const entry of searchServerVersions(filter).filter((item) => item.supported)) {
+        const current = grouped.get(entry.type) ?? {
+            type: entry.type,
+            versions: []
+        };
+        current.versions.push({
+            version: entry.minecraftVersion,
+            ...(entry.latestBuild != null ? { build: String(entry.latestBuild) } : {}),
+            ...(entry.requiresBuildTools ? { requiresBuildTools: true } : {})
+        });
+        grouped.set(entry.type, current);
+    }
+    return [...grouped.values()];
+}
+export function buildClientSearchResults(filter) {
+    const grouped = new Map();
+    for (const entry of searchClientVersions(filter)) {
+        const current = grouped.get(entry.minecraftVersion) ?? {
+            version: entry.minecraftVersion,
+            javaVersion: entry.javaVersion,
+            loaders: []
+        };
+        current.loaders.push({
+            loader: entry.loader,
+            supported: entry.supported,
+            ...(entry.loaderVersion ? { loaderVersion: entry.loaderVersion } : {}),
+            ...(entry.modVersion ? { modVersion: entry.modVersion } : {}),
+            ...(entry.validation ? { validation: entry.validation } : {}),
+            ...(entry.notes ? { notes: entry.notes } : {})
+        });
+        grouped.set(entry.minecraftVersion, current);
+    }
+    return [...grouped.values()];
+}

package/dist/download/VersionMatrix.d.ts

@@ -0,0 +1,72 @@
+export type ServerType = "paper" | "purpur" | "spigot" | "vanilla";
+export type ClientLoader = "fabric" | "forge" | "neoforge";
+export interface ServerSupportInfo {
+    supported: boolean;
+    latestBuild?: number;
+    requiresBuildTools?: boolean;
+}
+export interface ClientLoaderSupportInfo {
+    supported: boolean;
+    loaderVersion?: string;
+    modVersion?: string;
+    validation?: "verified" | "limited" | "planned";
+    notes?: string;
+}
+export interface MinecraftSupportEntry {
+    minecraftVersion: string;
+    javaVersion: string;
+    servers: Record<ServerType, ServerSupportInfo>;
+    clients: Record<ClientLoader, ClientLoaderSupportInfo>;
+}
+export interface ServerSearchResult {
+    type: ServerType;
+    minecraftVersion: string;
+    supported: boolean;
+    latestBuild?: number;
+    requiresBuildTools?: boolean;
+}
+export interface ServerCatalogEntry {
+    version: string;
+    build?: string;
+    requiresBuildTools?: boolean;
+}
+export interface ClientSearchResult {
+    loader: ClientLoader;
+    minecraftVersion: string;
+    supported: boolean;
+    loaderVersion?: string;
+    modVersion?: string;
+    validation?: "verified" | "limited" | "planned";
+    notes?: string;
+    javaVersion: string;
+}
+export declare function getVersionMatrix(): {
+    minecraftVersion: string;
+    javaVersion: string;
+    servers: {
+        paper: ServerSupportInfo;
+        purpur: ServerSupportInfo;
+        spigot: ServerSupportInfo;
+        vanilla: ServerSupportInfo;
+    };
+    clients: {
+        fabric: ClientLoaderSupportInfo;
+        forge: ClientLoaderSupportInfo;
+        neoforge: ClientLoaderSupportInfo;
+    };
+}[];
+export declare function getSupportedMinecraftVersions(): string[];
+export declare function getMinecraftSupport(version: string): MinecraftSupportEntry | undefined;
+export declare function searchServerVersions(filter?: {
+    type?: ServerType;
+    version?: string;
+}): ServerSearchResult[];
+export declare function searchClientVersions(filter?: {
+    loader?: ClientLoader;
+    version?: string;
+}): ClientSearchResult[];
+export declare function getServerVersionMatrix(): ServerSearchResult[];
+export declare function getClientVersionMatrix(): ClientSearchResult[];
+export declare function getServerVersionCatalog(): Record<ServerType, ServerCatalogEntry[]>;
+export declare function getServerTypes(): ServerType[];
+export declare function getClientLoaders(): ClientLoader[];