org.opentripplanner.apis.transmodel.schema.graphql Maven / Gradle / Ivy
The newest version!
schema {
query: QueryType
}
"Marks the field, argument, input field or enum value as deprecated"
directive @deprecated(
"The reason for the deprecation"
reason: String = "No longer supported"
) on FIELD_DEFINITION | ARGUMENT_DEFINITION | ENUM_VALUE | INPUT_FIELD_DEFINITION
"Directs the executor to include this field or fragment only when the `if` argument is true"
directive @include(
"Included when true."
if: Boolean!
) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
"Indicates an Input Object is a OneOf Input Object."
directive @oneOf on INPUT_OBJECT
"Directs the executor to skip this field or fragment when the `if` argument is true."
directive @skip(
"Skipped when true."
if: Boolean!
) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
"Exposes a URL that specifies the behaviour of this scalar."
directive @specifiedBy(
"The URL that specifies the behaviour of this scalar."
url: String!
) on SCALAR
"Add timing data to prometheus, if Actuator API is enabled"
directive @timingData on FIELD_DEFINITION
"Interface for places, i.e. quays, stop places, parks"
interface PlaceInterface {
id: ID!
latitude: Float
longitude: Float
}
union Affects = AffectedLine | AffectedServiceJourney | AffectedStopPlace | AffectedStopPlaceOnLine | AffectedStopPlaceOnServiceJourney | AffectedUnknown
type AffectedLine {
line: Line
}
type AffectedServiceJourney {
datedServiceJourney: DatedServiceJourney
operatingDay: Date
serviceJourney: ServiceJourney
}
type AffectedStopPlace {
quay: Quay
stopConditions: [StopCondition!]!
stopPlace: StopPlace
}
type AffectedStopPlaceOnLine {
line: Line
quay: Quay
stopConditions: [StopCondition!]!
stopPlace: StopPlace
}
type AffectedStopPlaceOnServiceJourney {
datedServiceJourney: DatedServiceJourney
operatingDay: Date
quay: Quay
serviceJourney: ServiceJourney
stopConditions: [StopCondition!]!
stopPlace: StopPlace
}
type AffectedUnknown {
description: String
}
"Authority involved in public transportation. An organisation under which the responsibility of organising the transport service in a certain area is placed."
type Authority {
fareUrl: String
id: ID!
lang: String
lines: [Line]! @timingData
name: String!
phone: String
"Get all situations active for the authority."
situations: [PtSituationElement!]! @timingData
timezone: String!
url: String
}
type BikePark implements PlaceInterface {
id: ID!
latitude: Float
longitude: Float
name: String!
realtime: Boolean
spacesAvailable: Int
}
type BikeRentalStation implements PlaceInterface {
allowDropoff: Boolean
bikesAvailable: Int
id: ID!
latitude: Float
longitude: Float
name: String!
networks: [String]!
realtimeOccupancyAvailable: Boolean
spacesAvailable: Int
}
type BookingArrangement {
"Time constraints for booking"
bookWhen: PurchaseWhen
"Who should ticket be contacted for booking"
bookingContact: Contact
"How should service be booked?"
bookingMethods: [BookingMethod]
"Textual description of booking arrangement for service"
bookingNote: String
"How many days prior to the travel the service needs to be booked"
latestBookingDay: Int
"Latest time the service can be booked. ISO 8601 timestamp"
latestBookingTime: LocalTime
"Minimum period in advance service can be booked as a ISO 8601 duration"
minimumBookingPeriod: String
}
type Branding {
"Description of branding."
description: String
id: ID
"URL to an image be used for branding"
image: String
"Full name to be used for branding."
name: String
"Short name to be used for branding."
shortName: String
"URL to be used for branding"
url: String
}
type Contact {
"Name of person to contact"
contactPerson: String
"Email adress for contact"
email: String
"Textual description of how to get in contact"
furtherDetails: String
"Phone number for contact"
phone: String
"Url for contact"
url: String
}
"A planned journey on a specific day"
type DatedServiceJourney {
"Returns scheduled passingTimes for this dated service journey, updated with real-time-updates (if available). "
estimatedCalls: [EstimatedCall] @timingData
id: ID!
"JourneyPattern for the dated service journey."
journeyPattern: JourneyPattern
"The date this service runs. The date used is based on the service date as opposed to calendar date."
operatingDay: Date
"Quays visited by the dated service journey."
quays(
"Only fetch the first n quays on the service journey"
first: Int,
"Only fetch the last n quays on the service journey"
last: Int
): [Quay!]!
"List of the dated service journeys this dated service journeys replaces"
replacementFor: [DatedServiceJourney!]!
"The service journey this Dated Service Journey is based on"
serviceJourney: ServiceJourney!
"Alterations specified on the Trip in the planned data"
tripAlteration: ServiceAlteration
}
"An advertised destination of a specific journey pattern, usually displayed on a head sign or at other on-board locations."
type DestinationDisplay {
"Name of destination to show on front of vehicle."
frontText: String
"Intermediary destinations which the vehicle will pass before reaching its final destination."
via: [String]
}
"Individual step of an elevation profile."
type ElevationProfileStep {
"The horizontal distance from the start of the step, in meters."
distance: Float
"""
The elevation at this distance, in meters above sea level. It is negative if the
location is below sea level.
"""
elevation: Float
}
"List of visits to quays as part of vehicle journeys. Updated with real time information where available"
type EstimatedCall {
"Actual time of arrival at quay. Updated from real time information if available."
actualArrivalTime: DateTime
"Actual time of departure from quay. Updated with real time information if available."
actualDepartureTime: DateTime
"Scheduled time of arrival at quay. Not affected by read time updated"
aimedArrivalTime: DateTime!
"Scheduled time of departure from quay. Not affected by read time updated"
aimedDepartureTime: DateTime!
"Booking arrangements for this EstimatedCall."
bookingArrangements: BookingArrangement
"Whether stop is cancelled. This means that either the ServiceJourney has a planned cancellation, the ServiceJourney has been cancelled by real-time data, or this particular StopPoint has been cancelled. This also means that both boarding and alighting has been cancelled."
cancellation: Boolean!
"The date the estimated call is valid for."
date: Date!
datedServiceJourney: DatedServiceJourney
destinationDisplay: DestinationDisplay
"Expected time of arrival at quay. Updated with real time information if available. Will be null if an actualArrivalTime exists"
expectedArrivalTime: DateTime!
"Expected time of departure from quay. Updated with real time information if available. Will be null if an actualDepartureTime exists"
expectedDepartureTime: DateTime!
"Whether vehicle may be alighted at quay."
forAlighting: Boolean!
"Whether vehicle may be boarded at quay."
forBoarding: Boolean!
notices: [Notice!]!
occupancyStatus: OccupancyStatus!
"Whether the updated estimates are expected to be inaccurate."
predictionInaccurate: Boolean!
quay: Quay!
"Whether this call has been updated with real time information."
realtime: Boolean!
realtimeState: RealtimeState!
"Whether vehicle will only stop on request."
requestStop: Boolean!
serviceJourney: ServiceJourney!
"Get all relevant situations for this EstimatedCall."
situations: [PtSituationElement!]! @timingData
stopPositionInPattern: Int!
"Whether this is a timing point or not. Boarding and alighting is not allowed at timing points."
timingPoint: Boolean!
}
"Additional (optional) grouping of lines for particular purposes such as e.g. fare harmonisation or public presentation."
type GroupOfLines {
"Description of group of lines"
description: String
id: ID!
"All lines part of this group of lines"
lines: [Line!]!
"Full name for group of lines."
name: String
"For internal use by operator/authority."
privateCode: String
"Short name for group of lines."
shortName: String
}
type Interchange {
FromLine: Line @deprecated(reason : "This is the same as using the `fromServiceJourney { line }` field.")
FromServiceJourney: ServiceJourney @deprecated(reason : "Use fromServiceJourney instead")
ToLine: Line @deprecated(reason : "This is the same as using the `toServiceJourney { line }` field.")
ToServiceJourney: ServiceJourney @deprecated(reason : "Use toServiceJourney instead")
fromServiceJourney: ServiceJourney
guaranteed: Boolean
"Maximum time after scheduled departure time the connecting transport is guaranteed to wait for the delayed trip. [NOT RESPECTED DURING ROUTING, JUST PASSED THROUGH]"
maximumWaitTime: Int
"The transfer priority is used to decide where a transfer should happen, at the highest prioritized location. If the guaranteed flag is set it take precedence priority. A guaranteed ALLOWED transfer is preferred over a PREFERRED none-guaranteed transfer."
priority: InterchangePriority
staySeated: Boolean
toServiceJourney: ServiceJourney
}
type JourneyPattern {
directionType: DirectionType
id: ID!
line: Line!
name: String
notices: [Notice!]!
pointsOnLink: PointsOnLink
"Quays visited by service journeys for this journey patterns"
quays: [Quay!]!
serviceJourneys: [ServiceJourney!]! @timingData
"List of service journeys for the journey pattern for a given date"
serviceJourneysForDate(date: Date): [ServiceJourney!]! @timingData
"Get all situations active for the journey pattern."
situations: [PtSituationElement!]!
"Detailed path travelled by journey pattern divided into stop-to-stop sections."
stopToStopGeometries: [StopToStopGeometry]
}
"Part of a trip pattern. Either a ride on a public transport vehicle or access or path link to/from/between places"
type Leg {
"The aimed date and time this leg ends."
aimedEndTime: DateTime!
"The aimed date and time this leg starts."
aimedStartTime: DateTime!
"For ride legs, the service authority used for this legs. For non-ride legs, null."
authority: Authority
bikeRentalNetworks: [String]!
bookingArrangements: BookingArrangement
"The dated service journey used for this leg."
datedServiceJourney: DatedServiceJourney
"NOT IMPLEMENTED"
directDuration: Long!
"The distance traveled while traversing the leg in meters."
distance: Float!
"The leg's duration in seconds"
duration: Long!
"""
The leg's elevation profile. All elevation values, including the first one, are in meters
above sea level. The elevation is negative for places below sea level. The profile
includes both the start and end coordinate.
"""
elevationProfile: [ElevationProfileStep]!
"The expected, real-time adjusted date and time this leg ends."
expectedEndTime: DateTime!
"The expected, real-time adjusted date and time this leg starts."
expectedStartTime: DateTime!
"EstimatedCall for the quay where the leg originates."
fromEstimatedCall: EstimatedCall @timingData
"The Place where the leg originates."
fromPlace: Place!
"Generalized cost or weight of the leg. Used for debugging."
generalizedCost: Int
"An identifier for the leg, which can be used to re-fetch transit leg information."
id: ID
interchangeFrom: Interchange
interchangeTo: Interchange
"For ride legs, estimated calls for quays between the Place where the leg originates and the Place where the leg ends. For non-ride legs, empty list."
intermediateEstimatedCalls: [EstimatedCall!]! @timingData
"For ride legs, intermediate quays between the Place where the leg originates and the Place where the leg ends. For non-ride legs, empty list."
intermediateQuays: [Quay!]!
"For ride legs, the line. For non-ride legs, null."
line: Line
"The mode of transport or access (e.g., foot) used when traversing this leg."
mode: Mode!
"Fetch the next legs, which can be used to replace this leg. The replacement legs do arrive/depart from/to the same stop places. It might be necessary to change other legs in an itinerary in order to be able to ride the returned legs."
nextLegs(
"Whether the leg should be similar to this leg in some way."
filter: AlternativeLegsFilter = noFilter,
"Number of later legs to return."
next: Int = 1
): [Leg!]
"For ride legs, the operator used for this legs. For non-ride legs, null."
operator: Operator
"The leg's geometry."
pointsOnLink: PointsOnLink
"Fetch the previous legs, which can be used to replace this leg. The replacement legs do arrive/depart from/to the same stop places. It might be necessary to change other legs in an itinerary in order to be able to ride the returned legs."
previousLegs(
"Whether the leg should be similar to this leg in some way."
filter: AlternativeLegsFilter = noFilter,
"Number of earlier legs to return."
previous: Int = 1
): [Leg!]
"Whether there is real-time data about this leg"
realtime: Boolean!
"Whether this leg is with a rented bike."
rentedBike: Boolean
"Whether this leg is a ride leg or not."
ride: Boolean!
"For transit legs, the service date of the trip. For non-transit legs, null."
serviceDate: Date
"For ride legs, the service journey. For non-ride legs, null."
serviceJourney: ServiceJourney
"For ride legs, all estimated calls for the service journey. For non-ride legs, empty list."
serviceJourneyEstimatedCalls: [EstimatedCall!]! @timingData
"All relevant situations for this leg"
situations: [PtSituationElement!]!
"Do we continue from a specified via place"
steps: [PathGuidance]!
"EstimatedCall for the quay where the leg ends."
toEstimatedCall: EstimatedCall @timingData
"The Place where the leg ends."
toPlace: Place!
"The transport sub mode (e.g., localBus or expressBus) used when traversing this leg. Null if leg is not a ride"
transportSubmode: TransportSubmode
"Whether this leg is walking with a bike."
walkingBike: Boolean
}
"A group of routes which is generally known to the public by a similar name or number"
type Line {
authority: Authority
bikesAllowed: BikesAllowed
"Booking arrangements for flexible line."
bookingArrangements: BookingArrangement @deprecated(reason : "BookingArrangements are defined per stop, and can be found under `passingTimes` or `estimatedCalls`")
branding: Branding
description: String
"Type of flexible line, or null if line is not flexible."
flexibleLineType: String
"Groups of lines that line is a part of."
groupOfLines: [GroupOfLines]!
id: ID!
journeyPatterns: [JourneyPattern]
name: String
notices: [Notice!]!
operator: Operator
presentation: Presentation
"Publicly announced code for line, differentiating it from other lines for the same operator."
publicCode: String
quays: [Quay]!
serviceJourneys: [ServiceJourney]!
"Get all situations active for the line."
situations: [PtSituationElement!]!
transportMode: TransportMode
transportSubmode: TransportSubmode
url: String
}
"Text with language"
type MultilingualString {
language: String
value: String!
}
type Notice {
id: ID!
publicCode: String
text: String
}
"Organisation providing public transport services."
type Operator {
id: ID!
lines: [Line]! @timingData
name: String!
phone: String
serviceJourney: [ServiceJourney]! @timingData
url: String
}
"Information about pagination in a connection."
type PageInfo {
"When paginating forwards, the cursor to continue."
endCursor: String
"When paginating forwards, are there more items?"
hasNextPage: Boolean!
"When paginating backwards, are there more items?"
hasPreviousPage: Boolean!
"When paginating backwards, the cursor to continue."
startCursor: String
}
"A series of turn by turn instructions used for walking, biking and driving."
type PathGuidance {
"This step is on an open area, such as a plaza or train platform, and thus the directions should say something like \"cross\""
area: Boolean
"The name of this street was generated by the system, so we should only display it once, and generally just display right/left directions"
bogusName: Boolean
"The distance in meters that this step takes."
distance: Float
"""
The step's elevation profile. All elevation values, including the first one, are in meters
above sea level. The elevation is negative for places below sea level. The profile
includes both the start and end coordinate.
"""
elevationProfile: [ElevationProfileStep]!
"When exiting a highway or traffic circle, the exit name/number."
exit: String
"The absolute direction of this step."
heading: AbsoluteDirection
"The latitude of the step."
latitude: Float
"The longitude of the step."
longitude: Float
"The relative direction of this step."
relativeDirection: RelativeDirection
"Indicates whether or not a street changes direction at an intersection."
stayOn: Boolean
"The name of the street."
streetName: String
}
"Common super class for all places (stop places, quays, car parks, bike parks and bike rental stations )"
type Place {
"The bike rental station related to the place"
bikeRentalStation: BikeRentalStation
"The flexible area related to the place."
flexibleArea: Coordinates
"The latitude of the place."
latitude: Float!
"The longitude of the place."
longitude: Float!
"For transit quays, the name of the quay. For points of interest, the name of the POI."
name: String
"The quay related to the place."
quay: Quay
"The rental vehicle related to the place"
rentalVehicle: RentalVehicle
"Type of vertex. (Normal, Bike sharing station, Bike P+R, Transit quay) Mostly used for better localization of bike sharing and P+R station names"
vertexType: VertexType
}
type PlaceAtDistance {
distance: Float
id: ID! @deprecated(reason : "Id is not referable or meaningful and will be removed")
place: PlaceInterface
}
"A list of coordinates encoded as a polyline string (see http://code.google.com/apis/maps/documentation/polylinealgorithm.html)"
type PointsOnLink {
"The number of points in the string"
length: Int
"The encoded points of the polyline. Be aware that the string could contain escape characters that need to be accounted for. (https://www.freeformatter.com/javascript-escape.html)"
points: String
}
"Types describing common presentation properties"
type Presentation {
colour: String
textColour: String
}
"Simple public transport situation element"
type PtSituationElement {
"Advice of situation in all different translations available"
advice: [MultilingualString!]!
"Get all affected entities for the situation"
affects: [Affects!]!
"Get affected authority for this situation element"
authority: Authority @deprecated(reason : "Use affects instead")
"Timestamp for when the situation was created."
creationTime: DateTime
"Description of situation in all different translations available"
description: [MultilingualString!]!
id: ID!
"Optional links to more information."
infoLinks: [infoLink!]
lines: [Line]! @deprecated(reason : "Use affects instead")
"Codespace of the data source."
participant: String
"Priority of this situation "
priority: Int
quays: [Quay!]! @deprecated(reason : "Use affects instead")
"Authority that reported this situation. Always returns the first agency in the codespace"
reportAuthority: Authority @deprecated(reason : "Not yet officially supported. May be removed or renamed.")
"ReportType of this situation"
reportType: ReportType
serviceJourneys: [ServiceJourney]! @deprecated(reason : "Use affects instead")
"Severity of this situation "
severity: Severity
"Operator's internal id for this situation"
situationNumber: String
stopPlaces: [StopPlace!]! @deprecated(reason : "Use affects instead")
"Summary of situation in all different translations available"
summary: [MultilingualString!]!
"Period this situation is in effect"
validityPeriod: ValidityPeriod
"Operator's version number for the situation element."
version: Int
"Timestamp when the situation element was updated."
versionedAtTime: DateTime
}
"A place such as platform, stance, or quayside where passengers have access to PT vehicles."
type Quay implements PlaceInterface {
description: String
"List of visits to this quay as part of vehicle journeys."
estimatedCalls(
"Filters results by either departures, arrivals or both. For departures forBoarding has to be true and the departure time has to be within the specified time range. For arrivals, forAlight has to be true and the arrival time has to be within the specified time range. If both are asked for, either the conditions for arrivals or the conditions for departures will have to be true for an EstimatedCall to show."
arrivalDeparture: ArrivalDeparture = departures,
"Indicates that real-time-cancelled trips should also be included."
includeCancelledTrips: Boolean = false,
"Limit the total number of departures returned."
numberOfDepartures: Int = 5,
"Limit the number of departures per line and destination display returned. The parameter is only applied when the value is between 1 and 'numberOfDepartures'."
numberOfDeparturesPerLineAndDestinationDisplay: Int,
omitNonBoarding: Boolean = false @deprecated(reason : "Non-functional. Use arrivalDeparture instead."),
"DateTime for when to fetch estimated calls from. Default value is current time"
startTime: DateTime,
"Duration in seconds from start time to search forward for estimated calls. Must be a positive value. Default value is 24 hours"
timeRange: Int = 86400,
"Parameters for indicating the only authorities and/or lines or quays to list estimatedCalls for"
whiteListed: InputWhiteListed,
"Only show estimated calls for selected modes."
whiteListedModes: [TransportMode]
): [EstimatedCall!]! @timingData
"Geometry for flexible area."
flexibleArea: Coordinates
"the Quays part of a flexible group."
flexibleGroup: [Quay]
id: ID!
"List of journey patterns servicing this quay"
journeyPatterns: [JourneyPattern]! @timingData
latitude: Float
"List of lines servicing this quay"
lines: [Line!]! @timingData
longitude: Float
name(
"Fetch the name in the language given. The language should be represented as a ISO-639 language code. If the translation does not exits, the default name is returned."
lang: String @deprecated(reason : "Use 'language' instead"),
"Fetch the name in the language given. The language should be represented as a ISO-639 language code. If the translation does not exits, the default name is returned."
language: String
): String!
"Public code used to identify this quay within the stop place. For instance a platform code."
publicCode: String
"Get all situations active for the quay."
situations: [PtSituationElement!]!
"The stop place to which this quay belongs to."
stopPlace: StopPlace
stopType: String
tariffZones: [TariffZone]!
timeZone: String
"Whether this quay is suitable for wheelchair boarding."
wheelchairAccessible: WheelchairBoarding
}
type QuayAtDistance {
"The distance in meters to the given quay."
distance: Float
id: ID!
quay: Quay
}
type QueryType {
"Get all authorities"
authorities: [Authority]! @timingData
"Get an authority by ID"
authority(id: String!): Authority @timingData
"Get a single bike park based on its id"
bikePark(id: String!): BikePark @timingData
"Get all bike parks"
bikeParks: [BikePark]! @timingData
"Get all bike rental stations"
bikeRentalStation(id: String!): BikeRentalStation @timingData
"Get all bike rental stations"
bikeRentalStations(ids: [String]): [BikeRentalStation]! @timingData
"Get all bike rental stations within the specified bounding box."
bikeRentalStationsByBbox(maximumLatitude: Float, maximumLongitude: Float, minimumLatitude: Float, minimumLongitude: Float): [BikeRentalStation]! @timingData
"Get a single dated service journey based on its id"
datedServiceJourney(id: String): DatedServiceJourney
"Get all dated service journeys, matching the filters"
datedServiceJourneys(
alterations: [ServiceAlteration!],
authorities: [String!],
lines: [String!],
operatingDays: [Date!]!,
privateCodes: [String!],
"Get all DatedServiceJourneys, which are replacing any of the given DatedServiceJourneys ids"
replacementFor: [String!],
serviceJourneys: [String!]
): [DatedServiceJourney!]!
"Get a single group of lines based on its id"
groupOfLines(id: String!): GroupOfLines
"Get all groups of lines"
groupsOfLines: [GroupOfLines!]!
"Refetch a single transit leg based on its id"
leg(id: ID!): Leg @timingData
"Get a single line based on its id"
line(id: ID!): Line @timingData
"Get all _lines_"
lines(
"Set of ids of _authorities_ to fetch _lines_ for."
authorities: [String],
"Filter by _lines_ containing flexible / on demand _service journey_ only."
flexibleOnly: Boolean = false,
"Set of ids of _lines_ to fetch. If this is set, no other filters can be set."
ids: [ID],
"Prefix of the _name_ of the _line_ to fetch. This filter is case insensitive."
name: String,
"_Public code_ of the _line_ to fetch."
publicCode: String,
"Set of _public codes_ to fetch _lines_ for."
publicCodes: [String],
"Set of _transport modes_ to fetch _lines_ for."
transportModes: [TransportMode]
): [Line]! @timingData
"Get all places (quays, stop places, car parks etc. with coordinates) within the specified radius from a location. The returned type has two fields place and distance. The search is done by walking so the distance is according to the network of walkables."
nearest(
"fetching only nodes after this node (exclusive)"
after: String,
"fetching only nodes before this node (exclusive)"
before: String,
"Only include places that match one of the given ids."
filterByIds: InputPlaceIds,
"Only affects queries for quays and stop places. If true only quays and stop places with at least one visiting line are included."
filterByInUse: Boolean = false,
"Only include places that include this mode. Only checked for places with mode i.e. quays, departures."
filterByModes: [TransportMode],
"Only include places of given types if set. Default accepts all types"
filterByPlaceTypes: [FilterPlaceType] = [quay, stopPlace, bicycleRent, bikePark, carPark],
"fetching only the first certain number of nodes"
first: Int,
"fetching only the last certain number of nodes"
last: Int,
"Latitude of the location"
latitude: Float!,
"Longitude of the location"
longitude: Float!,
"Maximum distance (in meters) to search for from the specified location. Default is 2000m."
maximumDistance: Float! = 2000.0,
"Maximum number of results. Search is stopped when this limit is reached. Default is 20."
maximumResults: Int = 20,
"MultiModalMode for query. To control whether multi modal parent stop places, their mono modal children or both are included in the response. Does not affect mono modal stop places that do not belong to a multi modal stop place. Only applicable for placeType StopPlace"
multiModalMode: MultiModalMode = parent
): placeAtDistanceConnection @timingData
"Get a operator by ID"
operator(id: String!): Operator @timingData
"Get all operators"
operators: [Operator]! @timingData
"Get a single quay based on its id)"
quay(id: String!): Quay @timingData
"Get all quays"
quays(ids: [String], name: String): [Quay]! @timingData
"Get all quays within the specified bounding box"
quaysByBbox(
authority: String @deprecated(reason : "This is the Transmodel namespace or the GTFS feedID - avoid using this. Request a new field if necessary."),
"If true only quays with at least one visiting line are included."
filterByInUse: Boolean = false,
maximumLatitude: Float!,
maximumLongitude: Float!,
minimumLatitude: Float!,
minimumLongitude: Float!
): [Quay]! @timingData
"Get all quays within the specified walking radius from a location. There are no maximum limits for the input parameters, but the query will timeout and return if the parameters are too high."
quaysByRadius(
"fetching only nodes after this node (exclusive)"
after: String,
authority: String,
"fetching only nodes before this node (exclusive)"
before: String,
"fetching only the first certain number of nodes"
first: Int,
"fetching only the last certain number of nodes"
last: Int,
"Latitude of the location"
latitude: Float!,
"Longitude of the location"
longitude: Float!,
"Radius via streets (in meters) to search for from the specified location"
radius: Float!
): quayAtDistanceConnection @timingData
"Get default routing parameters."
routingParameters: RoutingParameters @timingData
"Get OTP deployment information. This is only useful for developers of OTP itself not regular API users."
serverInfo: ServerInfo! @timingData
"Get a single service journey based on its id"
serviceJourney(id: String!): ServiceJourney @timingData
"Get all _service journeys_"
serviceJourneys(
"Set of _operating days_ to fetch _service journeys_ for."
activeDates: [Date],
"Set of ids of _authorities_ to fetch _service journeys_ for."
authorities: [String],
"Set of ids of _lines_ to fetch _service journeys_ for."
lines: [ID],
"Set of ids of _private codes_ to fetch _service journeys_ for."
privateCodes: [String]
): [ServiceJourney]! @timingData
"Get a single situation based on its situationNumber"
situation(situationNumber: String!): PtSituationElement @timingData
"Get all active situations."
situations(
"Filter by reporting authorities."
authorities: [String] @deprecated(reason : "Use codespaces instead. This only uses the codespace of the given authority."),
"Filter by reporting source."
codespaces: [String],
"Filter by severity."
severities: [Severity]
): [PtSituationElement!]! @timingData
"Get a single stopPlace based on its id)"
stopPlace(id: String!): StopPlace @timingData
"Get all stopPlaces"
stopPlaces(ids: [String]): [StopPlace]! @timingData
"Get all stop places within the specified bounding box"
stopPlacesByBbox(
authority: String,
"If true only stop places with at least one visiting line are included."
filterByInUse: Boolean = false,
maximumLatitude: Float!,
maximumLongitude: Float!,
minimumLatitude: Float!,
minimumLongitude: Float!,
"MultiModalMode for query. To control whether multi modal parent stop places, their mono modal children or both are included in the response. Does not affect mono modal stop places that do not belong to a multi modal stop place."
multiModalMode: MultiModalMode = parent
): [StopPlace]! @timingData
"Input type for executing a travel search for a trip between two locations. Returns trip patterns describing suggested alternatives for the trip."
trip(
"Time and cost penalty on access/egress modes."
accessEgressPenalty: [PenaltyForStreetMode!] = [{streetMode : car_park, timePenalty : "20m + 2.0 t", costFactor : 1.5}, {streetMode : car_pickup, timePenalty : "20m + 2.0 t", costFactor : 1.5}, {streetMode : car_rental, timePenalty : "20m + 2.0 t", costFactor : 1.5}, {streetMode : flexible, timePenalty : "10m + 1.30 t", costFactor : 1.3}],
"The alightSlack is the minimum extra time after exiting a public transport vehicle. This is the default value used, if not overridden by the 'alightSlackList'."
alightSlackDefault: Int = 0,
"List of alightSlack for a given set of modes. Defaults: []"
alightSlackList: [TransportModeSlack],
"Whether the trip should depart at dateTime (false, the default), or arrive at dateTime. See `timetableView` for use-cases where this parameter is relevant."
arriveBy: Boolean = false,
"Parameters for indicating authorities, lines or quays not be used in the trip patterns"
banned: InputBanned,
"The set of characteristics that the user wants to optimise for during bicycle searches -- defaults to safe"
bicycleOptimisationMethod: BicycleOptimisationMethod = safe,
"The maximum bike speed along streets, in meters per second"
bikeSpeed: Float = 5.0,
"The boardSlack is the minimum extra time to board a public transport vehicle. This is the same as the 'minimumTransferTime', except that this also applies to to the first transit leg in the trip. This is the default value used, if not overridden by the 'boardSlackList'."
boardSlackDefault: Int = 0,
"List of boardSlack for a given set of modes. Defaults: []"
boardSlackList: [TransportModeSlack],
"""
The date and time for the latest time the user is expected to book the journey.
Normally this is when the search is performed (now), plus a small grace period to
complete the booking. Services which must be booked before this time is excluded. The
`latestBookingTime` and `minimumBookingPeriod` in `BookingArrangement` (flexible
services only) is used to enforce this. If this parameter is _not set_, no booking-time
restrictions are applied - all journeys are listed.
"""
bookingTime: DateTime,
"The date and time for the earliest time the user is willing to start the journey (if `false` or not set) or the latest acceptable time of arriving (`true`). Defaults to now."
dateTime: DateTime,
"Debug the itinerary-filter-chain. OTP will attach a system notice to itineraries instead of removing them. This is very convenient when tuning the filters."
debugItineraryFilter: Boolean = false @deprecated(reason : "Use `itineraryFilter.debug` instead."),
"A list of filters for which trips should be included. A trip will be included if it matches with at least one filter. An empty list of filters means that all trips should be included. If a search include this parameter, \"whiteListed\", \"banned\" & \"modes.transportModes\" filters will be ignored."
filters: [TripFilterInput!],
"The start location"
from: Location!,
"When true, real-time updates are ignored during this search."
ignoreRealtimeUpdates: Boolean = false,
"When true, service journeys cancelled in scheduled route data will be included during this search."
includePlannedCancellations: Boolean = false,
"When true, service journeys cancelled by real-time updates will be included during this search."
includeRealtimeCancellations: Boolean = false,
"Configure the itinerary-filter-chain. NOTE! THESE PARAMETERS ARE USED FOR SERVER-SIDE TUNING AND IS AVAILABLE HERE FOR TESTING ONLY."
itineraryFilters: ItineraryFilters,
"The preferable language to use for text targeted the end user. Note! The data quality is limited, only stop and quay names are translates, and not in all places of the API."
locale: Locale = no,
"Maximum duration for access/egress for street searches per respective mode. Cannot be higher than default value. This is a performance optimisation parameter, avoid using it to limit the search. "
maxAccessEgressDurationForMode: [StreetModeDurationInput!] = [],
"Maximum duration for direct street searchers per respective mode. Cannot be higher than default value. This is a performance optimisation parameter, avoid using it to limit the search."
maxDirectDurationForMode: [StreetModeDurationInput!] = [],
"Maximum number of additional transfers compared to the best number of transfers allowed. Note! The best way to reduce the number of transfers is to set the `transferPenalty` parameter."
maximumAdditionalTransfers: Int = 5,
"Maximum number of transfers. Note! The best way to reduce the number of transfers is to set the `transferPenalty` parameter."
maximumTransfers: Int = 12,
"The set of access/egress/direct/transit modes to be used for this search. Note that this only works at the Line level. If individual ServiceJourneys have modes that differ from the Line mode, this will NOT be accounted for."
modes: Modes,
"The maximum number of trip patterns to return. Note! This reduce the number of trip patterns AFTER the OTP travel search is done in a post-filtering process. There is little/no performance gain in reducing the number of trip patterns returned. See also the trip meta-data on how to implement paging."
numTripPatterns: Int = 50,
"""
Use the cursor to go to the next "page" of itineraries. Copy the cursor from the last
response and keep the original request as is. This will enable you to search for
itineraries in the next or previous search-window. The paging will automatically scale
up/down the search-window to fit the `numTripPatterns`.
"""
pageCursor: String,
"The list of points the journey is required to pass through."
passThroughPoints: [PassThroughPoint!] @deprecated(reason : "Use via instead"),
"""
Relax generalized-cost when comparing trips with a different set of
transit-group-priorities. The groups are set server side for service-journey and
can not be configured in the API. This mainly helps to return competition neutral
services. Long distance authorities are put in different transit-groups.
This relaxes the comparison inside the routing engine for each stop-arrival. If two
paths have a different set of transit-group-priorities, then the generalized-cost
comparison is relaxed. The final set of paths are filtered through the normal
itinerary-filters.
- The `ratio` must be greater or equal to 1.0 and less then 1.2.
- The `constant` must be greater or equal to '0s' and less then '1h'.
THIS IS STILL AN EXPERIMENTAL FEATURE - IT MAY CHANGE WITHOUT ANY NOTICE!
"""
relaxTransitGroupPriority: RelaxCostInput = null,
"""
Whether non-optimal transit paths at the destination should be returned. Let c be the
existing minimum pareto optimal generalized-cost to beat. Then a trip with cost c' is
accepted if the following is true:
`c' < Math.round(c * relaxTransitSearchGeneralizedCostAtDestination)`
The parameter is optional. If not set, a normal comparison is performed.
Values less than 1.0 is not allowed, and values greater than 2.0 are not
supported, due to performance reasons.
"""
relaxTransitSearchGeneralizedCostAtDestination: Float = null @deprecated(reason : "This is replaced by 'relaxTransitGroupPriority'."),
"""
The length of the search-window in minutes. This parameter is optional.
The search-window is defined as the duration between the earliest-departure-time(EDT) and
the latest-departure-time(LDT). OTP will search for all itineraries in this departure
window. If `arriveBy=true` the `dateTime` parameter is the latest-arrival-time, so OTP
will dynamically calculate the EDT. Using a short search-window is faster than using a
longer one, but the search duration is not linear. Using a "too" short search-window will
waste resources server side, while using a search-window that is too long will be slow.
OTP will dynamically calculate a reasonable value for the search-window, if not provided. The
calculation comes with a significant overhead (10-20% extra). Whether you should use the
dynamic calculated value or pass in a value depends on your use-case. For a travel planner
in a small geographical area, with a dense network of public transportation, a fixed value
between 40 minutes and 2 hours makes sense. To find the appropriate search-window, adjust it
so that the number of itineraries on average is around the wanted `numTripPatterns`. Make
sure you set the `numTripPatterns` to a high number while testing. For a country wide area like
Norway, using the dynamic search-window is the best.
When paginating, the search-window is calculated using the `numTripPatterns` in the original
search together with statistics from the search for the last page. This behaviour is
configured server side, and can not be overridden from the client. The paging may even
exceed the maximum value.
The search-window used is returned to the response metadata as `searchWindowUsed`.
This can be used by the client to calculate the when the next page start/end.
Note! In some cases you may have to page many times to get all the results you want.
This is intended. Increasing the search-window beyond the max value is NOT going to be
much faster. Instead the client can inform the user about the progress.
Maximum value: 1440 minutes (24h)
"""
searchWindow: Int,
"""
Search for the best trip options within a time window. If `true` two TripPatterns are considered optimal if one is better on arrival time(earliest wins) and the other is better on departure time(latest wins).In combination with `arriveBy` this parameter cover the following 3 use cases:
- Traveler want to find the best alternative within a time window. Set `timetableView=true` and `arriveBy=false`. This is the default, and if the intention of the traveler is unknown it gives the best result, because it includes the two next use-cases. This option also work well with paging. Setting the `arriveBy=true`, covers the same use-case, but the input time is interpreted as latest-arrival-time, and not earliest-departure-time.
- Traveler want to find the best alternative with departure after a specific time. For example: I am at the station now and want to get home as quickly as possible. Set `timetableView=false` and `arriveBy=false`. Do not support paging.
- Traveler want to find the best alternative with arrival before a specific time. For example going to a meeting. Set `timetableView=false` and `arriveBy=true`. Do not support paging.
Default: `true`
"""
timetableView: Boolean,
"The destination location"
to: Location!,
"An extra penalty added on transfers (i.e. all boardings except the first one). The transferPenalty is used when a user requests even less transfers. In the latter case, we don't actually optimise for fewest transfers, as this can lead to absurd results. Consider a trip in New York from Grand Army Plaza (the one in Brooklyn) to Kalustyan's at noon. The true lowest transfers trip pattern is to wait until midnight, when the 4 train runs local the whole way. The actual fastest trip pattern is the 2/3 to the 4/5 at Nevins to the 6 at Union Square, which takes half an hour. Even someone optimise for fewest transfers doesn't want to wait until midnight. Maybe they would be willing to walk to 7th Ave and take the Q to Union Square, then transfer to the 6. If this takes less than transferPenalty seconds, then that's what we'll return."
transferPenalty: Int = 0,
"An expected transfer time (in seconds) that specifies the amount of time that must pass between exiting one public transport vehicle and boarding another. This time is in addition to time it might take to walk between stops."
transferSlack: Int = 120,
"When setting the BicycleOptimisationMethod to 'triangle', use these values to tell the routing engine how important each of the factors is compared to the others. All values should add up to 1."
triangleFactors: TriangleFactors,
"Whether or not bike rental availability information will be used to plan bike rental trips."
useBikeRentalAvailabilityInformation: Boolean = false,
"""
The list of via locations the journey is required to visit. All locations are
visited in the order they are listed.
"""
via: [TripViaLocationInput!],
"Wait cost is multiplied by this value. Setting this to a value lower than 1 indicates that waiting is better than staying on a vehicle. This should never be set higher than walkReluctance, since that would lead to walking down a line to avoid waiting."
waitReluctance: Float = 1.0,
"Walk cost is multiplied by this value. This is the main parameter to use for limiting walking."
walkReluctance: Float = 2.0,
"The maximum walk speed along streets, in meters per second."
walkSpeed: Float = 1.33,
"Whether the trip must be wheelchair accessible. Supported for the street part to the search, not implemented for the transit yet."
wheelchairAccessible: Boolean = false,
"Parameters for indicating the only authorities, lines or quays to be used in the trip patterns"
whiteListed: InputWhiteListed
): Trip! @timingData
"Via trip search. Find trip patterns traveling via one or more intermediate (via) locations."
viaTrip(
"Date and time for the earliest time the user is willing to start the journey (if arriveBy=false/not set) or the latest acceptable time of arriving (arriveBy=true). Defaults to now"
dateTime: DateTime,
"The start location"
from: Location!,
"The preferable language to use for text targeted the end user. Note! The data quality is limited, only stop and quay names are translates, and not in all places of the API."
locale: Locale = no,
"The maximum number of trip patterns segment to return. Note! This reduces the number of trip patterns AFTER the OTP travel search is done in a post-filtering process. There is little/no performance gain in reducing the number of trip patterns returned. See also the trip meta-data on how to implement paging."
numTripPatterns: Int = 50,
"Use the cursor to go to the next \"page\" of itineraries. Copy the cursor from the last response and keep the original request as is. This will enable you to search for itineraries in the next or previous time-window."
pageCursor: String,
"""
The length of the search-window. This parameter is optional.
The search-window is defined as the duration between the earliest-departure-time(EDT) and the latest-departure-time(LDT). OTP will search for all itineraries in this departure window. If `arriveBy=true` the `dateTime` parameter is the latest-arrival-time, so OTP will dynamically calculate the EDT. Using a short search-window is faster than using a longer one, but the search duration is not linear. Using a "too" short search-window will waste resources server side, while using a search-window that is too long will be slow.
OTP will dynamically calculate a reasonable value for the search-window, if not provided. The calculation comes with a significant overhead (10-20% extra). Whether you should use the dynamic calculated value or pass in a value depends on your use-case. For a travel planner in a small geographical area, with a dense network of public transportation, a fixed value between 40 minutes and 2 hours makes sense. To find the appropriate search-window, adjust it so that the number of itineraries on average is around the wanted `numItineraries`. Make sure you set the `numItineraries` to a high number while testing. For a country wide area like Norway, using the dynamic search-window is the best.
When paginating, the search-window is calculated using the `numItineraries` in the original search together with statistics from the search for the last page. This behaviour is configured server side, and can not be overridden from the client.
The search-window used is returned to the response metadata as `searchWindowUsed` for debugging purposes.
"""
searchWindow: Duration!,
"The requests for the individual segments of the search. The first segment is from the start location(`from`) to the first entry in the `via` locations list and the last is from the last entry in the `via` locations list to the end location(`to`). Note that the list must have length of exactly one greater than the `via` field."
segments: [ViaSegmentInput!],
"The destination location"
to: Location!,
"The locations needed to be visited along the route."
via: [ViaLocationInput!]!,
"Whether the trip must be wheelchair accessible. Supported for the street part to the search, not implemented for the transit yet."
wheelchairAccessible: Boolean = false
): ViaTrip! @deprecated(reason : "Use the regular trip query with via stop instead.") @timingData
}
type RentalVehicle implements PlaceInterface {
currentRangeMeters: Float
id: ID!
latitude: Float!
longitude: Float!
network: String!
vehicleType: RentalVehicleType!
}
type RentalVehicleType {
formFactor: String!
maxRangeMeters: Float
name: String
propulsionType: String!
vehicleTypeId: String!
}
"Description of the reason, why the planner did not return any results"
type RoutingError {
"An enum describing the reason"
code: RoutingErrorCode!
"A textual description of why the search failed. The clients are expected to have their own translations based on the code, for user visible error messages."
description: String!
"An enum describing the field which should be changed, in order for the search to succeed"
inputField: InputField
}
"The default parameters used in travel searches."
type RoutingParameters {
"The alightSlack is the minimum extra time after exiting a public transport vehicle. This is the default value used, if not overridden by the 'alightSlackList'."
alightSlackDefault: Int
"List of alightSlack for a given set of modes."
alightSlackList: [TransportModeSlackType]
allowBikeRental: Boolean @deprecated(reason : "Rental is specified by modes")
"Separate cost for boarding a vehicle with a bicycle, which is more difficult than on foot."
bikeBoardCost: Int
"Cost to park a bike."
bikeParkCost: Int
"Time to park a bike."
bikeParkTime: Int
"Cost to drop-off a rented bike."
bikeRentalDropOffCost: Int
"Time to drop-off a rented bike."
bikeRentalDropOffTime: Int
"Cost to rent a bike."
bikeRentalPickupCost: Int
"Time to rent a bike."
bikeRentalPickupTime: Int
"Max bike speed along streets, in meters per second"
bikeSpeed: Float
"The boardSlack is the minimum extra time to board a public transport vehicle. This is the same as the 'minimumTransferTime', except that this also applies to to the first transit leg in the trip. This is the default value used, if not overridden by the 'boardSlackList'."
boardSlackDefault: Int
"List of boardSlack for a given set of modes."
boardSlackList: [TransportModeSlackType]
"The acceleration speed of an automobile, in meters per second per second."
carAccelerationSpeed: Float
"The deceleration speed of an automobile, in meters per second per second."
carDecelerationSpeed: Float
"Time to park a car in a park and ride, w/o taking into account driving and walking cost."
carDropOffTime: Int
"Max car speed along streets, in meters per second"
carSpeed: Float @deprecated(reason : "This parameter is no longer configurable.")
compactLegsByReversedSearch: Boolean @deprecated(reason : "NOT IN USE IN OTP2.")
debugItineraryFilter: Boolean @deprecated(reason : "Use `itineraryFilter.debug` instead.")
"Option to disable the default filtering of GTFS-RT alerts by time."
disableAlertFiltering: Boolean @deprecated(reason : "This is not supported!")
"If true, the remaining weight heuristic is disabled."
disableRemainingWeightHeuristic: Boolean
"What is the cost of boarding a elevator?"
elevatorBoardCost: Int
"How long does it take to get on an elevator, on average."
elevatorBoardTime: Int
"What is the cost of travelling one floor on an elevator?"
elevatorHopCost: Int
"How long does it take to advance one floor on an elevator?"
elevatorHopTime: Int
"Whether to apply the ellipsoid->geoid offset to all elevations in the response."
geoIdElevation: Boolean
"When true, real-time updates are ignored during this search."
ignoreRealTimeUpdates: Boolean
"When true, service journeys cancelled in scheduled route data will be included during this search."
includedPlannedCancellations: Boolean
kissAndRide: Boolean @deprecated(reason : "Parking is specified by modes")
"Maximum number of transfers allowed in addition to the result with least number of transfers"
maxAdditionalTransfers: Int
"This is the maximum duration in seconds for a direct street search. This is a performance limit and should therefore be set high. Use filters to limit what is presented to the client."
maxDirectStreetDuration: Int
"The maximum slope of streets for wheelchair trips."
maxSlope: Float
"Maximum number of transfers returned in a trip plan."
maxTransfers: Int
"The maximum number of itineraries to return."
numItineraries: Int
"Accept only paths that use transit (no street-only paths)."
onlyTransitTrips: Boolean @deprecated(reason : "This is replaced by modes input object")
"Penalty added for using every route that is not preferred if user set any route as preferred. We return number of seconds that we are willing to wait for preferred route."
otherThanPreferredRoutesPenalty: Int
parkAndRide: Boolean @deprecated(reason : "Parking is specified by modes")
reverseOptimizeOnTheFly: Boolean @deprecated(reason : "NOT IN USE IN OTP2.")
"Whether the planner should return intermediate stops lists for transit legs."
showIntermediateStops: Boolean @deprecated(reason : "This parameter is always enabled")
"Used instead of walkReluctance for stairs."
stairsReluctance: Float
"An extra penalty added on transfers (i.e. all boardings except the first one)."
transferPenalty: Int
"A global minimum transfer time (in seconds) that specifies the minimum amount of time that must pass between exiting one transit vehicle and boarding another."
transferSlack: Int
"Multiplicative factor on expected turning time."
turnReluctance: Float
"How much worse is waiting for a transit vehicle than being on a transit vehicle, as a multiplier."
waitReluctance: Float
"This prevents unnecessary transfers by adding a cost for boarding a vehicle."
walkBoardCost: Int
"A multiplier for how bad walking is, compared to being in transit for equal lengths of time."
walkReluctance: Float
"Max walk speed along streets, in meters per second"
walkSpeed: Float
"Whether the trip must be wheelchair accessible."
wheelChairAccessible: Boolean
}
"""
Information about the deployment. This is only useful to developers of OTP itself.
It is not recommended for regular API consumers to use this type as it has no
stability guarantees.
"""
type ServerInfo {
"The 'configVersion' of the build-config.json file."
buildConfigVersion: String
"OTP Build timestamp"
buildTime: String
gitBranch: String
gitCommit: String
gitCommitTime: String
"""
The internal time zone of the transit data.
Note: The input data can be in several time zones, but OTP internally operates on a single one.
"""
internalTransitModelTimeZone: String
"The 'configVersion' of the otp-config.json file."
otpConfigVersion: String
"The otp-serialization-version-id used to check graphs for compatibility with current version of OTP."
otpSerializationVersionId: String
"The 'configVersion' of the router-config.json file."
routerConfigVersion: String
"Maven version"
version: String
}
"A planned vehicle journey with passengers."
type ServiceJourney {
activeDates: [Date]! @timingData
"Whether bikes are allowed on service journey."
bikesAllowed: BikesAllowed
"Booking arrangements for flexible services."
bookingArrangements: BookingArrangement @deprecated(reason : "BookingArrangements are defined per stop, and can be found under `passingTimes` or `estimatedCalls`")
directionType: DirectionType
"Returns scheduled passingTimes for this ServiceJourney for a given date, updated with real-time-updates (if available). NB! This takes a date as argument (default=today) and returns estimatedCalls for that date and should only be used if the date is known when creating the request. For fetching estimatedCalls for a given trip.leg, use leg.serviceJourneyEstimatedCalls instead."
estimatedCalls(
"Date to get estimated calls for. Defaults to today."
date: Date
): [EstimatedCall] @timingData
id: ID!
"JourneyPattern for the service journey, according to scheduled data. If the ServiceJourney is not included in the scheduled data, null is returned."
journeyPattern: JourneyPattern
line: Line!
notices: [Notice!]!
operator: Operator
"Returns scheduled passing times only - without real-time-updates, for realtime-data use 'estimatedCalls'"
passingTimes: [TimetabledPassingTime]! @timingData
"Detailed path travelled by service journey. Not available for flexible trips."
pointsOnLink: PointsOnLink
"For internal use by operators."
privateCode: String
"Publicly announced code for service journey, differentiating it from other service journeys for the same line."
publicCode: String
"Quays visited by service journey, according to scheduled data. If the ServiceJourney is not included in the scheduled data, an empty list is returned."
quays(
"Only fetch the first n quays on the service journey"
first: Int,
"Only fetch the last n quays on the service journey"
last: Int
): [Quay!]!
serviceAlteration: ServiceAlteration @deprecated(reason : "The service journey alteration will be moved out of SJ and grouped together with the SJ and date. In Netex this new type is called DatedServiceJourney. We will create artificial DSJs for the old SJs.")
"Get all situations active for the service journey."
situations: [PtSituationElement!]!
transportMode: TransportMode
transportSubmode: TransportSubmode
"Whether service journey is accessible with wheelchair."
wheelchairAccessible: WheelchairBoarding
}
"Named place where public transport may be accessed. May be a building complex (e.g. a station) or an on-street location."
type StopPlace implements PlaceInterface {
description: String
"List of visits to this stop place as part of vehicle journeys."
estimatedCalls(
arrivalDeparture: ArrivalDeparture = departures,
"Indicates that real-time-cancelled trips should also be included."
includeCancelledTrips: Boolean = false,
"Limit the total number of departures returned."
numberOfDepartures: Int = 5,
"Limit the number of departures per line and destination display returned. The parameter is only applied when the value is between 1 and 'numberOfDepartures'."
numberOfDeparturesPerLineAndDestinationDisplay: Int,
"DateTime for when to fetch estimated calls from. Default value is current time"
startTime: DateTime,
"Duration in seconds from start time to search forward for estimated calls. Must be a positive value. Default value is 24 hours"
timeRange: Int = 86400,
"Parameters for indicating the only authorities and/or lines or quays to list estimatedCalls for"
whiteListed: InputWhiteListed,
"Only show estimated calls for selected modes."
whiteListedModes: [TransportMode]
): [EstimatedCall!]! @timingData
id: ID!
latitude: Float
longitude: Float
name(
"Fetch the name in the language given. The language should be represented as a ISO-639 language code. If the translation does not exist, the default name is returned."
lang: String @deprecated(reason : "Use 'language' instead"),
"Fetch the name in the language given. The language should be represented as a ISO-639 language code. If the translation does not exist, the default name is returned."
language: String
): String!
"Returns parent stop for this stop"
parent: StopPlace
"Returns all quays that are children of this stop place"
quays(
"If true only quays with at least one visiting line are included."
filterByInUse: Boolean = false
): [Quay] @timingData
"Get all situations active for the stop place. Situations affecting individual quays are not returned, and should be fetched directly from the quay."
situations: [PtSituationElement!]!
"Specify the priority of interchanges at this stop"
stopInterchangePriority: StopInterchangePriority
tariffZones: [TariffZone]!
timeZone: String
"The transport modes of quays under this stop place."
transportMode: [TransportMode]
"The transport submode serviced by this stop place."
transportSubmode: [TransportSubmode]
"Relative weighting of this stop with regards to interchanges. NOT IMPLEMENTED"
weighting: InterchangeWeighting @deprecated(reason : "Not implemented. Use stopInterchangePriority")
}
"List of coordinates between two stops as a polyline"
type StopToStopGeometry {
"Origin Quay"
fromQuay: Quay
"A list of coordinates encoded as a polyline string between two stops (see http://code.google.com/apis/maps/documentation/polylinealgorithm.html)"
pointsOnLink: PointsOnLink
"Destination Quay"
toQuay: Quay
}
"""
A system notice is used to tag elements with system information for debugging or other
system related purpose. One use-case is to run a routing search with
`itineraryFilters.debug=listAll`. This will then tag itineraries instead of removing
them from the result. This make it possible to inspect the itinerary-filter-chain. A
SystemNotice only have english text, because the primary user are technical staff, like
testers and developers.
**NOTE!** _A SystemNotice is for debugging the system, avoid putting logic on it in the
client. The tags and usage may change without notice._
"""
type SystemNotice {
tag: String
text: String
}
type TariffZone {
id: ID!
name: String
}
type TimeAndDayOffset {
"Number of days offset from base line time"
dayOffset: Int
"Local time"
time: Time
}
"""
The time-penalty is applied to either the access-legs and/or egress-legs. Both access and
egress may contain more than one leg; Hence, the penalty is not a field on leg.
Note! This is for debugging only. This type can change without notice.
"""
type TimePenaltyWithCost {
"""
The time-penalty is applied to either the access-legs and/or egress-legs. Both access
and egress may contain more than one leg; Hence, the penalty is not a field on leg. The
`appliedTo` describe witch part of the itinerary that this instance applies to.
"""
appliedTo: String
"""
The time-penalty does also propagate to the `generalizedCost`. As a result of the given
time-penalty, the generalized-cost also increased by the given amount. This delta is
included in the itinerary generalized-cost. In some cases the generalized-cost-delta is
excluded when comparing itineraries - that happens if one of the itineraries is a
"direct/street-only" itinerary. Time-penalty can not be set for direct searches, so it
needs to be excluded from such comparison to be fair. The unit is transit-seconds.
"""
generalizedCostDelta: Int
"""
The time-penalty added to the actual time/duration when comparing the itinerary with
other itineraries. This is used to decide witch is the best option, but is not visible
- the actual departure and arrival-times are not modified.
"""
timePenalty: String
}
"Scheduled passing times. These are not affected by real time updates."
type TimetabledPassingTime {
"Scheduled time of arrival at quay"
arrival: TimeAndDayOffset
"Booking arrangements for this passing time."
bookingArrangements: BookingArrangement
"Scheduled time of departure from quay"
departure: TimeAndDayOffset
destinationDisplay: DestinationDisplay
"Earliest possible departure time for a service journey with a service window."
earliestDepartureTime: TimeAndDayOffset
"Whether vehicle may be alighted at quay."
forAlighting: Boolean!
"Whether vehicle may be boarded at quay."
forBoarding: Boolean!
"Latest possible (planned) arrival time for a service journey with a service window."
latestArrivalTime: TimeAndDayOffset
notices: [Notice!]!
quay: Quay!
"Whether vehicle will only stop on request."
requestStop: Boolean!
serviceJourney: ServiceJourney!
"Whether this is a timing point or not. Boarding and alighting is not allowed at timing points."
timingPoint: Boolean!
}
"Used to specify board and alight slack for a given modes."
type TransportModeSlackType {
modes: [TransportMode!]!
slack: Int!
}
"Description of a travel between two places."
type Trip {
"The time and date of travel"
dateTime: DateTime
"Information about the timings for the trip generation"
debugOutput: debugOutput!
"The origin"
fromPlace: Place!
"A list of possible error messages as enum"
messageEnums: [String]! @deprecated(reason : "Use routingErrors instead")
"A list of possible error messages in cleartext"
messageStrings(language: String): [String]! @deprecated(reason : "Use routingErrors instead")
"The trip request metadata."
metadata: TripSearchData
"""
Use the cursor to get the next page of results. Use this cursor for the pageCursor parameter in the trip query in order to get the next page.
The next page is a set of itineraries departing AFTER the last itinerary in this result.
"""
nextPageCursor: String
"""
Use the cursor to get the previous page of results. Use this cursor for the pageCursor parameter in the trip query in order to get the previous page.
The previous page is a set of itineraries departing BEFORE the first itinerary in this result.
"""
previousPageCursor: String
"A list of routing errors, and fields which caused them"
routingErrors: [RoutingError!]!
"The destination"
toPlace: Place!
"A list of possible trip patterns"
tripPatterns: [TripPattern!]!
}
"List of legs constituting a suggested sequence of rides and links for a specific trip."
type TripPattern {
"The aimed date and time the trip ends."
aimedEndTime: DateTime!
"The aimed date and time the trip starts."
aimedStartTime: DateTime!
"NOT IMPLEMENTED."
directDuration: Long
"Total distance for the trip, in meters. NOT IMPLEMENTED"
distance: Float
"Duration of the trip, in seconds."
duration: Long
"Time that the trip arrives."
endTime: DateTime @deprecated(reason : "Replaced with expectedEndTime")
"The expected, real-time adjusted date and time the trip ends."
expectedEndTime: DateTime!
"The expected, real-time adjusted date and time the trip starts."
expectedStartTime: DateTime!
"Generalized cost or weight of the itinerary. Used for debugging."
generalizedCost: Int
"A second cost or weight of the itinerary. Some use-cases like pass-through and transit-priority-groups use a second cost during routing. This is used for debugging."
generalizedCost2: Int
"A list of legs. Each leg is either a walking (cycling, car) portion of the trip, or a ride leg on a particular vehicle. So a trip where the use walks to the Q train, transfers to the 6, then walks to their destination, has four legs."
legs: [Leg!]!
"Time that the trip departs."
startTime: DateTime @deprecated(reason : "Replaced with expectedStartTime")
"How far the user has to walk, bike and/or drive in meters. It includes all street(none transit) modes."
streetDistance: Float
"Get all system notices."
systemNotices: [SystemNotice!]!
"""
A time and cost penalty applied to access and egress to favor regular scheduled
transit over potentially faster options with FLEX, Car, bike and scooter.
Note! This field is meant for debugging only. The field can be removed without notice
in the future.
"""
timePenalty: [TimePenaltyWithCost!]!
"A cost calculated to favor transfer with higher priority. This field is meant for debugging only."
transferPriorityCost: Int
"A cost calculated to distribute wait-time and avoid very short transfers. This field is meant for debugging only."
waitTimeOptimizedCost: Int
"How much time is spent waiting for transit to arrive, in seconds."
waitingTime: Long
walkDistance: Float @deprecated(reason : "Replaced by `streetDistance`.")
"How much time is spent walking, in seconds."
walkTime: Long
}
"Trips search metadata."
type TripSearchData {
"This is the suggested search time for the \"next page\" or time window. Insert it together with the 'searchWindowUsed' in the request to get a new set of trips following in the time-window AFTER the current search."
nextDateTime: DateTime @deprecated(reason : "Use pageCursor instead")
"This is the suggested search time for the \"previous page\" or time-window. Insert it together with the 'searchWindowUsed' in the request to get a new set of trips preceding in the time-window BEFORE the current search."
prevDateTime: DateTime @deprecated(reason : "Use pageCursor instead")
"This is the time window used by the raptor search. The input searchWindow is an optional parameter and is dynamically assigned if not set. OTP might override the value if it is too small or too large. When paging OTP adjusts it to the appropriate size, depending on the number of itineraries found in the current search window. The scaling of the search window ensures faster paging and limits resource usage. The unit is minutes."
searchWindowUsed: Int!
}
type ValidityPeriod {
"End of validity period. Will return 'null' if validity is open-ended."
endTime: DateTime
"Start of validity period"
startTime: DateTime
}
"An acceptable combination of trip patterns between two segments of the via search"
type ViaConnection {
"The index of the trip pattern in the segment before the via point"
from: Int
"The index of the trip pattern in the segment after the via point"
to: Int
}
"Description of a trip via one or more intermediate locations. For example from A, via B, then C to D."
type ViaTrip {
"A list of routing errors, and fields which caused them"
routingErrors: [RoutingError!]!
"A list of the acceptable combinations of the trip patterns in this segment and the next segment."
tripPatternCombinations: [[ViaConnection!]!]!
"A list of segments of the via search. The first segment is from the start location to the first entry in the locations list and the last is from the last entry in the locations list to the end location."
tripPatternsPerSegment: [ViaTripPatternSegment!]!
}
"A segment of the via search. The first segment is from the start location to the first entry in the locations list and the last is from the last entry in the locations list to the end location."
type ViaTripPatternSegment {
"A list of trip patterns for this segment of the search"
tripPatterns: [TripPattern!]!
}
type debugOutput {
totalTime: Long
}
type infoLink {
"Label"
label: String
"URI"
uri: String!
}
"A connection to a list of items."
type placeAtDistanceConnection {
"a list of edges"
edges: [placeAtDistanceEdge]
"details about this specific page"
pageInfo: PageInfo!
}
"An edge in a connection"
type placeAtDistanceEdge {
"cursor marks a unique position or index into the connection"
cursor: String!
"The item at the end of the edge"
node: PlaceAtDistance
}
"A connection to a list of items."
type quayAtDistanceConnection {
"a list of edges"
edges: [quayAtDistanceEdge]
"details about this specific page"
pageInfo: PageInfo!
}
"An edge in a connection"
type quayAtDistanceEdge {
"cursor marks a unique position or index into the connection"
cursor: String!
"The item at the end of the edge"
node: QuayAtDistance
}
enum AbsoluteDirection {
east
north
northeast
northwest
south
southeast
southwest
west
}
enum AlternativeLegsFilter {
noFilter
sameAuthority
sameLine
sameMode
"Must match both subMode and mode"
sameSubmode
}
enum ArrivalDeparture {
"Only show arrivals"
arrivals
"Show both arrivals and departures"
both
"Only show departures"
departures
}
enum BicycleOptimisationMethod {
flat
greenways
quick
safe
triangle
}
enum BikesAllowed {
"The vehicle being used on this particular trip can accommodate at least one bicycle."
allowed
"There is no bike information for the trip."
noInformation
"No bicycles are allowed on this trip."
notAllowed
}
enum BookingMethod {
callDriver
callOffice
online
phoneAtStop
text
}
enum DirectionType {
anticlockwise
clockwise
inbound
outbound
unknown
}
enum FilterPlaceType {
"Bicycle rent stations"
bicycleRent
"Bike parks"
bikePark
"Car parks"
carPark
"Quay"
quay
"StopPlace"
stopPlace
}
enum InputField {
dateTime
from
intermediatePlace
to
}
enum InterchangePriority {
allowed
notAllowed
preferred
recommended
}
"Deprecated. Use STOP_INTERCHANGE_PRIORITY"
enum InterchangeWeighting {
"Third highest priority interchange."
interchangeAllowed
"Interchange not allowed."
noInterchange
"Highest priority interchange."
preferredInterchange
"Second highest priority interchange."
recommendedInterchange
}
"""
Enable this to attach a system notice to itineraries instead of removing them. This is very
convenient when tuning the itinerary-filter-chain.
"""
enum ItineraryFilterDebugProfile {
"""
Only return the requested number of itineraries, counting both actual and deleted ones.
The top `numItineraries` using the request sort order is returned. This does not work
with paging, itineraries after the limit, but inside the search-window are skipped when
moving to the next page.
"""
limitToNumOfItineraries
"""
Return all itineraries, including deleted ones, inside the actual search-window used
(the requested search-window may differ).
"""
limitToSearchWindow
"List all itineraries, including all deleted itineraries."
listAll
"By default, the debug itinerary filters is turned off."
off
}
enum Locale {
no
us
}
enum Mode {
air
bicycle
bus
cableway
car
coach
foot
funicular
lift
metro
monorail
rail
scooter
taxi
tram
trolleybus
water
}
enum MultiModalMode {
"Both multiModal parents and their mono modal child stop places."
all
"Only mono modal children stop places, not their multi modal parent stop"
child
"Multi modal parent stop places without their mono modal children."
parent
}
"OccupancyStatus to be exposed in the API. The values are based on GTFS-RT"
enum OccupancyStatus {
"""
The vehicle or carriage can currently accommodate only standing passengers and has limited
space for them. There isn't a big difference between this and `full` so it's possible to
handle them as the same value, if one wants to limit the number of different values.
SIRI nordic profile: merge into `standingRoomOnly`.
"""
crushedStandingRoomOnly
"""
The vehicle is considered empty by most measures, and has few or no passengers onboard, but is
still accepting passengers. There isn't a big difference between this and `manySeatsAvailable`
so it's possible to handle them as the same value, if one wants to limit the number of different
values.
SIRI nordic profile: merge these into `manySeatsAvailable`.
"""
empty
"""
The vehicle or carriage has a few seats available.
SIRI nordic profile: less than ~50% of seats available.
"""
fewSeatsAvailable
"""
The vehicle or carriage is considered full by most measures, but may still be allowing
passengers to board.
"""
full
"""
The vehicle or carriage has a large number of seats available.
SIRI nordic profile: more than ~50% of seats available.
"""
manySeatsAvailable
"The vehicle or carriage doesn't have any occupancy data available."
noData
"""
The vehicle or carriage has no seats or standing room available.
SIRI nordic profile: if vehicle/carriage is not in use / unavailable, or passengers are only
allowed to alight due to e.g. crowding.
"""
notAcceptingPassengers
"""
The vehicle or carriage only has standing room available.
SIRI nordic profile: less than ~10% of seats available.
"""
standingRoomOnly
}
enum PurchaseWhen {
advanceAndDayOfTravel
dayOfTravelOnly
other
timeOfTravelOnly
untilPreviousDay
}
enum RealtimeState {
"The service journey has been added using a real-time update, i.e. the service journey was not present in the regular time table."
Added
"The service journey has been canceled by a real-time update."
canceled
"The service journey information has been updated and resulted in a different journey pattern compared to the journey pattern of the scheduled service journey."
modified
"The service journey information comes from the regular time table, i.e. no real-time update has been applied."
scheduled
"The service journey information has been updated, but the journey pattern stayed the same as the journey pattern of the scheduled service journey."
updated
}
enum RelativeDirection {
circleClockwise
circleCounterclockwise
continue
depart
elevator
enterStation
exitStation
followSigns
hardLeft
hardRight
left
right
slightlyLeft
slightlyRight
uturnLeft
uturnRight
}
enum ReportType {
"Indicates a general info-message that should not affect trip."
general
"Indicates an incident that may affect trip."
incident
}
enum RoutingErrorCode {
"The specified location is not close to any streets or transit stops"
locationNotFound
"No stops are reachable from the location specified. You can try searching using a different access or egress mode"
noStopsInRange
"No transit connection was found between the origin and destination withing the operating day or the next day"
noTransitConnection
"A transit connection was found, but it was outside the search window. Use paging to navigate to a result."
noTransitConnectionInSearchWindow
"The coordinates are outside the bounds of the data currently loaded into the system"
outsideBounds
"The date specified is outside the range of data currently loaded into the system"
outsideServicePeriod
"The origin and destination are so close to each other, that walking is always better, but no direct mode was specified for the search"
walkingBetterThanTransit
}
enum ServiceAlteration {
cancellation
extraJourney
planned
replaced
}
enum Severity {
"Situation has no impact on trips."
noImpact
"Situation has an impact on trips (default)."
normal
"Situation has a severe impact on trips."
severe
"Situation has a slight impact on trips."
slight
"Severity is undefined."
undefined
"Situation has unknown impact on trips."
unknown
"Situation has a very severe impact on trips."
verySevere
"Situation has a very slight impact on trips."
verySlight
}
enum StopCondition {
"Situation applies when stop is the destination of the leg."
destination
"Situation applies when transfering to another leg at the stop."
exceptionalStop
"Situation applies when passing the stop, without stopping."
notStopping
"Situation applies when at the stop, and the stop requires a request to stop."
requestStop
"Situation applies when stop is the startpoint of the leg."
startPoint
}
enum StopInterchangePriority {
"Allow transfers from/to this stop. This is the default. NeTEx equivalent is INTERCHANGE_ALLOWED."
allowed
"Block transfers from/to this stop. In OTP this is not a definitive block, just a huge penalty is added to the cost function. NeTEx equivalent is NO_INTERCHANGE."
discouraged
"Preferred place to transfer, strongly recommended. NeTEx equivalent is PREFERRED_INTERCHANGE."
preferred
"Recommended stop place. NeTEx equivalent is RECOMMENDED_INTERCHANGE."
recommended
}
enum StreetMode {
"Bike only. This can be used as access/egress, but transfers will still be walk only."
bicycle
"Bike to a bike parking area, then walk the rest of the way. Direct mode and access mode only."
bike_park
"Walk to a bike rental point, bike to a bike rental drop-off point, and walk the rest of the way. This can include bike rental at fixed locations or free-floating services."
bike_rental
"Car only. Direct mode only."
car
"Start in the car, drive to a parking area, and walk the rest of the way. Direct mode and access mode only."
car_park
"Walk to a pickup point along the road, drive to a drop-off point along the road, and walk the rest of the way. This can include various taxi-services or kiss & ride."
car_pickup
"Walk to a car rental point along the road, drive to a drop-off point along the road, and walk the rest of the way. This can include car rentals at fixed locations or free-floating services."
car_rental
"Walk to an eligible pickup area for flexible transportation, ride to an eligible drop-off area and then walk the rest of the way."
flexible
"Walk only"
foot
"Walk to a scooter rental point, ride a scooter to a scooter rental drop-off point, and walk the rest of the way. This can include scooter rental at fixed locations or free-floating services."
scooter_rental
}
enum TransportMode {
air
bus
cableway
coach
funicular
lift
metro
monorail
rail
taxi
tram
trolleybus
unknown
water
}
enum TransportSubmode {
SchengenAreaFlight
airportBoatLink
airportLinkBus
airportLinkRail
airshipService
allFunicularServices
allHireVehicles
allTaxiServices
bikeTaxi
blackCab
cableCar
cableFerry
canalBarge
carTransportRailService
chairLift
charterTaxi
cityTram
communalTaxi
commuterCoach
crossCountryRail
dedicatedLaneBus
demandAndResponseBus
domesticCharterFlight
domesticFlight
domesticScheduledFlight
dragLift
expressBus
funicular
helicopterService
highFrequencyBus
highSpeedPassengerService
highSpeedRail
highSpeedVehicleService
hireCar
hireCycle
hireMotorbike
hireVan
intercontinentalCharterFlight
intercontinentalFlight
international
internationalCarFerry
internationalCharterFlight
internationalCoach
internationalFlight
internationalPassengerFerry
interregionalRail
lift
local
localBus
localCarFerry
localPassengerFerry
localTram
longDistance
metro
miniCab
mobilityBus
mobilityBusForRegisteredDisabled
nationalCarFerry
nationalCoach
nationalPassengerFerry
nightBus
nightRail
postBoat
postBus
rackAndPinionRailway
railReplacementBus
railShuttle
railTaxi
regionalBus
regionalCarFerry
regionalCoach
regionalPassengerFerry
regionalRail
regionalTram
replacementRailService
riverBus
roadFerryLink
roundTripCharterFlight
scheduledFerry
schoolAndPublicServiceBus
schoolBoat
schoolBus
schoolCoach
shortHaulInternationalFlight
shuttleBus
shuttleCoach
shuttleFerryService
shuttleFlight
shuttleTram
sightseeingBus
sightseeingCoach
sightseeingFlight
sightseeingService
sightseeingTram
sleeperRailService
specialCoach
specialNeedsBus
specialTrain
streetCableCar
suburbanRailway
telecabin
telecabinLink
touristCoach
touristRailway
trainFerry
trainTram
tube
undefined
undefinedFunicular
unknown
urbanRailway
waterTaxi
}
enum VertexType {
bikePark
bikeShare
normal
transit
}
enum WheelchairBoarding {
"There is no accessibility information for the stopPlace/quay."
noInformation
"Wheelchair boarding/alighting is not possible at this stop."
notPossible
"Boarding wheelchair-accessible serviceJourneys is possible at this stopPlace/quay."
possible
}
"List of coordinates like: [[60.89, 11.12], [62.56, 12.10]]"
scalar Coordinates
"A cost value, normally a value of 1 is equivalent to riding transit for 1 second, but it might not depending on the use-case. Format: 3665 = DT1h1m5s = 1h1m5s"
scalar Cost
"Local date using the ISO 8601 format: `YYYY-MM-DD`. Example: `2020-05-17`."
scalar Date
"""
DateTime format accepting ISO 8601 dates with time zone offset.
Format: `YYYY-MM-DD'T'hh:mm[:ss](Z|±01:00)`
Example: `2017-04-23T18:25:43+02:00` or `2017-04-23T16:25:43Z`
"""
scalar DateTime
"""
A double function `f(t)` is used to calculate a value based on a variable(t). The variable can
be the duration/time or cost for a leg or section of a path/itinerary. The function
`f(t) = a + bt` has a constant(a) and a coefficient(b) that will be used in OTP to compute
`f(t)`.
Format: `a + b t`. Example: `30m + 2.0 t`. The constant `a` accept both whole numbers and
duration input format like: `60` = `60s` = `1m` and `3791` = `1h3m11s`. `b` must be a positive
decimal number between `0.0` and `100.0`.
"""
scalar DoubleFunction
"Duration in a lenient ISO-8601 duration format. Example P2DT2H12M40S, 2d2h12m40s or 1h"
scalar Duration
"Time using the format: HH:mm:SS. Example: 18:25:SS"
scalar LocalTime
"A 64-bit signed integer"
scalar Long
"Time using the format: `HH:MM:SS`. Example: `18:25:43`"
scalar Time
"Filter trips by disallowing lines involving certain elements. If both lines and authorities are specified, only one must be valid for each line to be banned. If a line is both banned and whitelisted, it will be counted as banned."
input InputBanned {
"Set of ids for authorities that should not be used"
authorities: [ID] = []
"Set of ids for lines that should not be used"
lines: [ID] = []
"NOT IMPLEMENTED. Set of ids of quays that should not be allowed for boarding or alighting. Trip patterns that travel through the quay will still be permitted."
quays: [ID] = []
"NOT IMPLEMENTED. Set of ids of quays that should not be allowed for boarding, alighting or traveling thorugh."
quaysHard: [ID] = []
"Set of ids of rental networks that should not be allowed for renting vehicles."
rentalNetworks: [ID] = []
"Set of ids of service journeys that should not be used."
serviceJourneys: [ID] = []
}
"Input type for coordinates in the WGS84 system"
input InputCoordinates {
"The latitude of the place."
latitude: Float!
"The longitude of the place."
longitude: Float!
}
input InputPlaceIds {
"Bike parks to include by id."
bikeParks: [String]
"Bike rentals to include by id."
bikeRentalStations: [String]
"Car parks to include by id."
carParks: [String]
"Lines to include by id."
lines: [String]
"Quays to include by id."
quays: [String]
}
"Filter trips by only allowing lines involving certain elements. If both lines and authorities are specified, only one must be valid for each line to be used. If a line is both banned and whitelisted, it will be counted as banned."
input InputWhiteListed {
"Set of ids for authorities that should be used"
authorities: [ID] = []
"Set of ids for lines that should be used"
lines: [ID] = []
"Set of ids of rental networks that should be used for renting vehicles."
rentalNetworks: [ID] = []
}
"Parameters for the OTP Itinerary Filter Chain. These parameters SHOULD be configured on the server side and should not be used by the client. They are made available here to be able to experiment and tune the server."
input ItineraryFilters {
"""
Use this parameter to debug the itinerary-filter-chain. The default is `off`
(itineraries are filtered and not returned). For all other values the unwanted
itineraries are returned with a system notice, and not deleted.
"""
debug: ItineraryFilterDebugProfile = off
groupSimilarityKeepNumOfItineraries: Float = 0.68 @deprecated(reason : "Use groupSimilarityKeepThree instead.")
"Pick ONE itinerary from each group after putting itineraries that is 85% similar together."
groupSimilarityKeepOne: Float = 0.85
"Reduce the number of itineraries in each group to to maximum 3 itineraries. The itineraries are grouped by similar legs (on board same journey). So, if 68% of the distance is traveled by similar legs, then two itineraries are in the same group. Default value is 68%, must be at least 50%."
groupSimilarityKeepThree: Float = 0.68
"Of the itineraries grouped to maximum of three itineraries, how much worse can the non-grouped legs be compared to the lowest cost. 2.0 means that they can be double the cost, and any itineraries having a higher cost will be filtered. Default value is 2.0, use a value lower than 1.0 to turn off"
groupedOtherThanSameLegsMaxCostMultiplier: Float = 2.0
"Add an additional cost for short transfers on long transit itineraries. See javaDoc on `AddMinSafeTransferCostFilter` details."
minSafeTransferTimeFactor: Float @deprecated(reason : "This filter is removed, it has undesired side-effects")
"Set a relative limit for all transit itineraries. The limit is calculated based on the transit itinerary generalized-cost and the time between itineraries Itineraries without transit legs are excluded from this filter. Example: costLimitFunction(x) = 3600 + 2.0 x and intervalRelaxFactor = 0.5. If the lowest cost returned is 10 000, then the limit is set to: 3 600 + 2 * 10 000 = 26 600 plus half of the time between either departure or arrival times of the itinerary. Default: {\"costLimitFunction\": 15m + 1.50 t, \"intervalRelaxFactor\": 0.4}"
transitGeneralizedCostLimit: TransitGeneralizedCostFilterParams
}
"Input format for specifying a location through either a place reference (id), coordinates or both. If both place and coordinates are provided the place ref will be used if found, coordinates will only be used if place is not known."
input Location {
"Coordinates for the location. This can be used alone or as fallback if the place id is not found."
coordinates: InputCoordinates
"The name of the location. This is pass-through informationand is not used in routing."
name: String
"The id of an element in the OTP model. Currently supports Quay, StopPlace, multimodal StopPlace, and GroupOfStopPlaces."
place: String
}
"Input format for specifying which modes will be allowed for this search. If this element is not present, it will default to accessMode/egressMode/directMode of foot and all transport modes will be allowed."
input Modes {
"The mode used to get from the origin to the access stops in the transit network (first-mile). If the element is not present or null,only transit that can be immediately boarded from the origin will be used."
accessMode: StreetMode
"The mode used to get from the origin to the destination directly, without using the transit network. If the element is not present or null,direct travel without using transit will be disallowed."
directMode: StreetMode
"The mode used to get from the egress stops in the transit network tothe destination (last-mile). If the element is not present or null,only transit that can immediately arrive at the origin will be used."
egressMode: StreetMode
"The allowed modes for the transit part of the trip. Use an empty list to disallow transit for this search. If the element is not present or null, it will default to all transport modes."
transportModes: [TransportModes]
}
"Defines one point which the journey must pass through."
input PassThroughPoint {
"Optional name of the pass-through point for debugging and logging. It is not used in routing."
name: String
"""
The list of *stop location ids* which define the pass-through point. At least one id is required.
Quay, StopPlace, multimodal StopPlace, and GroupOfStopPlaces are supported location types.
The journey must pass through at least one of these entities - not all of them.
"""
placeIds: [String!]
}
"A combination of street mode and penalty for time and cost."
input PenaltyForStreetMode {
"""
This is used to take the time-penalty and multiply by the `costFactor`.
The result is added to the generalized-cost.
"""
costFactor: Float = 1.0
"""
List of modes with the given penalty is applied to. A street-mode should not be listed
in more than one element. If empty or null the penalty is applied to all unlisted modes,
it becomes the default penalty for this query.
"""
streetMode: StreetMode!
"Penalty applied to the time for the given list of modes."
timePenalty: DoubleFunction!
}
"""
A relax-cost is used to increase the limit when comparing one cost to another cost.
This is used to include more results into the result. A `ratio=2.0` means a path(itinerary)
with twice as high cost as another one, is accepted. A `constant=$300` means a "fixed"
constant is added to the limit. A `{ratio=1.0, constant=0}` is said to be the NORMAL relaxed
cost - the limit is the same as the cost used to calculate the limit. The NORMAL is usually
the default. We can express the RelaxCost as a function `f(t) = constant + ratio * t`.
`f(t)=t` is the NORMAL function.
"""
input RelaxCostInput {
"The constant value to add to the limit. Must be a positive number. The value is equivalent to transit-cost-seconds. Integers are treated as seconds, but you may use the duration format. Example: '3665 = 'DT1h1m5s' = '1h1m5s'."
constant: Cost = "0s"
"The factor to multiply with the 'other cost'. Minimum value is 1.0."
ratio: Float = 1.0
}
"A combination of street mode and corresponding duration"
input StreetModeDurationInput {
duration: Duration!
streetMode: StreetMode!
}
"Input format for specifying which modes will be allowed for this search. If this element is not present, it will default to all to foot."
input StreetModes {
"The mode used to get from the origin to the access stops in the transit network the transit network (first-mile). If the element is not present or null,only transit that can be immediately boarded from the origin will be used."
accessMode: StreetMode
"The mode used to get from the origin to the destination directly, without using the transit network. If the element is not present or null,direct travel without using transit will be disallowed."
directMode: StreetMode
"The mode used to get from the egress stops in the transit network tothe destination (last-mile). If the element is not present or null,only transit that can immediately arrive at the origin will be used."
egressMode: StreetMode
}
input TransitGeneralizedCostFilterParams {
costLimitFunction: DoubleFunction!
intervalRelaxFactor: Float!
}
"Used to specify board and alight slack for a given modes."
input TransportModeSlack {
"List of modes for which the given slack apply."
modes: [TransportMode!]!
"The slack used for all given modes."
slack: Int!
}
input TransportModes {
"A transportMode that should be allowed for this search. You can furthernarrow it down by specifying a list of transportSubModes"
transportMode: TransportMode
"The allowed transportSubModes for this search. If this element is notpresent or null, it will default to all transportSubModes for the specifiedTransportMode. Be aware that all transportSubModes have an associated TransportMode, which must match what is specified in the transportMode field."
transportSubModes: [TransportSubmode]
}
"How much the factors safety, slope and distance are weighted relative to each other when routing bicycle legs. In total all three values need to add up to 1."
input TriangleFactors {
"How important is bicycle safety expressed as a fraction of 1."
safety: Float!
"How important is slope/elevation expressed as a fraction of 1."
slope: Float!
"How important is time expressed as a fraction of 1. Note that what this really optimises for is distance (even if that means going over terrible surfaces, so I might be slower than the safe route)."
time: Float!
}
"A collection of selectors for what lines/trips should be included in / excluded from search"
input TripFilterInput {
"A list of selectors for what lines/trips should be excluded during the search. If line/trip matches with at least one selector it will be excluded."
not: [TripFilterSelectInput!]
"A list of selectors for what lines/trips should be allowed during search. In order to be accepted a trip/line has to match with at least one selector. An empty list means that everything should be allowed. "
select: [TripFilterSelectInput!]
}
"A list of selectors for filter allow-list / exclude-list. An empty list means that everything is allowed. A trip/line will match with selectors if it matches with all non-empty lists. The `select` is always applied first, then `not`. If only `not` not is present, the exclude is applied to the existing set of lines. "
input TripFilterSelectInput {
"Set of ids for authorities that should be included in/excluded from search"
authorities: [ID!]
"Set of ids for group of lines that should be included in/excluded from the search"
groupOfLines: [ID!]
"Set of ids for lines that should be included in/excluded from search"
lines: [ID!]
"Set of ids for service journeys that should be included in/excluded from search"
serviceJourneys: [ID!]
"The allowed modes for the transit part of the trip. Use an empty list to disallow transit for this search. If the element is not present or null, it will default to all transport modes."
transportModes: [TransportModes!]
}
"""
One of the listed stop locations must be visited on-board a transit vehicle or the journey must
alight or board at the location.
"""
input TripPassThroughViaLocationInput {
"The label/name of the location. This is pass-through information and is not used in routing."
label: String
"""
A list of stop locations. A stop location can be a quay, a stop place, a multimodal
stop place or a group of stop places. It is enough to visit ONE of the locations
listed.
"""
stopLocationIds: [String!]!
}
"""
A via-location is used to specifying a location as an intermediate place the router must
route through. The via-location is either a pass-through-location or a visit-via-location.
"""
input TripViaLocationInput @oneOf {
"Board, alight or pass-through(on-board) at the stop location."
passThrough: TripPassThroughViaLocationInput
"Board or alight at a stop location or visit a coordinate."
visit: TripVisitViaLocationInput
}
"""
A visit-via-location is a physical visit to one of the stop locations or coordinates listed. An
on-board visit does not count, the traveler must alight or board at the given stop for it to to
be accepted. To visit a coordinate, the traveler must walk(bike or drive) to the closest point
in the street network from a stop and back to another stop to join the transit network.
"""
input TripVisitViaLocationInput {
"A coordinate to route through."
coordinate: InputCoordinates
"The label/name of the location. This is pass-through information and is not used in routing."
label: String
"""
The minimum wait time is used to force the trip to stay the given duration at the
via-location before the trip is continued.
"""
minimumWaitTime: Duration = "PT0S"
"""
A list of stop locations. A stop location can be a quay, a stop place, a multimodal
stop place or a group of stop places. It is enough to visit ONE of the locations
listed.
"""
stopLocationIds: [String!]
}
"Input format for specifying a location through either a place reference (id), coordinates or both. If both place and coordinates are provided the place ref will be used if found, coordinates will only be used if place is not known. The location also contain information about the minimum and maximum time the user is willing to stay at the via location."
input ViaLocationInput {
"Coordinates for the location. This can be used alone or as fallback if the place id is not found."
coordinates: InputCoordinates
"The maximum time the user wants to stay in the via location before continuing his journey"
maxSlack: Duration = "PT1H"
"The minimum time the user wants to stay in the via location before continuing his journey"
minSlack: Duration = "PT5M"
"The name of the location. This is pass-through information and is not used in routing."
name: String
"The id of an element in the OTP model. Currently supports Quay, StopPlace, multimodal StopPlace, and GroupOfStopPlaces."
place: String
}
input ViaSegmentInput {
"A list of filters for which trips should be included. A trip will be included if it matches with at least one filter. An empty list of filters means that all trips should be included."
filters: [TripFilterInput!]
"The set of access/egress/direct modes to be used for this search."
modes: StreetModes
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy