import { Tool, JSONToolOutput, BaseToolOptions, BaseToolRunOptions, ToolEmitter, ToolInput } from '../base.cjs';
import { z } from 'zod';
import { RunContext } from '../../context.cjs';
import 'ajv';
import '../../errors.cjs';
import '../../internals/types.cjs';
import '../../internals/helpers/guards.cjs';
import '../../internals/serializable.cjs';
import 'promise-based-task';
import '../../cache/base.cjs';
import '../../internals/helpers/schema.cjs';
import 'zod-to-json-schema';
import '../../emitter-D4OcelZ9.cjs';
import '../../internals/helpers/promise.cjs';

/**
 * Copyright 2025 © BeeAI a Series of LF Projects, LLC
 * SPDX-License-Identifier: Apache-2.0
 */

interface ResponseFilter {
    excludedKeys: (keyof OpenMeteoToolResponse)[];
}
interface ToolOptions extends BaseToolOptions {
    apiKey?: string;
    responseFilter?: ResponseFilter;
}
type ToolRunOptions = BaseToolRunOptions;
interface LocationSearch {
    name: string;
    country?: string;
    language?: string;
}
interface OpenMeteoToolResponse {
    latitude?: number;
    longitude?: number;
    generationtime_ms?: number;
    utc_offset_seconds?: number;
    timezone?: string;
    timezone_abbreviation?: string;
    elevation?: number;
    current_units?: Record<string, string>;
    current?: Record<string, string>;
    hourly_units?: Record<string, string>;
    hourly?: Record<string, any[]>;
    daily_units?: Record<string, string>;
    daily?: Record<string, any[]>;
}
declare class OpenMeteoToolOutput extends JSONToolOutput<OpenMeteoToolResponse> {
}
declare class OpenMeteoTool extends Tool<OpenMeteoToolOutput, ToolOptions, ToolRunOptions> {
    name: string;
    description: string;
    inputSchema(): z.ZodObject<{
        location: z.ZodUnion<[z.ZodObject<{
            name: z.ZodString;
            country: z.ZodOptional<z.ZodString>;
            language: z.ZodDefault<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            name: string;
            language: string;
            country?: string | undefined;
        }, {
            name: string;
            country?: string | undefined;
            language?: string | undefined;
        }>, z.ZodObject<{
            latitude: z.ZodNumber;
            longitude: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            latitude: number;
            longitude: number;
        }, {
            latitude: number;
            longitude: number;
        }>]>;
        start_date: z.ZodString;
        end_date: z.ZodOptional<z.ZodString>;
        temperature_unit: z.ZodDefault<z.ZodEnum<["celsius", "fahrenheit"]>>;
    }, "strip", z.ZodTypeAny, {
        location: {
            name: string;
            language: string;
            country?: string | undefined;
        } | {
            latitude: number;
            longitude: number;
        };
        start_date: string;
        temperature_unit: "celsius" | "fahrenheit";
        end_date?: string | undefined;
    }, {
        location: {
            name: string;
            country?: string | undefined;
            language?: string | undefined;
        } | {
            latitude: number;
            longitude: number;
        };
        start_date: string;
        end_date?: string | undefined;
        temperature_unit?: "celsius" | "fahrenheit" | undefined;
    }>;
    readonly emitter: ToolEmitter<ToolInput<this>, OpenMeteoToolOutput>;
    constructor(options?: Partial<ToolOptions>);
    protected preprocessInput(rawInput: unknown): void;
    protected _run({ location, start_date: startDate, end_date: endDate, ...input }: ToolInput<this>, _options: Partial<BaseToolRunOptions>, run: RunContext<this>): Promise<OpenMeteoToolOutput>;
    protected _geocode(location: LocationSearch, signal: AbortSignal): Promise<any>;
}

export { OpenMeteoTool, OpenMeteoToolOutput, type OpenMeteoToolResponse, type ResponseFilter };