import type { MapView, Directions, TNavigationOptions, TAddMarkerOptions, TStateChangedInternalPayload, Image3D, Shapes, Models, Markers, Labels, Camera, Text3D, Style, Outdoor, Paths } from '@mappedin/mappedin-js';
import type { UseBridgeHook } from '../hooks/use-bridge.js';
import type { Mappedin } from '../types.js';
import type { EventControl } from './event-control.js';
/**
 * Configuration for a navigation marker's template and display options.
 *
 * @example
 * ```typescript
 * // Basic distance marker
 * {
 *   template: 'Distance: {{instruction.distance}}m',
 *   options: { interactive: true, rank: 'high' }
 * }
 *
 * // Turn instruction marker
 * {
 *   template: 'Turn {{instruction.action.bearing}} in {{instruction.distance}}m',
 *   options: { rank: 'medium' }
 * }
 * ```
 */
export type NavigationMarkerConfig = {
    /**
     * Handlebars templates receive objects with an 'instruction' property containing TDirectionInstruction data. @see {@link TDirectionInstruction} in @mappedin/mappedin-js for full type details
     *
     * @example
     * ```typescript
     * {
     *   template: '<div>Turn {{instruction.action.bearing}} in {{instruction.distance}}m</div>',
     * }
     */
    template?: string;
    /** Optional configuration for marker behavior */
    options?: TAddMarkerOptions;
};
/**
 * Extended navigation options that support configurable markers.
 *
 * Example:
 * ```typescript
 * createMarkers: {
 *   departure: {
 *     template: 'Departure: {{instruction.action.type}}',
 *     options: { interactive: true }
 *   },
 *   destination: {
 *     template: 'Destination: {{instruction.action.type}}',
 *     options: { rank: 'medium' }
 *   },
 *   connection: false // Disable connection markers.
 * }
 * ```
 */
export type ExtendedNavigationOptions = Omit<TNavigationOptions, 'createMarkers'> & {
    createMarkers?: {
        /** Departure marker configuration or boolean to enable/disable */
        departure?: NavigationMarkerConfig | boolean;
        /** Destination marker configuration or boolean to enable/disable */
        destination?: NavigationMarkerConfig | boolean;
        /** Connection marker configuration or boolean to enable/disable */
        connection?: NavigationMarkerConfig | boolean;
    };
};
/**
 * Utility type that converts all methods in a given type to return Promises.
 * Used in MapViewControl to wrap synchronous MapView methods for async bridge communication.
 *
 * @template T - The type to promisify
 *
 * @example
 * ```typescript
 * // Original synchronous API
 * interface TextAPI {
 *   label(space: Space): Text3D;
 *   remove(text: Text3D): void;
 * }
 *
 * // Promisified version
 * type AsyncTextAPI = Promisify<TextAPI>;
 * // Results in:
 * // {
 * //   label(space: Space): Promise<Text3D>;
 * //   remove(text: Text3D): Promise<void>;
 * // }
 * ```
 *
 * @remarks
 * TypeScript's type system has limitations with complex generic transformations.
 * The basic Promisify works well for simple cases but struggles with:
 * - Function overloads - only the last overload signature is preserved
 * - Generic functions with conditional return types - type information is lost
 * - Complex generic constraints - requires manual type definitions
 */
export type Promisify<T> = {
    [K in keyof T]: T[K] extends (...args: infer Args) => infer Return ? Return extends Promise<any> ? T[K] : (...args: Args) => Promise<Return> : T[K] extends object ? Promisify<T[K]> : T[K];
};
/**
 * Extended navigation with custom marker templates
 *
 * @see {@link ExtendedNavigationOptions} for more information on the options
 *
 * @interface
 */
export type Navigation = {
    draw(directions: Directions | Directions[], options?: ExtendedNavigationOptions): Promise<void>;
} & Omit<MapView['Navigation'], 'draw'>;
type MapViewMethods = Omit<MapView, 'on' | 'off' | 'emit' | '__core' | 'then' | 'catch' | 'finally' | 'valueOf' | 'toString' | 'toJSON' | typeof Symbol.toPrimitive | typeof Symbol.toStringTag> & {
    /**
     * Internal method used by useEvent hook to call the bridge.
     *
     * @remarks
     * This method is used by useEvent hook to call the bridge.
     * It is not part of the public API and should not be used directly.
     *
     * @internal
     */
    _bridgeCall: UseBridgeHook['instruct'];
};
/**
 * A proxy that intercepts {@link MapView} method calls and forwards them through the bridge to the WebView.
 * All method calls are converted to asynchronous bridge instructions.
 *
 * This interface provides access to all MapView methods and properties in an async manner,
 * with specialized handling for Navigation and updateState methods.
 *
 * **Key Properties:**
 * - `updateState` - Async wrapper for updating entity states with type safety
 * - `Navigation` - Extended navigation with custom marker templates
 * - `on` - Subscribe to map events
 * - `off` - Unsubscribe from map events
 * - `destroy` - Clean up resources and event subscriptions
 * - All other MapView methods are available as async calls
 *
 * @example Basic Usage
 * ```typescript
 * // All MapView methods are available as async calls
 * await mapView.setFloor('floor-id');
 * await mapView.Camera.focusOn(target, options);
 * await mapView.Labels.add(coordinate, content);
 *
 * // Navigation with custom markers
 * await mapView.Navigation.draw(directions, {
 *   createMarkers: {
 *     connection: { template: '<div>{{instruction.action.type}}</div>', options: { rank: 'always-visible' } }
 *   }
 * });
 *
 * // Event handling
 * mapView.on('click', handler);
 * mapView.off('click', handler);
 *
 * // Cleanup when unmounting
 * mapView.destroy();
 * ```
 *
 * @interface
 */
export type MapViewControl = Omit<Promisify<MapViewMethods>, 'Navigation' | 'Text3D' | 'BlueDot' | 'Camera' | 'Labels' | 'Markers' | 'Models' | 'Image3D' | 'Paths' | 'Shapes' | 'Style' | 'Outdoor'> & {
    /** Extended navigation with custom marker templates */
    Navigation: Navigation;
    /** 3D text controls with async methods */
    Text3D: Promisify<Text3D>;
    /** Camera controls with async methods */
    Camera: Promisify<Camera>;
    /** Label controls with async methods */
    Labels: Promisify<Labels>;
    /** Marker controls with async methods */
    Markers: Promisify<Markers>;
    /** Model controls with async methods */
    Models: Promisify<Models>;
    /** Image controls with async methods */
    Image3D: Promisify<Image3D>;
    /** Path controls with async methods */
    Paths: Promisify<Paths>;
    /** Shape controls with async methods */
    Shapes: Promisify<Shapes>;
    /** Style controls with async methods */
    Style: Promisify<Style>;
    /** Outdoor controls with async methods */
    Outdoor: Promisify<Outdoor>;
    /** Subscribe to map events */
    on: MapView['on'];
    /** Unsubscribe from map events */
    off: MapView['off'];
    /** Destroy resources, caches, and event subscriptions */
    destroy: () => Promise<void>;
    /**
     * Internal method to get cache state for testing
     * @internal
     */
    __getCacheState?: () => {
        cacheSize: number;
        propertyCacheKeys: string[];
    };
};
/**
 * Creates a typed wrapper that allows calling any method on the MapView class through the bridge.
 *
 * Features:
 * - Full TypeScript support with auto-completion
 * - Type-safe method calls with proper parameter and return type checking
 * - Supports any method call on MapView (e.g., mapView.setFloor(...))
 * - Supports namespaced methods (e.g., mapView.Camera.focusOn(...))
 * - Supports property access for direct values (e.g., mapView.currentFloor, mapView.Camera.maxZoomLevel)
 * - All methods automatically return Promises since they go through the bridge
 * - Properties return cached values directly (synchronously)
 * - Automatically stays in sync with MapView API changes
 * - Subscribes to camera-state-change events to keep camera properties in sync
 * - Extended Navigation.draw method supports custom createMarker property
 *
 * Usage examples:
 * ```typescript
 * const mapView = createMapViewControl(instruct);
 *
 * // Direct method calls with full type safety
 * await mapView.setFloor('floor-id'); // TypeScript knows the parameter type
 *
 * // Namespaced method calls with auto-completion
 * await mapView.Camera.focusOn(target, options);
 * await mapView.Labels.add(coordinate, content);
 * await mapView.Markers.add(coordinate, '<div>Marker</div>');
 *
 * // Extended Navigation.draw with custom createMarker property
 * await mapView.Navigation.draw(directions, {
 *   createMarkers: {
 *     departure: '<div>departure</div>',
 *     destination: false,
 *     connection: '<div>connection {{instruction.action.type}}</div>',
 *   },
 *   pathOptions: { color: '#ff0000' },
 *   // ... all other TNavigationOptions remain available
 * });
 *
 * // Property access returns cached values directly (no await needed)
 * const currentFloor = mapView.currentFloor; // Returns 'floor-1'
 * const maxZoom = mapView.Camera.maxZoomLevel; // Returns 1
 * const minZoom = mapView.Camera.minZoomLevel; // Returns 0.5
 *
 * // All method return types are properly typed as Promises
 * const directions = await mapView.getDirections(from, to);
 * const mapData = await mapView.getMapData();
 * ```
 *
 * @param instruct - The bridge instruction function from useBridge hook
 * @param mapData - The map data for the map view
 * @param eventControl - Optional event control instance for handling events
 * @returns A typed proxy that intercepts any method call and forwards it to the bridge
 */
export declare function createMapViewControl(instruct: UseBridgeHook['instruct'], mapData: Mappedin.MapData, eventControl: EventControl, { startInitialState }?: {
    startInitialState?: TStateChangedInternalPayload;
}): Promise<MapViewControl>;
export {};
//# sourceMappingURL=map-view-control.d.ts.map