import { Feature, Collection } from 'ol';
import { Vector as Vector$1 } from 'ol/layer';
import { Vector } from 'ol/source';
import { Modify } from 'ol/interaction';
import { Geometry, Point } from 'ol/geom';
import { HsEventBusService } from 'hslayers-ng/services/event-bus';
import { HsLanguageService } from 'hslayers-ng/services/language';
import { HsMapService } from 'hslayers-ng/services/map';
import { HsShareUrlService } from 'hslayers-ng/services/share';
import * as i0 from '@angular/core';
import { OnInit } from '@angular/core';
import { HsConfig } from 'hslayers-ng/config';
import * as i7 from 'hslayers-ng/common/panels';
import { HsPanelBaseComponent } from 'hslayers-ng/common/panels';
import * as i4 from '@angular/forms';
import * as i5 from '@angular/common';
import * as i6 from '@ngx-translate/core';
import * as i8 from '@ng-bootstrap/ng-bootstrap';

declare const profiles: readonly ["driving-car", "driving-hgv", "cycling-regular", "cycling-road", "cycling-mountain", "cycling-electric", "foot-walking", "foot-hiking", "wheelchair"];
type RouteProfile = (typeof profiles)[number];

type Waypoint = {
    name: string;
    lon: number;
    lat: number;
    hash: number;
    routes: {
        from: Feature<Geometry>;
        to: Feature<Geometry>;
    };
    featureId: any;
    editMode?: boolean;
    loading: boolean;
};
declare function setWaypoint(feature: Feature<Geometry>, wp: Waypoint): void;
declare function getWaypoint(feature: Feature<Geometry>): Waypoint;
declare class HsTripPlannerService {
    hsMapService: HsMapService;
    private $http;
    hsShareUrlService: HsShareUrlService;
    hsEventBusService: HsEventBusService;
    private hsToastService;
    hsLanguageService: HsLanguageService;
    private hsLayoutService;
    private hsConfig;
    private hsProxyService;
    waypointRouteStyle: any;
    waypoints: Waypoint[];
    trip: any;
    orsProfiles: readonly ["driving-car", "driving-hgv", "cycling-regular", "cycling-road", "cycling-mountain", "cycling-electric", "foot-walking", "foot-hiking", "wheelchair"];
    movable_features: Collection<Feature<Geometry>>;
    modify: Modify;
    waypointSource: Vector<Feature<Point>>;
    waypointLayer: Vector$1<Vector<Feature<Point>>>;
    routeSource: Vector;
    routeLayer: Vector$1<Vector<Feature>>;
    timer: any;
    vectorLayers: {
        layer: Vector$1<Vector<Feature>>;
        title: string;
    }[];
    selectedLayerWrapper: {
        route?: {
            layer: Vector$1<Vector<Feature>>;
            title: string;
        };
        waypoints?: {
            layer: Vector$1<Vector<Feature>>;
            title: string;
        };
    };
    selectedProfile: RouteProfile;
    constructor();
    fillVectorLayers(): Promise<void>;
    private fillDefaultLayerWrapper;
    createWaypointLayer(): void;
    createRouteLayer(): void;
    /**
     * Select layer for storing route or waypoint features
     * @param layer - Wrapper object which contains OL layer and its title
     * @param usage - route or waypoints
     */
    selectLayer(layer: {
        layer: Vector$1<Vector<Feature>>;
        title: string;
    }, usage: 'route' | 'waypoints'): Promise<void>;
    selectProfile(profile: RouteProfile): Promise<void>;
    getTextOnFeature(feature: Feature<Geometry>): string;
    /**
     * Add waypoint to waypoint list and recalculate route
     * @param lon - Longitude number (part of Ol.coordinate Array)
     * @param lat - Latitude number (part of Ol.coordinate Array)
     */
    addWaypoint({ x, y, lon, lat, }: {
        x: number;
        y: number;
        lon: number;
        lat: number;
    }): void;
    /**
     * Handler of adding waypoint in connected service
     * @param wp - Waypoint object, with lat, lon and routes array
     */
    waypointAdded(wp: Waypoint): void;
    /**
     * Remove selected route from source
     * @param feature - Route feature to remove
     */
    routeRemoved(feature: Feature<Geometry>): void;
    /**
     * (PRIVATE) Remove routes from selected waypoint
     * @param wp - Waypoint to remove routes
     */
    removeRoutesForWaypoint(wp: Waypoint): void;
    /**
     * Remove selected waypoint from source
     * @param wp - Waypoint feature to remove
     */
    waypointRemoved(wp: Waypoint): void;
    /**
     * Remove selected waypoint from trip
     * @param wp - Waypoint object to remove
     */
    removeWaypoint(wp: any): void;
    /**
     * Clear all waypoints from service and layer
     */
    clearAll(): void;
    /**
     * Handler of adding computed route to layer
     * @param feature - Route to add
     */
    routeAdded(features: Feature<Geometry>[]): void;
    /**
     * Calculate routes between stored waypoints
     */
    calculateRoutes(): Promise<void>;
    /**
     * Format waypoint route distance in a human friendly way
     * @returns Distance
     */
    formatDistance(wp: Waypoint, which?: string): string;
    hashCode(s: string): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsTripPlannerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsTripPlannerService>;
}

declare class HsTripPlannerLayerSelectorComponent {
    hsTripPlannerService: HsTripPlannerService;
    label: string;
    usage: 'route' | 'waypoints';
    selectedWrapper: {
        layer: Vector$1<Vector<Feature>>;
        title: string;
    };
    layersExpanded: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsTripPlannerLayerSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsTripPlannerLayerSelectorComponent, "hs-trip-planner-layer-selector", never, { "label": { "alias": "label"; "required": false; }; "usage": { "alias": "usage"; "required": false; }; "selectedWrapper": { "alias": "selectedWrapper"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsTripPlannerProfileSelectorComponent {
    hsTripPlannerService: HsTripPlannerService;
    selectedProfile: RouteProfile;
    profilesExpanded: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsTripPlannerProfileSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsTripPlannerProfileSelectorComponent, "hs-trip-planner-profile-selector", never, { "selectedProfile": { "alias": "selectedProfile"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsTripPlannerComponent extends HsPanelBaseComponent implements OnInit {
    hsConfig: HsConfig;
    hsLanguageService: HsLanguageService;
    hsMapService: HsMapService;
    hsTripPlannerService: HsTripPlannerService;
    name: string;
    ngOnInit(): Promise<void>;
    /**
     * Format waypoint route distance in a human friendly way
     * @param wp - Waypoint
     * @returns Distance
     */
    formatDistance(wp: Waypoint): string;
    /**
     * Get the total distance for all waypoint routes
     * @returns Distance
     */
    totalDistance(): string;
    /**
     * Remove selected waypoint from source
     */
    toggleEdit(waypoint: Waypoint): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsTripPlannerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsTripPlannerComponent, "hs-trip-planner", never, {}, {}, never, never, false, never>;
}

declare class HsTripPlannerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsTripPlannerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsTripPlannerModule, [typeof HsTripPlannerComponent, typeof HsTripPlannerLayerSelectorComponent, typeof HsTripPlannerProfileSelectorComponent], [typeof i4.FormsModule, typeof i5.CommonModule, typeof i6.TranslatePipe, typeof i7.HsPanelHelpersModule, typeof i7.HsPanelHeaderComponent, typeof i8.NgbDropdownModule], [typeof HsTripPlannerComponent, typeof HsTripPlannerLayerSelectorComponent, typeof HsTripPlannerProfileSelectorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsTripPlannerModule>;
}

export { HsTripPlannerComponent, HsTripPlannerLayerSelectorComponent, HsTripPlannerModule, HsTripPlannerProfileSelectorComponent, HsTripPlannerService, getWaypoint, profiles, setWaypoint };
export type { RouteProfile, Waypoint };