import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { BicycleType, BikeShareStationInfo, BoundingBox, LatLng, LevelChange, Location, PedestrianType, RoadClass, RouteLandmark, StreetName, Summary, TaggedValue, TransitEgressInfo, TransitPlatformInfo, TransitRouteInfo, TransitStationInfo, TransitType, TravelMode, TurnLane, VehicleType } from "./common";
import { IncidentsTile_Metadata } from "./incidents";
import { TripSign } from "./sign";
export declare const protobufPackage = "valhalla";
export interface TripLeg {
    osmChangeset: number;
    tripId: number;
    legId: number;
    legCount: number;
    location: Location[];
    node: TripLeg_Node[];
    admin: TripLeg_Admin[];
    shape: string;
    bbox: BoundingBox | undefined;
    shapeAttributes: TripLeg_ShapeAttributes | undefined;
    incidents: TripLeg_Incident[];
    algorithms: string[];
    closures: TripLeg_Closure[];
    summary: Summary | undefined;
    levelChanges: LevelChange[];
}
export declare enum TripLeg_Traversability {
    kNone = 0,
    kForward = 1,
    kBackward = 2,
    kBoth = 3,
    UNRECOGNIZED = -1
}
export declare function tripLeg_TraversabilityFromJSON(object: any): TripLeg_Traversability;
export declare function tripLeg_TraversabilityToJSON(object: TripLeg_Traversability): string;
export declare enum TripLeg_Use {
    kRoadUse = 0,
    /** kRampUse - Link - exits/entrance ramps. */
    kRampUse = 1,
    /** kTurnChannelUse - Link - turn lane. */
    kTurnChannelUse = 2,
    /** kTrackUse - Agricultural use; forest tracks */
    kTrackUse = 3,
    /** kDrivewayUse - Driveway/private service */
    kDrivewayUse = 4,
    /** kAlleyUse - Service road - limited route use */
    kAlleyUse = 5,
    /** kParkingAisleUse - Access roads in parking areas */
    kParkingAisleUse = 6,
    /** kEmergencyAccessUse - Emergency vehicles only */
    kEmergencyAccessUse = 7,
    /** kDriveThruUse - Commercial drive-thru (banks/fast-food) */
    kDriveThruUse = 8,
    /** kCuldesacUse - Cul-de-sac (edge that forms a loop and is only */
    kCuldesacUse = 9,
    /** kLivingStreetUse - connected at one node to another edge. */
    kLivingStreetUse = 10,
    /** kServiceRoadUse - Generic service road (not driveway, alley, parking aisle, etc.) */
    kServiceRoadUse = 11,
    /** kCyclewayUse - Bicycle specific uses */
    kCyclewayUse = 20,
    /** kMountainBikeUse - Mountain bike trail */
    kMountainBikeUse = 21,
    kSidewalkUse = 24,
    /** kFootwayUse - Pedestrian specific uses */
    kFootwayUse = 25,
    /** kStepsUse - Stairs */
    kStepsUse = 26,
    kPathUse = 27,
    kPedestrianUse = 28,
    kBridlewayUse = 29,
    kPedestrianCrossingUse = 32,
    kElevatorUse = 33,
    kEscalatorUse = 34,
    /** kRestAreaUse - Rest/Service Areas */
    kRestAreaUse = 30,
    kServiceAreaUse = 31,
    /** kOtherUse - Other... */
    kOtherUse = 40,
    /** kFerryUse - Ferry and rail ferry */
    kFerryUse = 41,
    kRailFerryUse = 42,
    /** kConstructionUse - Road under construction */
    kConstructionUse = 43,
    /** kRailUse - Transit specific uses. Must be last in the list */
    kRailUse = 50,
    /** kBusUse - Bus line */
    kBusUse = 51,
    /** kEgressConnectionUse - Connection between transit station and transit egress */
    kEgressConnectionUse = 52,
    /** kPlatformConnectionUse - Connection between transit station and transit platform */
    kPlatformConnectionUse = 53,
    /** kTransitConnectionUse - Connection between road network and transit egress */
    kTransitConnectionUse = 54,
    UNRECOGNIZED = -1
}
export declare function tripLeg_UseFromJSON(object: any): TripLeg_Use;
export declare function tripLeg_UseToJSON(object: TripLeg_Use): string;
export declare enum TripLeg_Surface {
    kPavedSmooth = 0,
    kPaved = 1,
    kPavedRough = 2,
    kCompacted = 3,
    kDirt = 4,
    kGravel = 5,
    kPath = 6,
    kImpassable = 7,
    UNRECOGNIZED = -1
}
export declare function tripLeg_SurfaceFromJSON(object: any): TripLeg_Surface;
export declare function tripLeg_SurfaceToJSON(object: TripLeg_Surface): string;
export declare enum TripLeg_CycleLane {
    kNoCycleLane = 0,
    /** kShared - Shared use lane (could be shared with pedestrians) */
    kShared = 1,
    /** kDedicated - Dedicated cycle lane */
    kDedicated = 2,
    /** kSeparated - A separate cycle lane (physical separation from the main carriageway */
    kSeparated = 3,
    UNRECOGNIZED = -1
}
export declare function tripLeg_CycleLaneFromJSON(object: any): TripLeg_CycleLane;
export declare function tripLeg_CycleLaneToJSON(object: TripLeg_CycleLane): string;
export declare enum TripLeg_SacScale {
    kNoSacScale = 0,
    kHiking = 1,
    kMountainHiking = 2,
    kDemandingMountainHiking = 3,
    kAlpineHiking = 4,
    kDemandingAlpineHiking = 5,
    kDifficultAlpineHiking = 6,
    UNRECOGNIZED = -1
}
export declare function tripLeg_SacScaleFromJSON(object: any): TripLeg_SacScale;
export declare function tripLeg_SacScaleToJSON(object: TripLeg_SacScale): string;
export declare enum TripLeg_Sidewalk {
    kNoSidewalk = 0,
    kLeft = 1,
    kRight = 2,
    kBothSides = 3,
    UNRECOGNIZED = -1
}
export declare function tripLeg_SidewalkFromJSON(object: any): TripLeg_Sidewalk;
export declare function tripLeg_SidewalkToJSON(object: TripLeg_Sidewalk): string;
export declare enum TripLeg_HovType {
    kHOV2 = 0,
    kHOV3 = 1,
    UNRECOGNIZED = -1
}
export declare function tripLeg_HovTypeFromJSON(object: any): TripLeg_HovType;
export declare function tripLeg_HovTypeToJSON(object: TripLeg_HovType): string;
export declare enum TripLeg_SpeedType {
    kTagged = 0,
    kClassified = 1,
    UNRECOGNIZED = -1
}
export declare function tripLeg_SpeedTypeFromJSON(object: any): TripLeg_SpeedType;
export declare function tripLeg_SpeedTypeToJSON(object: TripLeg_SpeedType): string;
export interface TripLeg_LaneConnectivity {
    fromWayId: number;
    fromLanes: string;
    toLanes: string;
}
export interface TripLeg_TrafficSegment {
    segmentId: number;
    beginPercent: number;
    endPercent: number;
    startsSegment: boolean;
    endsSegment: boolean;
}
export interface TripLeg_Speeds {
    predictedFlow: number;
    constrainedFlow: number;
    freeFlow: number;
    currentFlow: number;
    noFlow: number;
}
export interface TripLeg_Restriction {
    type: number;
}
/** represents a single date/time range from https://wiki.openstreetmap.org/wiki/Key:opening_hours */
export interface TripLeg_TimeDomain {
    /** `begin_day_dow` and `end_day_dow` type */
    dayDowType: TripLeg_TimeDomain_DayDowType;
    /** day of week mask, e.g. 0b0111110 for Mo-Fr as week starts from Su */
    dowMask: number;
    /** begin hours, 0 if not set */
    beginHrs: number;
    /** begin minutes, 0 if not set */
    beginMins: number;
    /** begin month, from 1 (January) to 12 (December), 0 if not set */
    beginMonth: number;
    /** begin day of month or nth dow, i.e. 1st Sunday */
    beginDayDow: number;
    /** which week does this start, i.e. 1st week in Oct */
    beginWeek: number;
    /** end hours, 0 if not set */
    endHrs: number;
    /** end minutes, 0 if not set */
    endMins: number;
    /** end month, from 1 (January) to 12 (December), 0 if not set */
    endMonth: number;
    /** end day of month or nth dow, i.e. last Sunday */
    endDayDow: number;
    /** which week does this end, i.e. last week in Oct */
    endWeek: number;
}
export declare enum TripLeg_TimeDomain_DayDowType {
    /** kDayOfMonth - day_dow is a day of month in range [1,31] */
    kDayOfMonth = 0,
    /** kNthDayOfWeek - day_dow is a day of week in range [1,7] */
    kNthDayOfWeek = 1,
    UNRECOGNIZED = -1
}
export declare function tripLeg_TimeDomain_DayDowTypeFromJSON(object: any): TripLeg_TimeDomain_DayDowType;
export declare function tripLeg_TimeDomain_DayDowTypeToJSON(object: TripLeg_TimeDomain_DayDowType): string;
export interface TripLeg_ConditionalSpeedLimit {
    speedLimit: number;
    condition: TripLeg_TimeDomain | undefined;
}
export interface TripLeg_Edge {
    /** street names */
    name: StreetName[];
    /** km */
    lengthKm: number;
    /** km/h */
    speed: number;
    roadClass: RoadClass;
    /** 0-359 */
    beginHeading: number;
    /** 0-359 */
    endHeading: number;
    /** inclusive */
    beginShapeIndex: number;
    /** inclusive */
    endShapeIndex: number;
    traversability: TripLeg_Traversability;
    use: TripLeg_Use;
    toll: boolean;
    unpaved: boolean;
    tunnel: boolean;
    bridge: boolean;
    roundabout: boolean;
    internalIntersection: boolean;
    /** [default = false] */
    driveOnLeft: boolean;
    surface: TripLeg_Surface;
    sign: TripSign | undefined;
    travelMode: TravelMode;
    vehicleType: VehicleType;
    pedestrianType: PedestrianType;
    bicycleType: BicycleType;
    transitType: TransitType;
    transitRouteInfo: TransitRouteInfo | undefined;
    id: number;
    wayId: number;
    weightedGrade: number;
    /** set to 32768 if no elevation data */
    maxUpwardGrade: number;
    /** set to 32768 if no elevation data */
    maxDownwardGrade: number;
    laneCount: number;
    cycleLane: TripLeg_CycleLane;
    /** true if the edge is part of a bike network */
    bicycleNetwork: boolean;
    sidewalk: TripLeg_Sidewalk;
    density: number;
    /** 0 if unavailable, 255 if unlimited */
    speedLimit: number;
    /** km/h, 0 if unavailable */
    truckSpeed: number;
    truckRoute: boolean;
    laneConnectivity: TripLeg_LaneConnectivity[];
    /** set to 32768 if no elevation data */
    meanElevation: number;
    trafficSegment: TripLeg_TrafficSegment[];
    turnLanes: TurnLane[];
    hasTimeRestrictions: boolean;
    /** km/h */
    defaultSpeed: number;
    restriction: TripLeg_Restriction | undefined;
    destinationOnly: boolean;
    /** uses edge density to decide if edge is in an urban area */
    isUrban: boolean;
    taggedValue: TaggedValue[];
    /**
     * for the part of the edge that is used in the path we must know where
     * it starts and ends along the length of the edge as a percentage
     */
    sourceAlongEdge: number;
    targetAlongEdge: number;
    sacScale: TripLeg_SacScale;
    shoulder: boolean;
    indoor: boolean;
    /** landmarks in the trip leg */
    landmarks: RouteLandmark[];
    tunnelName: StreetName[];
    elevationSamplingInterval: number;
    elevation: number[];
    countryCrossing: boolean;
    forward: boolean;
    beginOsmNodeId?: number | undefined;
    endOsmNodeId?: number | undefined;
    conditionalSpeedLimits: TripLeg_ConditionalSpeedLimit[];
    levels: TripLeg_Edge_Level[];
    levelPrecision: number;
    speedsFaded?: TripLeg_Speeds | undefined;
    speedsNonFaded?: TripLeg_Speeds | undefined;
    speedType: TripLeg_SpeedType;
    trafficSignal: boolean;
    hovType: TripLeg_HovType;
    curvature: number;
}
export interface TripLeg_Edge_Level {
    start: number;
    end: number;
}
export interface TripLeg_IntersectingEdge {
    /** 0-359 */
    beginHeading: number;
    prevNameConsistency: boolean;
    currNameConsistency: boolean;
    driveability: TripLeg_Traversability;
    cyclability: TripLeg_Traversability;
    walkability: TripLeg_Traversability;
    use: TripLeg_Use;
    roadClass: RoadClass;
    laneCount: number;
    sign: TripSign | undefined;
    /** street names */
    name: StreetName[];
}
export interface TripLeg_Cost {
    seconds: number;
    cost: number;
}
export interface TripLeg_PathCost {
    elapsedCost: TripLeg_Cost | undefined;
    transitionCost: TripLeg_Cost | undefined;
}
export interface TripLeg_Node {
    edge: TripLeg_Edge | undefined;
    intersectingEdge: TripLeg_IntersectingEdge[];
    /** index into the admin list, 0 if unknown */
    adminIndex: number;
    /** The type of node */
    type: TripLeg_Node_Type;
    /** Fork */
    fork: boolean;
    transitPlatformInfo: TransitPlatformInfo | undefined;
    transitStationInfo: TransitStationInfo | undefined;
    transitEgressInfo: TransitEgressInfo | undefined;
    timeZone: string;
    /** how much cost did it take at this node in the path */
    cost: TripLeg_PathCost | undefined;
    /** how much cost did it take at this node in the path for recostings */
    recosts: TripLeg_PathCost[];
    bssInfo: BikeShareStationInfo | undefined;
    trafficSignal: boolean;
}
export declare enum TripLeg_Node_Type {
    /** kStreetIntersection - Regular intersection of 2+ roads */
    kStreetIntersection = 0,
    /** kGate - Gate or rising bollard */
    kGate = 1,
    /** kBollard - Bollard (fixed obstruction) */
    kBollard = 2,
    /** kTollBooth - Toll booth / fare collection */
    kTollBooth = 3,
    /** kTransitEgress - TODO - for now there is no differentiation between bus and rail stops... */
    kTransitEgress = 4,
    /** kTransitStation - Transit station */
    kTransitStation = 5,
    /** kTransitPlatform - Transit platform (rail and bus) */
    kTransitPlatform = 6,
    /** kBikeShare - Bike share location */
    kBikeShare = 7,
    /** kParking - Parking location */
    kParking = 8,
    /** kMotorwayJunction - Highway = motorway_junction */
    kMotorwayJunction = 9,
    /** kBorderControl - Border control */
    kBorderControl = 10,
    /** kTollGantry - Toll gantry */
    kTollGantry = 11,
    /** kSumpBuster - Sump Buster */
    kSumpBuster = 12,
    /** kBuildingEntrance - Building Entrance */
    kBuildingEntrance = 13,
    /** kElevator - Elevator */
    kElevator = 14,
    UNRECOGNIZED = -1
}
export declare function tripLeg_Node_TypeFromJSON(object: any): TripLeg_Node_Type;
export declare function tripLeg_Node_TypeToJSON(object: TripLeg_Node_Type): string;
export interface TripLeg_Admin {
    countryCode: string;
    countryText: string;
    stateCode: string;
    stateText: string;
}
export interface TripLeg_ShapeAttributes {
    /** milliseconds */
    time: number[];
    /** decimeters */
    length: number[];
    /** decimeters per sec */
    speed: number[];
    /** 4 is reserved */
    speedLimit: number[];
    /** congestion value between 0 and 63 */
    congestion: number[];
}
/**
 * we encapsulate the real incident object here so we can add information
 * about where it is along the route, ie once its referenced to the route
 */
export interface TripLeg_Incident {
    metadata: IncidentsTile_Metadata | undefined;
    /** Valhalla additions to incident metadata goes here */
    beginShapeIndex: number;
    endShapeIndex: number;
}
export interface TripLeg_Closure {
    beginShapeIndex?: number | undefined;
    endShapeIndex?: number | undefined;
}
export interface TripRoute {
    legs: TripLeg[];
    /** Each point corresponds to a trace point in the original request. */
    matchedPoints: TripRoute_MatchedPoint[];
    /**
     * Relative quality measure for this map matching alternative. Value of 1.0 for the best match,
     * lower values indicate how much worse this alternative is compared to the best match.
     */
    confidenceScore: number;
    /**
     * Total accumulated cost from the map matching algorithm. Lower values indicate better match
     * quality based on GPS accuracy and route consistency.
     */
    rawScore: number;
    isBest: boolean;
}
export interface TripRoute_MatchedPoint {
    type: TripRoute_MatchedPoint_MatchType;
    edgeIndex?: number | undefined;
    /** Whether or not there is a discontinuity starting from this point. */
    beginsDiscontinuity: boolean;
    /** Whether or not a discontinuity ends at this point. */
    endsDiscontinuity: boolean;
    distanceAlongEdge?: number | undefined;
    distanceFromTracePoint?: number | undefined;
    latlng?: LatLng | undefined;
}
export declare enum TripRoute_MatchedPoint_MatchType {
    kUnmatched = 0,
    kInterpolated = 1,
    kMatched = 2,
    UNRECOGNIZED = -1
}
export declare function tripRoute_MatchedPoint_MatchTypeFromJSON(object: any): TripRoute_MatchedPoint_MatchType;
export declare function tripRoute_MatchedPoint_MatchTypeToJSON(object: TripRoute_MatchedPoint_MatchType): string;
export interface Trip {
    routes: TripRoute[];
}
export declare const TripLeg: MessageFns<TripLeg>;
export declare const TripLeg_LaneConnectivity: MessageFns<TripLeg_LaneConnectivity>;
export declare const TripLeg_TrafficSegment: MessageFns<TripLeg_TrafficSegment>;
export declare const TripLeg_Speeds: MessageFns<TripLeg_Speeds>;
export declare const TripLeg_Restriction: MessageFns<TripLeg_Restriction>;
export declare const TripLeg_TimeDomain: MessageFns<TripLeg_TimeDomain>;
export declare const TripLeg_ConditionalSpeedLimit: MessageFns<TripLeg_ConditionalSpeedLimit>;
export declare const TripLeg_Edge: MessageFns<TripLeg_Edge>;
export declare const TripLeg_Edge_Level: MessageFns<TripLeg_Edge_Level>;
export declare const TripLeg_IntersectingEdge: MessageFns<TripLeg_IntersectingEdge>;
export declare const TripLeg_Cost: MessageFns<TripLeg_Cost>;
export declare const TripLeg_PathCost: MessageFns<TripLeg_PathCost>;
export declare const TripLeg_Node: MessageFns<TripLeg_Node>;
export declare const TripLeg_Admin: MessageFns<TripLeg_Admin>;
export declare const TripLeg_ShapeAttributes: MessageFns<TripLeg_ShapeAttributes>;
export declare const TripLeg_Incident: MessageFns<TripLeg_Incident>;
export declare const TripLeg_Closure: MessageFns<TripLeg_Closure>;
export declare const TripRoute: MessageFns<TripRoute>;
export declare const TripRoute_MatchedPoint: MessageFns<TripRoute_MatchedPoint>;
export declare const Trip: MessageFns<Trip>;
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=trip.d.ts.map