import { z } from 'zod';
import { PubSub } from '../engine/pubsub.js';
import { SessionContext } from './types.js';
export declare function setWorldPubSub(instance: PubSub): void;
export declare const Tools: {
    readonly GENERATE_WORLD: {
        readonly name: "generate_world";
        readonly description: "Generate a new procedural RPG world with seed, width, and height parameters. Example: { \"seed\": \"atlas\", \"width\": 50, \"height\": 50 }";
        readonly inputSchema: z.ZodObject<{
            seed: z.ZodString;
            width: z.ZodNumber;
            height: z.ZodNumber;
            landRatio: z.ZodOptional<z.ZodNumber>;
            temperatureOffset: z.ZodOptional<z.ZodNumber>;
            moistureOffset: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            seed: string;
            width: number;
            height: number;
            landRatio?: number | undefined;
            temperatureOffset?: number | undefined;
            moistureOffset?: number | undefined;
        }, {
            seed: string;
            width: number;
            height: number;
            landRatio?: number | undefined;
            temperatureOffset?: number | undefined;
            moistureOffset?: number | undefined;
        }>;
    };
    readonly GET_WORLD_STATE: {
        readonly name: "get_world_state";
        readonly description: "Retrieves the current state of the generated world.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
        }, {
            worldId: string;
        }>;
    };
    readonly APPLY_MAP_PATCH: {
        readonly name: "apply_map_patch";
        readonly description: "Apply DSL commands to modify the world map. Use find_valid_poi_location first for structure placement. Example: { \"worldId\": \"id\", \"script\": \"ADD_STRUCTURE...\" }";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
            script: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
            script: string;
        }, {
            worldId: string;
            script: string;
        }>;
    };
    readonly GET_WORLD_MAP_OVERVIEW: {
        readonly name: "get_world_map_overview";
        readonly description: "Returns a high-level overview of the world including biome distribution and statistics.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
        }, {
            worldId: string;
        }>;
    };
    readonly GET_REGION_MAP: {
        readonly name: "get_region_map";
        readonly description: "Returns detailed information about a specific region including its tiles and structures.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
            regionId: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
            regionId: number;
        }, {
            worldId: string;
            regionId: number;
        }>;
    };
    readonly GET_WORLD_TILES: {
        readonly name: "get_world_tiles";
        readonly description: "Returns the full tile grid for rendering the world map. Includes biome, elevation, region, and river data for visualization.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
        }, {
            worldId: string;
        }>;
    };
    readonly PREVIEW_MAP_PATCH: {
        readonly name: "preview_map_patch";
        readonly description: "Previews what a DSL patch script would do without applying it to the world.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
            script: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
            script: string;
        }, {
            worldId: string;
            script: string;
        }>;
    };
    readonly FIND_VALID_POI_LOCATION: {
        readonly name: "find_valid_poi_location";
        readonly description: "Find terrain-valid locations for placing a POI/structure. Returns ranked candidates by suitability.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
            poiType: z.ZodEnum<["city", "town", "village", "castle", "ruins", "dungeon", "temple"]>;
            nearWater: z.ZodOptional<z.ZodBoolean>;
            preferredBiomes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            avoidExistingPOIs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            minDistanceFromPOI: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            regionId: z.ZodOptional<z.ZodNumber>;
            count: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
            count: number;
            poiType: "village" | "dungeon" | "city" | "town" | "castle" | "ruins" | "temple";
            avoidExistingPOIs: boolean;
            minDistanceFromPOI: number;
            regionId?: number | undefined;
            nearWater?: boolean | undefined;
            preferredBiomes?: string[] | undefined;
        }, {
            worldId: string;
            poiType: "village" | "dungeon" | "city" | "town" | "castle" | "ruins" | "temple";
            count?: number | undefined;
            regionId?: number | undefined;
            nearWater?: boolean | undefined;
            preferredBiomes?: string[] | undefined;
            avoidExistingPOIs?: boolean | undefined;
            minDistanceFromPOI?: number | undefined;
        }>;
    };
    readonly SUGGEST_POI_LOCATIONS: {
        readonly name: "suggest_poi_locations";
        readonly description: "Batch suggest locations for multiple POI types at once. Returns DSL script for easy application.";
        readonly inputSchema: z.ZodObject<{
            worldId: z.ZodString;
            requests: z.ZodArray<z.ZodObject<{
                poiType: z.ZodEnum<["city", "town", "village", "castle", "ruins", "dungeon", "temple"]>;
                count: z.ZodDefault<z.ZodNumber>;
                nearWater: z.ZodOptional<z.ZodBoolean>;
                preferredBiomes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                count: number;
                poiType: "village" | "dungeon" | "city" | "town" | "castle" | "ruins" | "temple";
                nearWater?: boolean | undefined;
                preferredBiomes?: string[] | undefined;
            }, {
                poiType: "village" | "dungeon" | "city" | "town" | "castle" | "ruins" | "temple";
                count?: number | undefined;
                nearWater?: boolean | undefined;
                preferredBiomes?: string[] | undefined;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            worldId: string;
            requests: {
                count: number;
                poiType: "village" | "dungeon" | "city" | "town" | "castle" | "ruins" | "temple";
                nearWater?: boolean | undefined;
                preferredBiomes?: string[] | undefined;
            }[];
        }, {
            worldId: string;
            requests: {
                poiType: "village" | "dungeon" | "city" | "town" | "castle" | "ruins" | "temple";
                count?: number | undefined;
                nearWater?: boolean | undefined;
                preferredBiomes?: string[] | undefined;
            }[];
        }>;
    };
};
export declare function handleGenerateWorld(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
export declare function handleGetWorldState(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
export declare function handleApplyMapPatch(args: unknown, ctx: SessionContext): Promise<{
    isError: boolean;
    content: {
        type: "text";
        text: string;
    }[];
} | {
    content: {
        type: "text";
        text: string;
    }[];
    isError?: undefined;
}>;
export declare function handleGetWorldMapOverview(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
export declare function handleGetRegionMap(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
export declare function handleGetWorldTiles(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
export declare function handlePreviewMapPatch(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
/**
 * Find valid POI locations based on terrain and preferences
 */
export declare function handleFindValidPoiLocation(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
/**
 * Batch suggest POI locations
 */
export declare function handleSuggestPoiLocations(args: unknown, ctx: SessionContext): Promise<{
    content: {
        type: "text";
        text: string;
    }[];
}>;
export declare function clearWorld(): void;
//# sourceMappingURL=tools.d.ts.map