import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { LatLng, Location } from "./common";
export declare const protobufPackage = "valhalla";
export declare enum ShapeMatch {
    walk_or_snap = 0,
    edge_walk = 1,
    map_snap = 2,
    UNRECOGNIZED = -1
}
export declare function shapeMatchFromJSON(object: any): ShapeMatch;
export declare function shapeMatchToJSON(object: ShapeMatch): string;
export declare enum FilterAction {
    no_action = 0,
    exclude = 1,
    include = 2,
    UNRECOGNIZED = -1
}
export declare function filterActionFromJSON(object: any): FilterAction;
export declare function filterActionToJSON(object: FilterAction): string;
export declare enum DirectionsType {
    instructions = 0,
    none = 1,
    maneuvers = 2,
    UNRECOGNIZED = -1
}
export declare function directionsTypeFromJSON(object: any): DirectionsType;
export declare function directionsTypeToJSON(object: DirectionsType): string;
export declare enum ShapeFormat {
    polyline6 = 0,
    polyline5 = 1,
    geojson = 2,
    /** no_shape - to omit returning the geometry, e.g. default in matrix */
    no_shape = 3,
    UNRECOGNIZED = -1
}
export declare function shapeFormatFromJSON(object: any): ShapeFormat;
export declare function shapeFormatToJSON(object: ShapeFormat): string;
export interface Contour {
    /** minutes */
    time?: number | undefined;
    /** hex color with out # - for example: "ff0000" for red */
    color?: string | undefined;
    /** kilometers */
    distance?: number | undefined;
}
export interface Ring {
    coords: LatLng[];
}
export interface Levels {
    levels: number[];
}
/**
 * use this to select which top level fields should be present in the pbf output
 * the actions below are marked for each field that would provide a minimal response
 */
export interface PbfFieldSelector {
    options: boolean;
    /** /trace_attributes */
    trip: boolean;
    /** /route /trace_route /optimized_route /centroid */
    directions: boolean;
    /** /status */
    status: boolean;
    /** sources_to_targets */
    matrix: boolean;
    isochrone: boolean;
    /**
     * TODO: enable these once we have objects for them
     * bool locate = 7;
     * bool height = 8;
     */
    expansion: boolean;
}
export interface AvoidEdge {
    id?: number | undefined;
    percentAlong?: number | undefined;
}
export interface CostFactorEdge {
    /** the edge's graph id */
    id: number;
    /** the factor applied to the (partial) edge cost */
    factor: number;
    /** the start fraction along the edge */
    start: number;
    /** the end fraction along the edge */
    end: number;
}
/**
 * Hierarchy limits controls expansion and transitions between hierarchy
 * levels. It allows limiting expansion on hierarchy levels once
 * some number of "upward" transitions have been made (e.g. from the local
 * level to the arterial level). Expansion on a level is allowed within some
 * distance from the destination location. This also allows control of where
 * upward and downward transitions are allowed based on distance from the
 * destination.
 */
export interface HierarchyLimits {
    /** Keep track of # of upward transitions */
    upTransitionCount: number;
    /** Internal use only, remember to clear on incoming requests */
    maxUpTransitions: number;
    /** expansion is stopped on a level. */
    expandWithinDist: number;
}
/** for /tile requests */
export interface Tile {
    x?: number | undefined;
    y?: number | undefined;
    z?: number | undefined;
}
export interface TileOptions {
    /** which layers to exclude, default none */
    excludeLayers: string[];
}
export interface Costing {
    options?: Costing_Options | undefined;
    type: Costing_Type;
    name?: string | undefined;
    filterClosures?: boolean | undefined;
}
export declare enum Costing_Type {
    none_ = 0,
    bicycle = 1,
    bus = 2,
    motor_scooter = 3,
    /** multimodal - turns into pedestrian + transit */
    multimodal = 4,
    pedestrian = 5,
    transit = 6,
    truck = 7,
    motorcycle = 8,
    taxi = 9,
    auto_ = 10,
    /** bikeshare - turns into pedestrian + bike */
    bikeshare = 11,
    /** auto_pedestrian - turns into auto + pedestrian */
    auto_pedestrian = 12,
    UNRECOGNIZED = -1
}
export declare function costing_TypeFromJSON(object: any): Costing_Type;
export declare function costing_TypeToJSON(object: Costing_Type): string;
export interface Costing_Options {
    maneuverPenalty?: number | undefined;
    destinationOnlyPenalty?: number | undefined;
    gateCost?: number | undefined;
    gatePenalty?: number | undefined;
    tollBoothCost?: number | undefined;
    tollBoothPenalty?: number | undefined;
    alleyPenalty?: number | undefined;
    countryCrossingCost?: number | undefined;
    countryCrossingPenalty?: number | undefined;
    ferryCost?: number | undefined;
    avoidBadSurfaces?: number | undefined;
    useFerry?: number | undefined;
    useHighways?: number | undefined;
    useTolls?: number | undefined;
    useRoads?: number | undefined;
    maxDistance?: number | undefined;
    walkingSpeed?: number | undefined;
    stepPenalty?: number | undefined;
    maxGrade?: number | undefined;
    maxHikingDifficulty?: number | undefined;
    modeFactor?: number | undefined;
    walkwayFactor?: number | undefined;
    sidewalkFactor?: number | undefined;
    alleyFactor?: number | undefined;
    drivewayFactor?: number | undefined;
    drivewayPenalty?: number | undefined;
    /** deprecated in favor of multimodal_start_end_max_distance */
    transitStartEndMaxDistance?: number | undefined;
    transitTransferMaxDistance?: number | undefined;
    transportType?: string | undefined;
    topSpeed?: number | undefined;
    useHills?: number | undefined;
    usePrimary?: number | undefined;
    useTrails?: number | undefined;
    lowClassPenalty?: number | undefined;
    hazmat: boolean;
    weight?: number | undefined;
    axleLoad?: number | undefined;
    height?: number | undefined;
    width?: number | undefined;
    length?: number | undefined;
    cyclingSpeed?: number | undefined;
    wheelchair: boolean;
    bicycle: boolean;
    useBus?: number | undefined;
    useRail?: number | undefined;
    useTransfers?: number | undefined;
    transferCost?: number | undefined;
    transferPenalty?: number | undefined;
    filterStopAction: FilterAction;
    filterStopIds: string[];
    filterOperatorAction: FilterAction;
    filterOperatorIds: string[];
    filterRouteAction: FilterAction;
    filterRouteIds: string[];
    flowMask?: number | undefined;
    bikeShareCost?: number | undefined;
    bikeSharePenalty?: number | undefined;
    railFerryCost?: number | undefined;
    useRailFerry?: number | undefined;
    ignoreRestrictions: boolean;
    ignoreOneways: boolean;
    ignoreAccess: boolean;
    ignoreClosures?: boolean | undefined;
    shortest: boolean;
    servicePenalty?: number | undefined;
    useTracks?: number | undefined;
    useDistance?: number | undefined;
    useLivingStreets?: number | undefined;
    serviceFactor?: number | undefined;
    closureFactor?: number | undefined;
    privateAccessPenalty?: number | undefined;
    excludeUnpaved: boolean;
    includeHot: boolean;
    includeHov2: boolean;
    includeHov3: boolean;
    excludeCashOnlyTolls: boolean;
    restrictionProbability?: number | undefined;
    excludeEdges: AvoidEdge[];
    elevatorPenalty?: number | undefined;
    fixedSpeed: number;
    axleCount: number;
    useLit: number;
    disableHierarchyPruning: boolean;
    ignoreNonVehicularRestrictions: boolean;
    hgvNoAccessPenalty?: number | undefined;
    useTruckRoute: number;
    excludeBridges: boolean;
    excludeTunnels: boolean;
    excludeTolls: boolean;
    excludeHighways: boolean;
    excludeFerries: boolean;
    hierarchyLimits: {
        [key: number]: HierarchyLimits;
    };
    ignoreConstruction: boolean;
    /** identified edges along user provided linear features, to which to apply special cost factors */
    costFactorEdges: CostFactorEdge[];
    speedPenaltyFactor?: number | undefined;
    multimodalStartEndMaxDistance?: number | undefined;
}
export interface Costing_Options_HierarchyLimitsEntry {
    key: number;
    value: HierarchyLimits | undefined;
}
export interface LinearFeatureCost {
    /** In here we just store the first and last location correlation */
    locations: Location[];
    /** This is where the actual line geometry goes */
    shape: Location[];
    costFactor: number;
}
export interface Options {
    /** kilometers or miles */
    units: Options_Units;
    /** Based on IETF BCP 47 language tag string [default = "en-US"] */
    language?: string | undefined;
    /** Enable/disable narrative production [default = instructions] */
    directionsType: DirectionsType;
    /** What the response format should be [default = json] */
    format: Options_Format;
    /** id for the request */
    id?: string | undefined;
    /** javascript callback for the request */
    jsonp?: string | undefined;
    /** polyline 6 encoded shape used in /height /trace_* */
    encodedPolyline?: string | undefined;
    /** Action signifying the request type */
    action: Options_Action;
    /** deprecated = 9; */
    range: boolean;
    /** Used in /locate & /status request to give back extensive information [default = false] */
    verbose?: boolean | undefined;
    /** The main costing to use with the action, in multimodal this is the first costing to use */
    costingType: Costing_Type;
    /** A map of Costing.Type enum to its Costing object */
    costings: {
        [key: number]: Costing;
    };
    /** Locations for /route /optimized /locate /isochrone */
    locations: Location[];
    /** Avoids for any costing */
    excludeLocations: Location[];
    /** Sources for /sources_to_targets */
    sources: Location[];
    /** Targets for /sources_to_targets */
    targets: Location[];
    /** Are you leaving now or then or arriving then */
    dateTimeType: Options_DateTimeType;
    /** And what day and time */
    dateTime?: string | undefined;
    /** Raw shape for map matching */
    shape: Location[];
    /** Resampling shape at regular intervals */
    resampleDistance?: number | undefined;
    /** List of isochrone contours */
    contours: Contour[];
    /** Boolean value to determine whether to return geojson polygons or linestrings as the contours */
    polygons: boolean;
    /** A floating point value from 0 to 1 which can be used to remove smaller contours (default 1.0) */
    denoise?: number | undefined;
    /** Meters used as the tolerance for Douglas-Peucker generalization */
    generalize?: number | undefined;
    /** Add original locations to the isochrone geojson response */
    showLocations: boolean;
    /** Trace points for map matching */
    trace: Location[];
    /** The matching algorithm based on the type of input [default = walk_or_snap] */
    shapeMatch: ShapeMatch;
    /** The gps accuracy associated with the supplied trace points */
    gpsAccuracy?: number | undefined;
    /** The search radius associated with the supplied trace points */
    searchRadius?: number | undefined;
    /** The turn penalty factor associated with the supplied trace points */
    turnPenaltyFactor?: number | undefined;
    /** The trace filter action - either exclude or include */
    filterAction: FilterAction;
    /** The filter list for trace attributes */
    filterAttributes: string[];
    /** Map-matching breaking distance (distance between GPS trace points) */
    breakageDistance?: number | undefined;
    /** Use timestamps to compute elapsed time for trace_route and trace_attributes [default = false] */
    useTimestamps: boolean;
    /** Shape format, defaults to polyline6 encoding for OSRM/height, and no_shape for matrix */
    shapeFormat?: ShapeFormat | undefined;
    /** Maximum number of alternate routes that can be returned */
    alternates?: number | undefined;
    /** Map-matching interpolation distance beyond which trace points are merged */
    interpolationDistance?: number | undefined;
    /** Whether to return guidance_views in the response */
    guidanceViews: boolean;
    /** Number of digits precision for heights returned [default = 0] */
    heightPrecision?: number | undefined;
    /** Whether to announce roundabout exit maneuvers [default = true] */
    roundaboutExits?: boolean | undefined;
    /** Include linear references for graph edges returned in certain responses. */
    linearReferences: boolean;
    /** CostingType options to use to recost a path after it has been found */
    recostings: Costing[];
    /** Rings/polygons to exclude entire areas during path finding */
    excludePolygons: Ring[];
    /** Prioritize bidirectional a* /matrix when depart_at date_time.type is specified [default = false] */
    prioritizeBidirectional: boolean;
    /** Meta action for /expansion endpoint */
    expansionAction?: Options_Action | undefined;
    /** Whether to return opposite edges encountered during expansion */
    skipOpposites: boolean;
    /** The array keys (ExpansionTypes enum) to return in the /expansions's GeoJSON "properties" */
    expansionProperties: Options_ExpansionProperties[];
    /** Which pbf fields to include in the pbf format response */
    pbfFieldSelector: PbfFieldSelector | undefined;
    /** should the isochrone expansion be done in the reverse direction, ignored for multimodal isochrones */
    reverse: boolean;
    /** a one to many or many to one time distance matrix. Does not affect */
    matrixLocations?: number | undefined;
    /** or when CostMatrix is the selected matrix mode. */
    bannerInstructions: boolean;
    /** Interval for sampling elevation along the route path.  [default = 0.0]; */
    elevationInterval: number;
    /** Whether to return voiceInstructions in the OSRM serializer response */
    voiceInstructions: boolean;
    /** Keep track of edges and override their properties during expansion, */
    dedupe: boolean;
    /** ensuring that each edge appears in the output only once. [default = false] */
    adminCrossings: boolean;
    /** Include turn lane information into Valhalla serializer response. */
    turnLanes: boolean;
    /** User provided linear features to which apply special cost factors to */
    costFactorLines: LinearFeatureCost[];
    /** Which strategy to use on the reverse tree in time dependent bidirectional routing */
    reverseTimeTracking: Options_ReverseTimeTracking;
    /** x, y, z for /tile requests */
    tileXyz: Tile | undefined;
    /** additional /tile specific options */
    tileOptions: TileOptions | undefined;
    /** Levels to exclude within the exclude_polygon at the same index */
    excludeLevels: Levels[];
    /** Maximum path distance in meters for expansion. 0 = disabled. */
    expansionMaxDistance: number;
}
export declare enum Options_Units {
    kilometers = 0,
    miles = 1,
    UNRECOGNIZED = -1
}
export declare function options_UnitsFromJSON(object: any): Options_Units;
export declare function options_UnitsToJSON(object: Options_Units): string;
export declare enum Options_Format {
    json = 0,
    gpx = 1,
    osrm = 2,
    pbf = 3,
    geotiff = 4,
    /** mvt - we set this ourselves and throw if it's set by the user */
    mvt = 5,
    UNRECOGNIZED = -1
}
export declare function options_FormatFromJSON(object: any): Options_Format;
export declare function options_FormatToJSON(object: Options_Format): string;
export declare enum Options_Action {
    no_action = 0,
    route = 1,
    locate = 2,
    sources_to_targets = 3,
    optimized_route = 4,
    isochrone = 5,
    trace_route = 6,
    trace_attributes = 7,
    height = 8,
    transit_available = 9,
    expansion = 10,
    centroid = 11,
    status = 12,
    tile = 13,
    UNRECOGNIZED = -1
}
export declare function options_ActionFromJSON(object: any): Options_Action;
export declare function options_ActionToJSON(object: Options_Action): string;
export declare enum Options_DateTimeType {
    no_time = 0,
    current = 1,
    depart_at = 2,
    arrive_by = 3,
    invariant = 4,
    UNRECOGNIZED = -1
}
export declare function options_DateTimeTypeFromJSON(object: any): Options_DateTimeType;
export declare function options_DateTimeTypeToJSON(object: Options_DateTimeType): string;
export declare enum Options_ExpansionProperties {
    cost = 0,
    duration = 1,
    distance = 2,
    edge_status = 3,
    edge_id = 4,
    pred_edge_id = 5,
    expansion_type = 6,
    flow_sources = 7,
    travel_mode = 8,
    UNRECOGNIZED = -1
}
export declare function options_ExpansionPropertiesFromJSON(object: any): Options_ExpansionProperties;
export declare function options_ExpansionPropertiesToJSON(object: Options_ExpansionProperties): string;
export declare enum Options_ReverseTimeTracking {
    rtt_heuristic = 0,
    rtt_disabled = 1,
    UNRECOGNIZED = -1
}
export declare function options_ReverseTimeTrackingFromJSON(object: any): Options_ReverseTimeTracking;
export declare function options_ReverseTimeTrackingToJSON(object: Options_ReverseTimeTracking): string;
export interface Options_CostingsEntry {
    key: number;
    value: Costing | undefined;
}
export declare const Contour: MessageFns<Contour>;
export declare const Ring: MessageFns<Ring>;
export declare const Levels: MessageFns<Levels>;
export declare const PbfFieldSelector: MessageFns<PbfFieldSelector>;
export declare const AvoidEdge: MessageFns<AvoidEdge>;
export declare const CostFactorEdge: MessageFns<CostFactorEdge>;
export declare const HierarchyLimits: MessageFns<HierarchyLimits>;
export declare const Tile: MessageFns<Tile>;
export declare const TileOptions: MessageFns<TileOptions>;
export declare const Costing: MessageFns<Costing>;
export declare const Costing_Options: MessageFns<Costing_Options>;
export declare const Costing_Options_HierarchyLimitsEntry: MessageFns<Costing_Options_HierarchyLimitsEntry>;
export declare const LinearFeatureCost: MessageFns<LinearFeatureCost>;
export declare const Options: MessageFns<Options>;
export declare const Options_CostingsEntry: MessageFns<Options_CostingsEntry>;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & {
    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
};
export interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};
//# sourceMappingURL=options.d.ts.map