import { type SearchResponse, type GeocodingResponse, type ReverseGeocodingResponse, type POICategoriesResponse, type RouteType } from "@tomtom-org/maps-sdk/services";
import type { Position } from "geojson";
import type { BBox, Language, Places, POICategory, Routes } from "@tomtom-org/maps-sdk/core";
interface BaseSearchOptions {
    limit?: number;
    language?: string;
    countries?: string[];
    position?: Position;
    radius?: number;
    boundingBox?: BBox;
}
interface FuzzySearchOptions extends BaseSearchOptions {
    typeahead?: boolean;
    minFuzzyLevel?: number;
    maxFuzzyLevel?: number;
    poiCategories?: POICategory[];
}
interface NearbySearchOptions {
    radius?: number;
    limit?: number;
    language?: Language;
    countries?: string[];
    poiCategories?: POICategory[];
}
/**
 * Searches for places based on a free-text query
 */
export declare function searchPlaces(query: string): Promise<SearchResponse>;
/**
 * Performs a fuzzy search for places, addresses, and POIs with advanced options
 */
export declare function fuzzySearch(query: string, options?: FuzzySearchOptions): Promise<SearchResponse>;
/**
 * Search specifically for Points of Interest (POIs)
 */
export declare function poiSearch(query: string, options?: FuzzySearchOptions): Promise<SearchResponse>;
/**
 * Geocodes an address to coordinates
 */
export declare function geocodeAddress(query: string, options?: BaseSearchOptions): Promise<GeocodingResponse>;
/**
 * Reverse geocodes coordinates to an address.
 * @param position [longitude, latitude] (GeoJSON convention)
 */
export declare function reverseGeocode(position: Position, options?: {
    language?: Language;
    radius?: number;
}): Promise<ReverseGeocodingResponse>;
/**
 * Searches for points of interest (POIs) near a location.
 * @param position [longitude, latitude] (GeoJSON convention)
 */
export declare function searchNearby(position: Position, options?: NearbySearchOptions): Promise<SearchResponse>;
/**
 * Retrieves POI categories, optionally filtered by keywords
 */
export declare function fetchPOICategories(filters?: string[]): Promise<POICategoriesResponse>;
export interface AreaSearchParams {
    query: string;
    /** Circle center as [longitude, latitude] (GeoJSON convention) */
    center?: Position;
    radius?: number;
    /** Polygon vertices as [longitude, latitude] positions */
    polygon?: Position[];
    /** Bounding box as [[topLeftLon, topLeftLat], [bottomRightLon, bottomRightLat]] */
    boundingBox?: [Position, Position];
    limit?: number;
    poiCategories?: POICategory[];
    language?: string;
    countries?: string[];
}
/**
 * Search for POIs within a geometric area.
 *
 * Supports three geometry types:
 * 1. Circle (center + radius) — most common
 * 2. Polygon (array of vertices) — custom areas
 * 3. Bounding box ([[topLeftLon, topLeftLat], [bottomRightLon, bottomRightLat]]) — rectangular areas
 *
 * Uses SDK's search() with the specified geometry.
 */
export declare function searchInArea(params: AreaSearchParams): Promise<SearchResponse>;
export interface EVSearchParams {
    query?: string;
    /** Center position as [longitude, latitude] (GeoJSON convention) */
    position: Position;
    radius?: number;
    connectorTypes?: string[];
    minPowerKW?: number;
    limit?: number;
    includeAvailability?: boolean;
    language?: string;
    countries?: string[];
}
/**
 * Search for EV charging stations using TomTom Maps SDK.
 *
 * Uses SDK's search() with poiCategories filter for EV stations,
 * then enriches results with real-time availability via getPlacesWithEVAvailability().
 */
export declare function searchEVStations(params: EVSearchParams): Promise<Places>;
export interface SearchAlongRouteResult {
    route: Routes;
    pois: SearchResponse;
    summary: {
        routeLengthMeters: number | undefined;
        routeTravelTimeSeconds: number | undefined;
        poiCount: number;
        corridorWidthMeters: number;
    };
}
export interface SearchAlongRouteParams {
    /** Route origin as [longitude, latitude] (GeoJSON convention) */
    origin: Position;
    /** Route destination as [longitude, latitude] (GeoJSON convention) */
    destination: Position;
    query: string;
    corridorWidth?: number;
    limit?: number;
    poiCategories?: POICategory[];
    language?: string;
    routeType?: RouteType;
}
/**
 * Search for POIs along a route corridor.
 *
 * Two-step process using SDK:
 * 1. calculateRoute() to get the route LineString geometry
 * 2. search() with the route geometry as a search corridor
 */
export declare function searchAlongRoute(params: SearchAlongRouteParams): Promise<SearchAlongRouteResult>;
export {};