# Source: introspection of https://api.entur.io/journey-planner/v3/graphql (fetched 2026-10-09) schema { query: QueryType } """This directive allows results to be deferred during execution""" directive @defer( """Deferred behaviour is controlled by this argument""" if: Boolean! = true """A unique label that represents the fragment being deferred""" label: String ) on FRAGMENT_SPREAD | INLINE_FRAGMENT """ This directive disables error propagation when a non nullable field returns null for the given operation. """ directive @experimental_disableErrorPropagation on QUERY | MUTATION | SUBSCRIPTION """Add timing data to prometheus, if Actuator API is enabled""" directive @timingData on FIELD_DEFINITION enum AbsoluteDirection { north northeast east southeast south southwest west northwest } type AffectedLine { line: Line } type AffectedServiceJourney { serviceJourney: ServiceJourney operatingDay: Date datedServiceJourney: DatedServiceJourney } type AffectedStopPlace { quay: Quay stopPlace: StopPlace stopConditions: [StopCondition!]! } type AffectedStopPlaceOnLine { quay: Quay stopPlace: StopPlace line: Line stopConditions: [StopCondition!]! } type AffectedStopPlaceOnServiceJourney { quay: Quay stopPlace: StopPlace serviceJourney: ServiceJourney operatingDay: Date datedServiceJourney: DatedServiceJourney stopConditions: [StopCondition!]! } type AffectedUnknown { description: String } union Affects = AffectedStopPlace | AffectedLine | AffectedServiceJourney | AffectedStopPlaceOnLine | AffectedStopPlaceOnServiceJourney | AffectedUnknown enum AlternativeLegsFilter { noFilter sameAuthority sameMode """Must match both subMode and mode""" sameSubmode sameLine } enum ArrivalDeparture { """Only show arrivals""" arrivals """Only show departures""" departures """Show both arrivals and departures""" both } """ Authority involved in public transportation. An organisation under which the responsibility of organising the transport service in a certain area is placed. """ type Authority { id: ID! name: String! url: String timezone: String! lang: String phone: String fareUrl: String lines: [Line]! """Get all situations active for the authority.""" situations: [PtSituationElement!]! } enum BicycleOptimisationMethod { quick safe flat greenways triangle } type BikePark implements PlaceInterface { id: ID! name: String! spacesAvailable: Int realtime: Boolean longitude: Float latitude: Float } """Bicycle routing preferences.""" input BikePreferencesInput { """The maximum bike speed along streets, in meters per second.""" speed: Float = 5 """ A measure of how bad biking is compared to being in transit for equal periods of time. Higher values make routing prefer other modes over biking. """ reluctance: Float = 5 """ The set of characteristics that the user wants to optimize for during bicycle routing. """ optimisationMethod: VehicleOptimisationMethod = safe """ When using optimisationMethod 'triangle', these values tell the routing engine how important each factor is compared to the others. All values should add up to 1. """ triangleFactors: TriangleFactors } type BikeRentalStation implements PlaceInterface { id: ID! name: String! bikesAvailable: Int spacesAvailable: Int realtimeOccupancyAvailable: Boolean allowDropoff: Boolean networks: [String]! longitude: Float latitude: Float } enum BikesAllowed { """There is no bike information for the trip.""" noInformation """ The vehicle being used on this particular trip can accommodate at least one bicycle. """ allowed """No bicycles are allowed on this trip.""" notAllowed } type BookingArrangement { """How should service be booked?""" bookingMethods: [BookingMethod] """Latest time the service can be booked. ISO 8601 timestamp""" latestBookingTime: LocalTime """How many days prior to the travel the service needs to be booked""" latestBookingDay: Int """Time constraints for booking""" bookWhen: PurchaseWhen """Minimum period in advance service can be booked as a ISO 8601 duration""" minimumBookingPeriod: String """Textual description of booking arrangement for service""" bookingNote: String """Who should ticket be contacted for booking""" bookingContact: Contact } enum BookingMethod { callDriver callOffice online phoneAtStop text } type Branding { id: ID! """Full name to be used for branding.""" name: String """Short name to be used for branding.""" shortName: String """Description of branding.""" description: String """URL to be used for branding""" url: String """URL to an image be used for branding""" image: String } type Contact { """Name of person to contact""" contactPerson: String """Email adress for contact""" email: String """Url for contact""" url: String """Phone number for contact""" phone: String """Textual description of how to get in contact""" furtherDetails: String } """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 planned journey on a specific day""" type DatedServiceJourney { id: ID! """ The date this service runs. The date used is based on the service date as opposed to calendar date. """ operatingDay: Date """The service journey this Dated Service Journey is based on""" serviceJourney: ServiceJourney! """ Alterations specified on the Trip in the planned data. Note: realtime alterations are not included """ tripAlteration: ServiceAlteration """ Whether this is an extra journey, either from planned data or added in realtime """ extraJourney: Boolean! """ List of the dated service journeys this dated service journeys replaces """ replacementFor: [DatedServiceJourney!]! @deprecated(reason: "Use replacementForRelation") """ Dated service journeys this dated service journey replaces with full replacement information """ replacementForRelation: [ReplacementForRelation!]! """Dated service journeys this dated service journey is replaced by""" replacedByRelation: [ReplacedByRelation!]! """JourneyPattern for the dated service journey.""" journeyPattern: JourneyPattern """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!]! """ Returns scheduled passingTimes for this dated service journey, updated with real-time-updates (if available). """ estimatedCalls: [EstimatedCall!]! """The real-time state of this dated service journey.""" realTimeJourneyState: RealTimeJourneyState } """ Identifies a specific service journey on a specific service date. Exactly one of the fields must be set. """ input DatedServiceJourneyReference { """Identifies the service journey by service journey ID and service date.""" serviceJourneyOnServiceDate: ServiceJourneyOnServiceDate """ Identifies the service journey by a dated service journey ID (e.g. from NeTEx data where a service journey on a date has a unique ID). """ datedServiceJourneyId: String } """ 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] } enum DirectionType { unknown outbound inbound clockwise anticlockwise } "A double function `f(t)` is used to calculate a value based on a variable (t). The variable can\nbe the duration/time or cost for a leg or section of a path/itinerary. The function\n`f(t) = a + bt` has a constant (a) and a coefficient (b) that will be used in OTP to compute\n`f(t)`.\n\nFormat: `a + b t`. Example: `30m + 2.0 t`. The constant `a` accept both whole numbers and\nduration input format like: `60` = `60s` = `1m` and `3791` = `1h3m11s`. `b` must be a positive\ndecimal number between `0.0` and `100.0`.\n" scalar DoubleFunction """ Duration in a lenient ISO-8601 duration format. Example P2DT2H12M40S, 2d2h12m40s or 1h """ scalar Duration """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\nlocation is below sea level.\n" elevation: Float } """ Emission information for a trip-pattern or legs. For more information, go to https://data.entur.no/public/datasets/energy_emissions """ type Emission { """The average CO₂ emission per passenger in grams.""" co2: Float } "The empirical delay indicates how late a service journey is based on historic data.\n" type EmpiricalDelay { """ The median/50% percentile. This value is in the middle of the distribution. """ p50: Duration """ The 90% percentile. 90% of the values in the distribution is better and 10% is more delayed. """ p90: Duration } """ List of calls on quays as part of vehicle journeys. Updated with real time information where available """ type EstimatedCall { quay: Quay! """ The scheduled quay for this call. Equal to 'quay' unless the quay has been changed by a real time update """ scheduledQuay: Quay! """Scheduled time of arrival at quay. Not affected by read time updated""" aimedArrivalTime: DateTime! """ Expected time of arrival at quay. Updated with real time information if available. """ expectedArrivalTime: DateTime! """ Actual time of arrival at quay. Updated from real time information if available. """ actualArrivalTime: DateTime """ Scheduled time of departure from quay. Not affected by read time updated """ aimedDepartureTime: DateTime! """ Expected time of departure from quay. Updated with real time information if available. """ expectedDepartureTime: DateTime! """ Actual time of departure from quay. Updated with real time information if available. """ actualDepartureTime: DateTime """ The typical delay for this trip on this day for this stop based on historical data. """ empiricalDelay: EmpiricalDelay """ Whether this is a timing point or not. Boarding and alighting is not allowed at timing points. """ timingPoint: Boolean! """Whether this call has been updated with real time information.""" realtime: Boolean! """Whether the updated estimates are expected to be inaccurate.""" predictionInaccurate: Boolean! realtimeState: RealtimeState! @deprecated(reason: "Use realTimeJourneyState on datedServiceJourney for the journey's real-time state, or the individual boolean fields (cancellation, predictionInaccurate, extraCall) for the quay's state.") occupancyStatus: OccupancyStatus! stopPositionInPattern: Int! """Whether vehicle may be boarded at quay.""" forBoarding: Boolean! """Whether vehicle may be alighted at quay.""" forAlighting: Boolean! """Whether vehicle will only stop on request.""" requestStop: Boolean! """ 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! """Whether this call is an extra call introduced by real-time data""" extraCall: Boolean! """The date the estimated call is valid for.""" date: Date! """Estimated calls for the ServiceJourney on this date.""" serviceJourneyEstimatedCalls: SJEstimatedCalls! serviceJourney: ServiceJourney! datedServiceJourney: DatedServiceJourney destinationDisplay: DestinationDisplay notices: [Notice!]! """Get all relevant situations for this EstimatedCall.""" situations: [PtSituationElement!]! """Booking arrangements for this EstimatedCall.""" bookingArrangements: BookingArrangement """ Information about any trips replacing the current trip at the arrival of this call. """ arrivalReplacedBy: [ReplacedByRelation!]! """ Information about any trips replacing the current trip at the departure of this call. """ departureReplacedBy: [ReplacedByRelation!]! } """ A collection of selectors for what estimated calls should be included / excluded. At least one of `select` or `not` must be provided. The `select` is always applied first, then `not`. If only `not` is present, the exclude is applied to the existing set of estimated calls. """ input EstimatedCallFilterInput { """ A list of selectors for what estimated calls should be included. A call is included if it matches at least one selector. Omit the field to include all calls. An empty list is not allowed. """ select: [EstimatedCallSelectInput!] """ A list of selectors for what estimated calls should be excluded during the search. If a call matches with at least one selector it will be excluded. """ not: [EstimatedCallSelectInput!] } """ A selector for filter allow-list / exclude-list. At least one field must be provided. An estimated call matches a selector if it matches all fields. Within each field, a call matches if it matches any of the listed values. """ input EstimatedCallSelectInput { """ Set of ids for lines that should be included in/excluded from search. A call matches if its line matches any of the given IDs. An empty list is not allowed. Omit the field to match all lines. """ lines: [ID!] """ Set of ids for authorities that should be included in/excluded from search. A call matches if its authority matches any of the given IDs. An empty list is not allowed. Omit the field to match all authorities. """ authorities: [ID!] """ The allowed modes for the estimated call. A call matches if its mode matches any of the listed modes. An empty list is not allowed. Omit the field to match all modes. Omitting main mode (transportMode) is also not allowed. """ transportModes: [TransportModes!] } enum FilterPlaceType { """Quay""" quay """StopPlace""" stopPlace """Bicycle rent stations""" bicycleRent """Bike parks""" bikePark """Car parks""" carPark } """ Additional (optional) grouping of lines for particular purposes such as e.g. fare harmonisation or public presentation. """ type GroupOfLines { id: ID! """For internal use by operator/authority.""" privateCode: String """Short name for group of lines.""" shortName: String """Full name for group of lines.""" name: String """Description of group of lines""" description: String """All lines part of this group of lines""" lines: [Line!]! } """ 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 lines that should not be used""" lines: [ID] = [] """Set of ids for authorities that should not be used""" authorities: [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 service journeys that should not be used.""" serviceJourneys: [ID] = [] """ Set of ids of rental networks that should not be allowed for renting vehicles. """ rentalNetworks: [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! } enum InputField { dateTime from to intermediatePlace } input InputPlaceIds { """Quays to include by id.""" quays: [String] """Lines to include by id.""" lines: [String] """Bike rentals to include by id.""" bikeRentalStations: [String] """Bike parks to include by id.""" bikeParks: [String] """Car parks to include by id.""" carParks: [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 lines that should be used""" lines: [ID] = [] """Set of ids for authorities that should be used""" authorities: [ID] = [] """ Set of ids of rental networks that should be used for renting vehicles. """ rentalNetworks: [ID] = [] } type Interchange { staySeated: Boolean guaranteed: Boolean """ 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 """ 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 FromLine: Line @deprecated(reason: "This is the same as using the `fromServiceJourney { line }` field.") ToLine: Line @deprecated(reason: "This is the same as using the `toServiceJourney { line }` field.") fromServiceJourney: ServiceJourney toServiceJourney: ServiceJourney FromServiceJourney: ServiceJourney @deprecated(reason: "Use fromServiceJourney instead") ToServiceJourney: ServiceJourney @deprecated(reason: "Use toServiceJourney instead") } enum InterchangePriority { preferred recommended allowed notAllowed } """Deprecated. Use STOP_INTERCHANGE_PRIORITY""" enum InterchangeWeighting { """Highest priority interchange.""" preferredInterchange """Second highest priority interchange.""" recommendedInterchange """Third highest priority interchange.""" interchangeAllowed """Interchange not allowed.""" noInterchange } """ 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 { """By default, the debug itinerary filters is turned off.""" off """List all itineraries, including all deleted itineraries.""" listAll """ Return all itineraries, including deleted ones, inside the actual search-window used (the requested search-window may differ). """ limitToSearchWindow """ 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 } """ 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 { """ 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.5 t, "intervalRelaxFactor": 0.75} """ transitGeneralizedCostLimit: TransitGeneralizedCostFilterParams """ 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 """ 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 } type JourneyPattern { id: ID! line: Line! directionType: DirectionType name: String serviceJourneys: [ServiceJourney!]! """List of service journeys for the journey pattern for a given date""" serviceJourneysForDate(date: Date): [ServiceJourney!]! """Quays visited by service journeys for this journey patterns""" quays: [Quay!]! pointsOnLink: PointsOnLink """ Detailed path travelled by journey pattern divided into stop-to-stop sections. """ stopToStopGeometries: [StopToStopGeometry] """Get all situations active for the journey pattern.""" situations: [PtSituationElement!]! notices: [Notice!]! } """ Part of a trip pattern. Either a ride on a public transport vehicle or access or path link to/from/between places """ type Leg { "An identifier for the leg, which can be used to re-fetch transit leg information. The\nidentifier is valid for a maximum of 2 years, but sometimes it will fail after a few hours.\nWe do not recommend storing IDs for a long time.\n" id: ID """The aimed date and time this leg starts.""" aimedStartTime: DateTime! """The expected, real-time adjusted date and time this leg starts.""" expectedStartTime: DateTime! """The aimed date and time this leg ends.""" aimedEndTime: DateTime! """The expected, real-time adjusted date and time this leg ends.""" expectedEndTime: DateTime! """ The mode of transport or access (e.g., foot) used when traversing this leg. """ mode: Mode! """ The transport sub mode (e.g., localBus or expressBus) used when traversing this leg. Null if leg is not a ride """ transportSubmode: TransportSubmode """The leg's duration in seconds""" duration: Long! """NOT IMPLEMENTED""" directDuration: Long! """The leg's geometry.""" pointsOnLink: PointsOnLink """ For ride legs, the service authority used for this legs. For non-ride legs, null. """ authority: Authority """ For ride legs, the operator used for this legs. For non-ride legs, null. """ operator: Operator """Whether there is real-time data about this leg""" realtime: Boolean! """The distance traveled while traversing the leg in meters.""" distance: Float! """Generalized cost or weight of the leg. Used for debugging.""" generalizedCost: Int """Whether this leg is a ride leg or not.""" ride: Boolean! """Whether this leg is walking with a bike.""" walkingBike: Boolean """Whether this leg is with a rented bike.""" rentedBike: Boolean """The Place where the leg originates.""" fromPlace: Place! """The Place where the leg ends.""" toPlace: Place! """EstimatedCall for the quay where the leg originates.""" fromEstimatedCall: EstimatedCall """EstimatedCall for the quay where the leg ends.""" toEstimatedCall: EstimatedCall """For ride legs, the line. For non-ride legs, null.""" line: Line """For ride legs, the service journey. For non-ride legs, null.""" serviceJourney: ServiceJourney """The dated service journey used for this leg.""" datedServiceJourney: DatedServiceJourney """ For transit legs, the service date of the trip. For non-transit legs, null. """ serviceDate: Date """ 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, 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!]! """ For ride legs, all estimated calls for the service journey. For non-ride legs, empty list. """ serviceJourneyEstimatedCalls: [EstimatedCall!]! """All relevant situations for this leg""" situations: [PtSituationElement!]! """Do we continue from a specified via place""" steps: [PathGuidance]! interchangeFrom: Interchange interchangeTo: Interchange bookingArrangements: BookingArrangement bikeRentalNetworks: [String]! "The leg's elevation profile. All elevation values, including the first one, are in meters\nabove sea level. The elevation is negative for places below sea level. The profile\nincludes both the start and end coordinate.\n" elevationProfile: [ElevationProfileStep]! """The emission per person""" emission: Emission """ 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( """Number of earlier legs to return.""" previous: Int = 1 """Whether the leg should be similar to this leg in some way.""" filter: AlternativeLegsFilter = noFilter ): [Leg!] """ 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( """Number of later legs to return.""" next: Int = 1 """Whether the leg should be similar to this leg in some way.""" filter: AlternativeLegsFilter = noFilter ): [Leg!] } """ A group of routes which is generally known to the public by a similar name or number """ type Line { id: ID! authority: Authority operator: Operator branding: Branding """ Publicly announced code for line, differentiating it from other lines for the same operator. """ publicCode: String name: String transportMode: TransportMode transportSubmode: TransportSubmode description: String url: String presentation: Presentation bikesAllowed: BikesAllowed journeyPatterns: [JourneyPattern] quays: [Quay]! serviceJourneys: [ServiceJourney]! notices: [Notice!]! """Get all situations active for the line.""" situations: [PtSituationElement!]! """Type of flexible line, or null if line is not flexible.""" flexibleLineType: String """Booking arrangements for flexible line.""" bookingArrangements: BookingArrangement @deprecated(reason: "BookingArrangements are defined per stop, and can be found under `passingTimes` or `estimatedCalls`") """Groups of lines that line is a part of.""" groupOfLines: [GroupOfLines]! "Is this a replacement Line? In NeTEx/SIRI-sourced data this can be set by either\na replacement submode, or a replacement link in a DatedServiceJourney. Only true\nfor GTFS-sourced data if set by the extended GTFS type.\n" isReplacement: Boolean! """Are there replacement DatedServiceJourneys for this Line?""" replacementsExist: Boolean! } """Time using the format: HH:mm:SS. Example: 18:25:SS""" scalar LocalTime enum Locale { no us } """ 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. Alternatively, a serviceJourneyLocation can be used to start the search on-board a vehicle,or pinpoint a boarding on a specific dated service journey to start routing. """ input Location { """ 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 """ Coordinates for the location. This can be used alone or as fallback if the place id is not found. """ coordinates: InputCoordinates """ Identifies a location on a specific transit trip. When set, the search starts from the specified vehicle,considered either to be starting on-board or boarding at the provided stop. In this case, the dateTime parameter of the request is ignored, as the time is resolved based on timetable data instead. """ serviceJourneyLocation: ServiceJourneyLocationInput } """A 64-bit signed integer""" scalar Long enum Mode { air bicycle bus cableway water funicular lift rail snowAndIce metro taxi tram trolleybus monorail coach foot car scooter carpool } """ 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 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 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 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] } enum MultiModalMode { """Multi modal parent stop places without their mono modal children.""" parent """ Only mono modal children stop places, not their multi modal parent stop """ child """Both multiModal parents and their mono modal child stop places.""" all } """Text with language""" type MultilingualString { value: String! language: String } type Notice { id: ID! text: String publicCode: String } """ OccupancyStatus to be exposed in the API. The values are based on GTFS-RT """ enum OccupancyStatus { """The vehicle or carriage doesn't have any occupancy data available.""" noData "The vehicle is considered empty by most measures, and has few or no passengers onboard, but is\nstill accepting passengers. There isn't a big difference between this and `manySeatsAvailable`\nso it's possible to handle them as the same value, if one wants to limit the number of different\nvalues.\nSIRI nordic profile: merge these into `manySeatsAvailable`.\n" empty "The vehicle or carriage has a large number of seats available.\nSIRI nordic profile: more than ~50% of seats available.\n" manySeatsAvailable "The vehicle or carriage has a few seats available.\nSIRI nordic profile: less than ~50% of seats available.\n" fewSeatsAvailable "The vehicle or carriage only has standing room available.\nSIRI nordic profile: less than ~10% of seats available.\n" standingRoomOnly "The vehicle or carriage can currently accommodate only standing passengers and has limited\nspace for them. There isn't a big difference between this and `full` so it's possible to\nhandle them as the same value, if one wants to limit the number of different values.\nSIRI nordic profile: merge into `standingRoomOnly`.\n" crushedStandingRoomOnly "The vehicle or carriage is considered full by most measures, but may still be allowing\npassengers to board.\n" full "The vehicle or carriage has no seats or standing room available.\nSIRI nordic profile: if vehicle/carriage is not in use / unavailable, or passengers are only\nallowed to alight due to e.g. crowding.\n" notAcceptingPassengers } """Organisation providing public transport services.""" type Operator { id: ID! name: String! url: String phone: String lines: [Line]! serviceJourney: [ServiceJourney]! } """Information about pagination in a connection.""" type PageInfo { """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 """When paginating forwards, the cursor to continue.""" endCursor: String } """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 series of turn by turn instructions used for walking, biking and driving. """ type PathGuidance { """The distance in meters that this step takes.""" distance: Float """The relative direction of this step.""" relativeDirection: RelativeDirection """The name of the street.""" streetName: String """The absolute direction of this step.""" heading: AbsoluteDirection """When exiting a highway or traffic circle, the exit name/number.""" exit: String """ Indicates whether or not a street changes direction at an intersection. """ stayOn: Boolean """ 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 latitude of the step.""" latitude: Float """The longitude of the step.""" longitude: Float "The step's elevation profile. All elevation values, including the first one, are in meters\nabove sea level. The elevation is negative for places below sea level. The profile\nincludes both the start and end coordinate.\n" elevationProfile: [ElevationProfileStep]! } """A combination of street mode and penalty for time and cost.""" input PenaltyForStreetMode { "List of modes with the given penalty is applied to. A street-mode should not be listed\nin more than one element. If empty or null the penalty is applied to all unlisted modes,\nit becomes the default penalty for this query.\n" streetMode: StreetMode! "Penalty applied to the time for the given list of modes.\n" timePenalty: DoubleFunction! " This is used to take the time-penalty and multiply by the `costFactor`.\n The result is added to the generalized-cost.\n" costFactor: Float = 1 } """ Common super class for all places (stop places, quays, car parks, bike parks and bike rental stations ) """ type Place { """ For transit quays, the name of the quay. For points of interest, the name of the POI. """ name: String """ 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 """The latitude of the place.""" latitude: Float! """The longitude of the place.""" longitude: Float! """The quay related to the place.""" quay: Quay """The flexible area related to the place.""" flexibleArea: Coordinates """The bike rental station related to the place""" bikeRentalStation: BikeRentalStation """The rental vehicle related to the place""" rentalVehicle: RentalVehicle """ This defines if the place is a requested via location, and what kind it is. If the value is `null`, this place is not a via location. """ viaLocationType: ViaLocationType } type PlaceAtDistance { id: ID! @deprecated(reason: "Id is not referable or meaningful and will be removed") place: PlaceInterface distance: Float } """Interface for places, i.e. quays, stop places, parks""" interface PlaceInterface { id: ID! latitude: Float longitude: Float } """ Identifies a point in a journey pattern by stop location ID, optionally with an aimed departure time for disambiguation. """ input PointInJourneyPatternReference { """ The stop location ID (quay or stop place). Must not be the last stop in the journey pattern, as boarding there would not allow further travel. """ stopLocationId: String! """ The exact aimed departure time at this stop, corresponding to the aimedDepartureTime on EstimatedCall. Must match exactly. Used for disambiguation when the stop location is visited more than once in the journey pattern (e.g. ring lines). If provided, it is always validated against the timetable. """ aimedDepartureTime: DateTime } """ 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 """The distance in meters.""" distance: Int } """Types describing common presentation properties""" type Presentation { colour: String textColour: String } """Simple public transport situation element""" type PtSituationElement { id: ID! """Get affected authority for this situation element""" authority: Authority @deprecated(reason: "Use affects instead") lines: [Line]! @deprecated(reason: "Use affects instead") serviceJourneys: [ServiceJourney]! @deprecated(reason: "Use affects instead") quays: [Quay!]! @deprecated(reason: "Use affects instead") stopPlaces: [StopPlace!]! @deprecated(reason: "Use affects instead") """Get all affected entities for the situation""" affects: [Affects!]! """Summary of situation in all different translations available""" summary: [MultilingualString!]! """Description of situation in all different translations available""" description: [MultilingualString!]! """Advice of situation in all different translations available""" advice: [MultilingualString!]! """Optional links to more information.""" infoLinks: [infoLink!] """Period this situation is in effect""" validityPeriod: ValidityPeriod @deprecated(reason: "Use validityPeriods instead") """ The periods in which this situation is valid, sorted in chronological order. There is always at least one period. """ validityPeriods: [ValidityPeriod!]! """ReportType of this situation""" reportType: ReportType """Operator's internal id for this situation""" situationNumber: String """Severity of this situation """ severity: Severity """Priority of this situation """ priority: Int """Timestamp for when the situation was created.""" creationTime: DateTime """Timestamp when the situation element was updated.""" versionedAtTime: DateTime """Operator's version number for the situation element.""" version: Int """Codespace of the data source.""" participant: String """ 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.") } enum PurchaseWhen { timeOfTravelOnly dayOfTravelOnly untilPreviousDay advanceAndDayOfTravel other } """ A place such as platform, stance, or quayside where passengers have access to PT vehicles. """ type Quay implements PlaceInterface { id: ID! 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. """ language: String ): String! latitude: Float longitude: Float description: String """The stop place to which this quay belongs to.""" stopPlace: StopPlace """Whether this quay is suitable for wheelchair boarding.""" wheelchairAccessible: WheelchairBoarding timeZone: String """ Public code used to identify this quay within the stop place. For instance a platform code. """ publicCode: String """List of lines servicing this quay""" lines: [Line!]! """List of journey patterns servicing this quay""" journeyPatterns: [JourneyPattern]! """List of visits to this quay as part of vehicle journeys.""" estimatedCalls( """ 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 """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 """ 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 """ A list of filters for which estimated calls should be included. An estimated call will be included if it matches with at least one filter. An empty list is not allowed. Omit the parameter to include all estimated calls. """ filters: [EstimatedCallFilterInput!] """Indicates that real-time-cancelled trips should also be included.""" includeCancelledTrips: Boolean = false ): [EstimatedCall!]! """Get all situations active for the quay.""" situations: [PtSituationElement!]! stopType: String """Geometry for flexible area.""" flexibleArea: Coordinates """the Quays part of a flexible group.""" flexibleGroup: [Quay] tariffZones: [TariffZone]! } type QuayAtDistance { id: ID! quay: Quay """The distance in meters to the given quay.""" distance: Float } type QueryType { """ Input type for executing a travel search for a trip between two locations. Returns trip patterns describing suggested alternatives for the trip. """ trip( """ 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 "The date and time for the latest time the user is expected to book the journey.\nNormally this is when the search is performed (now), plus a small grace period to\ncomplete the booking. Services which must be booked before this time is excluded. The\n`latestBookingTime` and `minimumBookingPeriod` in `BookingArrangement` (flexible\nservices only) are used to enforce this. If this parameter is _not set_, no booking-time\nrestrictions are applied - all journeys are listed.\n" bookingTime: DateTime "The length of the search-window in minutes. This parameter is optional.\n\nThe search-window is defined as the duration between the earliest-departure-time (EDT)\nand the latest-departure-time (LDT). OTP will search for all itineraries in this\ndeparture window. If `arriveBy=true` the `dateTime` parameter is the\nlatest-arrival-time, so OTP will dynamically calculate the EDT. Using a short\nsearch-window is faster than using a longer one, but the search duration is not linear.\nUsing a \"too\" short search-window will waste resources server side, while using a\nsearch-window that is too long will be slow.\n\nOTP will dynamically calculate a reasonable value for the search-window, if not\nprovided. The calculation comes with a significant overhead (10-20% extra). Whether\nyou should use the dynamic calculated value or pass in a value depends on your use-case.\nFor a travel planner in a small geographical area, with a dense network of public\ntransportation, a fixed value between 40 minutes and 2 hours makes sense. To find the\nappropriate search-window, adjust it so that the number of itineraries on average is\naround the wanted `numTripPatterns`. Make sure you set the `numTripPatterns` to a high\nnumber while testing. For a country wide area like Norway, using the dynamic\nsearch-window is the best.\n\nWhen paginating, the search-window is calculated using the `numTripPatterns` in the\noriginal search together with statistics from the search for the last page. This\nbehaviour is configured server side, and can not be overridden from the client. The\npaging may even exceed the maximum value.\n\nThe search-window used is returned to the response metadata as `searchWindowUsed`.\nThis can be used by the client to calculate the when the next page start/end.\n\nNote! In some cases you may have to page many times to get all the results you want.\nThis is intended. Increasing the search-window beyond the max value is NOT going to be\nmuch faster. Instead the client can inform the user about the progress.\n\nMaximum value: 2880 minutes (48h)\n" searchWindow: Int "Use the cursor to go to the next \"page\" of itineraries. Copy the cursor from the last\nresponse and keep the original request as is. This will enable you to search for\nitineraries in the next or previous search-window. The paging will automatically scale\nup/down the search-window to fit the `numTripPatterns`.\n" pageCursor: String """ 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 start location""" from: Location! """The destination location""" to: Location! "The list of via locations the journey is required to visit. All locations are\nvisited in the order they are listed.\n" via: [TripViaLocationInput!] """ 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 """ Whether the trip must be wheelchair accessible. Supported for the street part to the search, not implemented for the transit yet. """ wheelchairAccessible: Boolean = false """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 """ 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 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 """ Parameters for indicating authorities, lines or quays not be used in the trip patterns """ banned: InputBanned """ Parameters for indicating the only authorities, lines or quays to be used in the trip patterns """ whiteListed: InputWhiteListed """ 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!] "Relax generalized-cost when comparing trips with a different set of\ntransit-group-priorities. The groups are set server side for service-journey and\ncan not be configured in the API. This mainly helps to return competition neutral\nservices. Long distance authorities are put in different transit-groups.\n\nThis relaxes the comparison inside the routing engine for each stop-arrival. If two\npaths have a different set of transit-group-priorities, then the generalized-cost\ncomparison is relaxed. The final set of paths are filtered through the normal\nitinerary-filters.\n\n- The `ratio` must be greater or equal to 1.0 and less then 1.2.\n- The `constant` must be greater or equal to '0s' and less then '1h'.\n" relaxTransitGroupPriority: RelaxCostInput = {ratio: 1.2, constant: "15m"} """The maximum walk speed along streets, in meters per second.""" walkSpeed: Float = 1.3 """ Walk cost is multiplied by this value. This is the main parameter to use for limiting walking. """ walkReluctance: Float = 4 """ 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 """ Bicycle routing preferences. If not provided, default values from the server configuration will be used. Deprecated top-level bike fields (bikeSpeed, bicycleOptimisationMethod, triangleFactors) take precedence if explicitly provided. """ bikePreferences: BikePreferencesInput """ Scooter routing preferences. If not provided, default values from the server configuration will be used. """ scooterPreferences: ScooterPreferencesInput """ Whether or not bike rental availability information will be used to plan bike rental trips. """ useBikeRentalAvailabilityInformation: Boolean = true """ 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 """ 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: [air : PT35M]""" boardSlackList: [TransportModeSlack] """ 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: [air : PT15M]""" alightSlackList: [TransportModeSlack] """ 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 = 12 """ Maximum number of transfers. Note! The best way to reduce the number of transfers is to set the `transferPenalty` parameter. """ maximumTransfers: Int = 12 """ 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 """ Configure the itinerary-filter-chain. NOTE! THESE PARAMETERS ARE USED FOR SERVER-SIDE TUNING AND IS AVAILABLE HERE FOR TESTING ONLY. """ itineraryFilters: ItineraryFilters """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.3 t", costFactor: 1.3}] """ 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!] = [{streetMode: bike_rental, duration: "PT20M"}, {streetMode: scooter_rental, duration: "PT20M"}, {streetMode: car, duration: "PT3H"}] """ 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!] = [{streetMode: car, duration: "PT12H"}] ): Trip! """ Get an updated version of a trip pattern with realtime changes applied. """ refetchTripPattern( """ The start location, if null the trip pattern will start with the first provided leg """ from: Location """ The destination location, if null the trip pattern will end with the last provided leg """ to: Location """ A list of legIds describing the trip pattern. At least one leg is required. """ legs: [ID!]! """ Whether the trip must be wheelchair accessible. Supported for the street part of the search. """ wheelchairAccessible: Boolean = false """ The set of access/egress modes to be used for this search. The direct and transit modes are ignored """ modes: Modes """The maximum walk speed along streets, in meters per second.""" walkSpeed: Float = 1.3 """ Walk cost is multiplied by this value. This is the main parameter to use for limiting walking. """ walkReluctance: Float = 4 """ 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: [air : PT35M]""" boardSlackList: [TransportModeSlack] """ 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: [air : PT15M]""" alightSlackList: [TransportModeSlack] """ 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!] = [{streetMode: bike_rental, duration: "PT20M"}, {streetMode: scooter_rental, duration: "PT20M"}, {streetMode: car, duration: "PT3H"}] ): RefetchTripPatternResult! @deprecated(reason: "This query is experimental and might change in the future.") """ 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 length of the search-window. This parameter is optional.\n\nThe search-window is defined as the duration between the earliest-departure-time (EDT)\nand the latest-departure-time (LDT). OTP will search for all itineraries in this\ndeparture window. If `arriveBy=true` the `dateTime` parameter is the\nlatest-arrival-time, so OTP will dynamically calculate the EDT. Using a short\nsearch-window is faster than using a longer one, but the search duration is not linear.\nUsing a \"too\" short search-window will waste resources server side, while using a\nsearch-window that is too long will be slow.\n\nOTP will dynamically calculate a reasonable value for the search-window, if not\nprovided. The calculation comes with a significant overhead (10-20% extra). Whether you\nshould use the dynamic calculated value or pass in a value depends on your use-case.\nFor a travel planner in a small geographical area, with a dense network of public\ntransportation, a fixed value between 40 minutes and 2 hours makes sense. To find the\nappropriate search-window, adjust it so that the number of itineraries on average is\naround the wanted `numItineraries`. Make sure you set the `numItineraries` to a high\nnumber while testing. For a country wide area like Norway, using the dynamic\nsearch-window is the best.\n\nWhen paginating, the search-window is calculated using the `numItineraries` in the\noriginal search together with statistics from the search for the last page. This\nbehaviour is configured server side, and can not be overridden from the client.\n\nThe search-window used is returned to the response metadata as `searchWindowUsed` for\ndebugging purposes.\n" searchWindow: Duration! """ 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 start location""" from: Location! """The destination location""" to: Location! """The locations needed to be visited along the route.""" via: [ViaLocationInput!]! """ 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 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 = 12 """ Whether the trip must be wheelchair accessible. Supported for the street part to the search, not implemented for the transit yet. """ wheelchairAccessible: Boolean = false """ 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 ): ViaTrip! @deprecated(reason: "Use the regular trip query with via stop instead.") """Get a single stopPlace based on its id)""" stopPlace(id: String!): StopPlace """Get all stopPlaces""" stopPlaces(ids: [String]): [StopPlace]! """Get all stop places within the specified bounding box""" stopPlacesByBbox( minimumLatitude: Float! minimumLongitude: Float! maximumLatitude: Float! maximumLongitude: Float! authority: String """ 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 """If true only stop places with at least one visiting line are included.""" filterByInUse: Boolean = false ): [StopPlace]! """Get a single quay based on its id)""" quay(id: String!): Quay """Get all quays""" quays(ids: [String], name: String): [Quay]! """Get all quays within the specified bounding box""" quaysByBbox( minimumLatitude: Float! minimumLongitude: Float! maximumLatitude: Float! maximumLongitude: Float! """If true only quays with at least one visiting line are included.""" filterByInUse: Boolean = false ): [Quay]! """ 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( """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! authority: String """fetching only nodes before this node (exclusive)""" before: String """fetching only nodes after this node (exclusive)""" after: String """fetching only the first certain number of nodes""" first: Int """fetching only the last certain number of nodes""" last: Int ): quayAtDistanceConnection """ 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( """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 """ Maximum number of results. Search is stopped when this limit is reached. Default is 20. """ maximumResults: Int = 20 """Only include places of given types if set. Default accepts all types""" filterByPlaceTypes: [FilterPlaceType] = [quay, stopPlace, bicycleRent, bikePark, carPark] """ Only include places that include this mode. Only checked for places with mode i.e. quays, departures. """ filterByModes: [TransportMode] """ 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 match one of the given ids.""" filterByIds: InputPlaceIds """ 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 """fetching only nodes before this node (exclusive)""" before: String """fetching only nodes after this node (exclusive)""" after: String """fetching only the first certain number of nodes""" first: Int """fetching only the last certain number of nodes""" last: Int ): placeAtDistanceConnection """Get an authority by ID""" authority(id: String!): Authority """Get all authorities""" authorities: [Authority]! """Get a operator by ID""" operator(id: String!): Operator """Get all operators""" operators: [Operator]! """Get a single line based on its id""" line(id: ID!): Line """Get all _lines_""" lines( """ 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] """Set of ids of _authorities_ to fetch _lines_ for.""" authorities: [String] """ Filter by _lines_ containing flexible / on demand _service journey_ only. """ flexibleOnly: Boolean = false ): [Line]! """Get a single group of lines based on its id""" groupOfLines(id: String!): GroupOfLines """Get all groups of lines""" groupsOfLines: [GroupOfLines!]! """Get a single service journey based on its id""" serviceJourney(id: String!): ServiceJourney """Get all _service journeys_""" serviceJourneys( """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] """Set of _operating days_ to fetch _service journeys_ for.""" activeDates: [Date] """Set of ids of _authorities_ to fetch _service journeys_ for.""" authorities: [String] ): [ServiceJourney]! """Get all bike rental stations""" bikeRentalStations(ids: [String]): [BikeRentalStation]! """Get all bike rental stations""" bikeRentalStation(id: String!): BikeRentalStation """Get all bike rental stations within the specified bounding box.""" bikeRentalStationsByBbox(minimumLatitude: Float, minimumLongitude: Float, maximumLatitude: Float, maximumLongitude: Float): [BikeRentalStation]! """Get a single bike park based on its id""" bikePark(id: String!): BikePark """Get all bike parks""" bikeParks: [BikePark]! """Get default routing parameters.""" routingParameters: RoutingParameters """Get all active situations.""" situations( """Filter by reporting source.""" codespaces: [String] """Filter by severity.""" severities: [Severity] ): [PtSituationElement!]! """Get a single situation based on its situationNumber""" situation(situationNumber: String!): PtSituationElement """Refetch a single transit leg based on its id""" leg(id: ID!): Leg """ Get OTP deployment information. This is only useful for developers of OTP itself not regular API users. """ serverInfo: ServerInfo! """Get information about the transit data available in the system.""" transitInfo: TransitInfo! """Get a single dated service journey based on its id""" datedServiceJourney(id: String): DatedServiceJourney """Get all dated service journeys, matching the filters""" datedServiceJourneys( lines: [String!] serviceJourneys: [String!] privateCodes: [String!] operatingDays: [Date!]! alterations: [ServiceAlteration!] authorities: [String!] """ Get all DatedServiceJourneys, which are replacing any of the given DatedServiceJourneys ids """ replacementFor: [String!] ): [DatedServiceJourney!]! } """The real-time state of a service journey.""" type RealTimeJourneyState { """ Has this journey been added via real-time updates? (extra journey not in the planned data) """ extraJourney: Boolean! """Has this journey been cancelled?""" cancellation: Boolean! """ Have any quay's arrival or departure times been modified from the scheduled times? """ timesModified: Boolean! """ Has the quay sequence changed from the planned journey pattern? True if quays were added, removed, reordered, or reassigned to a different quay's location. False if the journey was cancelled """ journeyPatternModified: Boolean! """Have there been any real-time updates on this journey?""" updated: Boolean! } enum RealtimeState { """ 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 """The service journey has been canceled by a real-time update.""" canceled """ 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 information has been updated and resulted in a different journey pattern compared to the journey pattern of the scheduled service journey. """ modified } """Refetched data for a trip pattern""" type RefetchTripPatternResult { """The refetched trip pattern""" tripPattern: TripPattern } enum RelativeDirection { depart hardLeft left slightlyLeft continue slightlyRight right hardRight circleClockwise circleCounterclockwise elevator uturnLeft uturnRight enterStation exitStation followSigns } "A relax-cost is used to increase the limit when comparing one cost to another cost.\nThis is used to include more results into the result. A `ratio=2.0` means a path (itinerary)\nwith twice as high cost as another one, is accepted. A `constant=$300` means a \"fixed\"\nconstant is added to the limit. A `{ratio=1.0, constant=0}` is said to be the NORMAL relaxed\ncost - the limit is the same as the cost used to calculate the limit. The NORMAL is usually\nthe default. We can express the RelaxCost as a function `f(t) = constant + ratio * t`.\n`f(t)=t` is the NORMAL function.\n" input RelaxCostInput { """The factor to multiply with the 'other cost'. Minimum value is 1.0.""" ratio: Float = 1 """ 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" } type RentalVehicle implements PlaceInterface { id: ID! vehicleType: RentalVehicleType! network: String! longitude: Float! latitude: Float! currentRangeMeters: Float } type RentalVehicleType { vehicleTypeId: String! name: String formFactor: String! propulsionType: String! maxRangeMeters: Float } """ Relation for indicating the DatedServiceJourney which is replacing an older one. Exists as a place to put additional information on the replacement when we get SIRI 2.1 support. """ type ReplacedByRelation { """The replacing DatedServiceJourney.""" datedServiceJourney: DatedServiceJourney } """ Relation for indicating the DatedServiceJourney which is replaced by a newer one. Exists as a place to put additional information on the replacement when we get SIRI 2.1 support. """ type ReplacementForRelation { """The replaced DatedServiceJourney.""" datedServiceJourney: DatedServiceJourney } enum ReportType { """Indicates a general info-message that should not affect trip.""" general """Indicates an incident that may affect trip.""" incident } """Description of the reason, why the planner did not return any results""" type RoutingError { """An enum describing the reason""" code: RoutingErrorCode! """ An enum describing the field which should be changed, in order for the search to succeed """ inputField: InputField """ 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! } 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 """ The service journey location is ambiguous because the stop is visited more than once by the service journey. An aimedDepartureTime is necessary to disambiguate. """ serviceJourneyLocationMissingAimedDepartureTime """ No usable itineraries were found for the requested direct mode and no transit was included in the search """ noDirectModeConnection } """The default parameters used in travel searches.""" type RoutingParameters { """Max walk speed along streets, in meters per second""" walkSpeed: Float """Max bike speed along streets, in meters per second""" bikeSpeed: Float """Max car speed along streets, in meters per second""" carSpeed: Float @deprecated(reason: "This parameter is no longer configurable.") """ 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 """Whether the trip must be wheelchair accessible.""" wheelChairAccessible: Boolean """The maximum number of itineraries to return.""" numItineraries: Int """The maximum slope of streets for wheelchair trips.""" maxSlope: Float """ Whether the planner should return intermediate stops lists for transit legs. """ showIntermediateStops: Boolean @deprecated(reason: "This parameter is always enabled") """ An extra penalty added on transfers (i.e. all boardings except the first one). """ transferPenalty: Int """ A multiplier for how bad walking is, compared to being in transit for equal lengths of time. """ walkReluctance: Float """ A multiplier to specify how bad walking on stairs is, compared to walking on flat ground, on top of the walk reluctance. """ stairsReluctance: Float """Multiplicative factor on expected turning time.""" turnReluctance: Float """How long it takes to get on an elevator, on average.""" elevatorBoardTime: Int """What is the cost of boarding a elevator?""" elevatorBoardCost: Int """How long it takes to advance one floor on an elevator, on average.""" elevatorHopTime: Int """What is the cost of travelling one floor on an elevator?""" elevatorHopCost: Int @deprecated(reason: "Use elevatorReluctance to set cost instead.") """A multiplier to specify how bad using an elevator is.""" elevatorReluctance: Float """Time to rent a bike.""" bikeRentalPickupTime: Int """Cost to rent a bike.""" bikeRentalPickupCost: Int """Time to drop-off a rented bike.""" bikeRentalDropOffTime: Int """Cost to drop-off a rented bike.""" bikeRentalDropOffCost: Int """Time to park a bike.""" bikeParkTime: Int """Cost to park a bike.""" bikeParkCost: Int """ Time to park a car in a park and ride, w/o taking into account driving and walking cost. """ carDropOffTime: Int """ 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 """ Separate cost for boarding a vehicle with a bicycle, which is more difficult than on foot. """ bikeBoardCost: Int """ 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 """ 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 """ 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 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] """Maximum number of transfers returned in a trip plan.""" maxTransfers: Int """ Maximum number of transfers allowed in addition to the result with least number of transfers """ maxAdditionalTransfers: Int reverseOptimizeOnTheFly: Boolean @deprecated(reason: "NOT IN USE IN OTP2.") compactLegsByReversedSearch: Boolean @deprecated(reason: "NOT IN USE IN OTP2.") """ The deceleration speed of an automobile, in meters per second per second. """ carDecelerationSpeed: Float """ The acceleration speed of an automobile, in meters per second per second. """ carAccelerationSpeed: Float """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 """If true, the remaining weight heuristic is disabled.""" disableRemainingWeightHeuristic: Boolean """""" allowBikeRental: Boolean @deprecated(reason: "Rental is specified by modes") parkAndRide: Boolean @deprecated(reason: "Parking is specified by modes") kissAndRide: Boolean @deprecated(reason: "Parking is specified by modes") debugItineraryFilter: Boolean @deprecated(reason: "Use `itineraryFilter.debug` instead.") """Accept only paths that use transit (no street-only paths).""" onlyTransitTrips: Boolean @deprecated(reason: "This is replaced by modes input object") """Option to disable the default filtering of GTFS-RT alerts by time.""" disableAlertFiltering: Boolean @deprecated(reason: "This is not supported!") """ Whether to apply the ellipsoid->geoid offset to all elevations in the response. """ geoIdElevation: Boolean } """ List of visits to quays as part of a vehicle journey, relative to the current quay and for a given date. Includes real-time updates """ type SJEstimatedCalls { """The first call in this service journey""" first: EstimatedCall! """The last call in this service journey""" last: EstimatedCall! """ The list of subsequent calls in this service journey after the current call """ next( """ Number of subsequent calls to return. The default value (null) returns all subsequent calls """ count: Int ): [EstimatedCall!]! """ The list of previous calls in this service journey before the current call """ previous( """ Number of previous calls to return. The default value (null) returns all previous calls """ count: Int ): [EstimatedCall!]! } """Scooter routing preferences.""" input ScooterPreferencesInput { """The maximum scooter speed along streets, in meters per second.""" speed: Float = 5 """ A measure of how bad scooter travel is compared to being in transit for equal periods of time. Higher values make routing prefer other modes over scooter. """ reluctance: Float = 2 """ The set of characteristics that the user wants to optimize for during scooter routing. """ optimisationMethod: VehicleOptimisationMethod = safe """ When using optimisationMethod 'triangle', these values tell the routing engine how important each factor is compared to the others. All values should add up to 1. """ triangleFactors: TriangleFactors } "Information about the deployment. This is only useful to developers of OTP itself.\nIt is not recommended for regular API consumers to use this type as it has no\nstability guarantees.\n" type ServerInfo { """Maven version""" version: String """OTP Build timestamp""" buildTime: String """""" gitBranch: String """""" gitCommit: String """""" gitCommitTime: String """The 'configVersion' of the otp-config.json file.""" otpConfigVersion: String """The 'configVersion' of the build-config.json file.""" buildConfigVersion: String """The 'configVersion' of the router-config.json file.""" routerConfigVersion: String """ The otp-serialization-version-id used to check graphs for compatibility with current version of OTP. """ otpSerializationVersionId: String " The internal time zone of the transit data.\n\n Note: The input data can be in several time zones, but OTP internally operates on a single one.\n" internalTransitModelTimeZone: String """Number of CPU cores on the OTP server""" numberOfCores: Int } enum ServiceAlteration { cancellation replaced extraJourney planned } """A planned vehicle journey with passengers.""" type ServiceJourney { id: ID! line: Line! activeDates: [Date]! transportMode: TransportMode transportSubmode: TransportSubmode """ Publicly announced code for service journey, differentiating it from other service journeys for the same line. """ publicCode: String """For internal use by operators.""" privateCode: String operator: Operator directionType: DirectionType 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.") """Whether service journey is accessible with wheelchair.""" wheelchairAccessible: WheelchairBoarding """Whether bikes are allowed on service journey.""" bikesAllowed: BikesAllowed "JourneyPattern for the service journey, according to scheduled data. If the\nServiceJourney is not included in the scheduled data, null is returned.\n" journeyPattern: JourneyPattern "Quays visited by service journey, according to scheduled data. If the\nServiceJourney is not included in the scheduled data, an empty list is returned.\n" 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!]! """ Returns scheduled passing times only - without real-time-updates, for realtime-data use 'estimatedCalls' """ passingTimes: [TimetabledPassingTime]! "Returns scheduled passingTimes for this ServiceJourney for a given date, updated with real-time-updates (if available).\nNB! This takes a date as argument (default=today) and returns estimatedCalls for that date and should only be used if the date is\nknown when creating the request. For fetching estimatedCalls for a given trip.leg, use leg.serviceJourneyEstimatedCalls instead.\n" estimatedCalls( """Date to get estimated calls for. Defaults to today.""" date: Date ): [EstimatedCall!]! """ Detailed path travelled by service journey. Not available for flexible trips. """ pointsOnLink: PointsOnLink notices: [Notice!]! """Get all situations active for the service journey.""" situations: [PtSituationElement!]! """Booking arrangements for flexible services.""" bookingArrangements: BookingArrangement @deprecated(reason: "BookingArrangements are defined per stop, and can be found under `passingTimes` or `estimatedCalls`") "Is this a replacement ServiceJourney? In NeTEx/SIRI-sourced data this can be set by\neither a replacement submode, or a replacement link in a DatedServiceJourney. Only\ntrue for GTFS-sourced data if set by the extended GTFS type.\n" isReplacement: Boolean! """Are there replacement DatedServiceJourneys for this ServiceJourney?""" replacementsExist: Boolean! } """ Identifies a specific dated service journey and a specific point within it. """ input ServiceJourneyLocationInput { """ Identifies the service journey and service date, either by service journey ID and service date, or by a dated service journey ID. """ datedServiceJourneyReference: DatedServiceJourneyReference! """ Identifies a specific point in the journey pattern. Note that cancelled stops are not allowed unless includePlannedCancellations/includeRealtimeCancellations are set accordingly. """ pointInJourneyPatternReference: PointInJourneyPatternReference! } """Identifies a service journey by service journey ID and service date.""" input ServiceJourneyOnServiceDate { """The service journey ID.""" serviceJourneyId: String! """The service date of the trip, in ISO 8601 format (YYYY-MM-DD).""" serviceDate: Date! } enum Severity { """Situation has unknown impact on trips.""" unknown """Situation has no impact on trips.""" noImpact """Situation has a very slight impact on trips.""" verySlight """Situation has a slight impact on trips.""" slight """ Situation has an impact on trips (default). Used for SIRI severities `normal` and `undefined`. """ normal """Situation has a severe impact on trips.""" severe """Situation has a very severe impact on trips.""" verySevere """Severity is undefined.""" undefined @deprecated(reason: "This value is never returned, and filtering on it matches no situations. SIRI severity `undefined` is mapped to `normal`.") } enum StopCondition { """Situation applies when stop is the destination of the leg.""" destination """Situation applies when stop is the startpoint of the leg.""" startPoint """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 } enum StopInterchangePriority { """ Preferred place to transfer, strongly recommended. NeTEx equivalent is PREFERRED_INTERCHANGE. """ preferred """Recommended stop place. NeTEx equivalent is RECOMMENDED_INTERCHANGE.""" recommended """ 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 } """ 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 { id: ID! 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. """ language: String ): String! latitude: Float longitude: Float description: String """ Relative weighting of this stop with regards to interchanges. NOT IMPLEMENTED """ weighting: InterchangeWeighting @deprecated(reason: "Not implemented. Use stopInterchangePriority") """Specify the priority of interchanges at this stop""" stopInterchangePriority: StopInterchangePriority tariffZones: [TariffZone]! """The transport modes of quays under this stop place.""" transportMode: [TransportMode] """The transport submode serviced by this stop place.""" transportSubmode: [TransportSubmode] timeZone: String """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] """Returns parent stop for this stop""" parent: StopPlace """List of visits to this stop place as part of vehicle journeys.""" estimatedCalls( """ 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 """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 arrivalDeparture: ArrivalDeparture = departures """ A list of filters for which estimated calls should be included. An estimated call will be included if it matches with at least one filter. An empty list is not allowed. Omit the parameter to include all estimated calls. """ filters: [EstimatedCallFilterInput!] """Indicates that real-time-cancelled trips should also be included.""" includeCancelledTrips: Boolean = false ): [EstimatedCall!]! """ 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!]! } """List of coordinates between two stops as a polyline""" type StopToStopGeometry { """ A list of coordinates encoded as a polyline string between two stops (see http://code.google.com/apis/maps/documentation/polylinealgorithm.html) """ pointsOnLink: PointsOnLink """Origin Quay""" fromQuay: Quay """Destination Quay""" toQuay: Quay } enum StreetMode { """Walk only""" foot """ 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 """ 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 """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 """ Share a car ride with a driver and other passengers going in the same direction. """ carpool """ 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 } """A combination of street mode and corresponding duration""" input StreetModeDurationInput { streetMode: StreetMode! duration: Duration! } """ 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 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 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 } """ 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 } """ A **zone** used to define a zonal fare structure in a zone-counting or zone-matrix system. This includes TariffZone, as well as the specialised FareZone elements. TariffZones are deprecated, please use FareZones. **TariffZone data will not be maintained from 1. MAY 2025 (Entur).** """ type TariffZone { id: ID! name: String } """Time using the format: `HH:MM:SS`. Example: `18:25:43`""" scalar Time type TimeAndDayOffset { """Local time""" time: Time """Number of days offset from base line time""" dayOffset: Int } "The time-penalty is applied to either the access-legs and/or egress-legs. Both access and\negress may contain more than one leg; Hence, the penalty is not a field on leg.\n\nNote! This is for debugging only. This type can change without notice.\n" type TimePenaltyWithCost { "The time-penalty is applied to either the access-legs and/or egress-legs. Both access\nand egress may contain more than one leg; Hence, the penalty is not a field on leg. The\n`appliedTo` describe which part of the itinerary that this instance applies to.\n" appliedTo: String "The time-penalty added to the actual time/duration when comparing the itinerary with\nother itineraries. This is used to decide which is the best option, but is not visible\n- the actual departure and arrival-times are not modified.\n" timePenalty: String "The time-penalty does also propagate to the `generalizedCost`. As a result of the given\ntime-penalty, the generalized-cost also increased by the given amount. This delta is\nincluded in the itinerary generalized-cost. In some cases the generalized-cost-delta is\nexcluded when comparing itineraries - that happens if one of the itineraries is a\n\"direct/street-only\" itinerary. Time-penalty can not be set for direct searches, so it\nneeds to be excluded from such comparison to be fair. The unit is transit-seconds.\n" generalizedCostDelta: Int } """Scheduled passing times. These are not affected by real time updates.""" type TimetabledPassingTime { quay: Quay! """Scheduled time of arrival at quay""" arrival: TimeAndDayOffset """Scheduled time of departure from quay""" departure: TimeAndDayOffset """ Whether this is a timing point or not. Boarding and alighting is not allowed at timing points. """ timingPoint: Boolean! """Whether vehicle may be boarded at quay.""" forBoarding: Boolean! """Whether vehicle may be alighted at quay.""" forAlighting: Boolean! """Whether vehicle will only stop on request.""" requestStop: Boolean! """ Earliest possible departure time for a service journey with a service window. """ earliestDepartureTime: TimeAndDayOffset """ Latest possible (planned) arrival time for a service journey with a service window. """ latestArrivalTime: TimeAndDayOffset serviceJourney: ServiceJourney! destinationDisplay: DestinationDisplay notices: [Notice!]! """Booking arrangements for this passing time.""" bookingArrangements: BookingArrangement } input TransitGeneralizedCostFilterParams { costLimitFunction: DoubleFunction! intervalRelaxFactor: Float! } """Information about the transit data available in the system.""" type TransitInfo { """ The validity period for the transit data currently loaded in the system. """ validityPeriod: ValidityPeriod } enum TransportMode { air bus cableway water funicular lift rail snowAndIce metro taxi tram trolleybus monorail coach carpool unknown } """Used to specify board and alight slack for a given modes.""" input TransportModeSlack { """The slack used for all given modes.""" slack: Int! """List of modes for which the given slack apply.""" modes: [TransportMode!]! } """Used to specify board and alight slack for a given modes.""" type TransportModeSlackType { slack: Int! modes: [TransportMode!]! } 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] } enum TransportSubmode { unknown undefined internationalFlight domesticFlight intercontinentalFlight domesticScheduledFlight shuttleFlight intercontinentalCharterFlight internationalCharterFlight roundTripCharterFlight sightseeingFlight helicopterService domesticCharterFlight SchengenAreaFlight airshipService shortHaulInternationalFlight canalBarge localBus regionalBus expressBus nightBus postBus specialNeedsBus mobilityBus mobilityBusForRegisteredDisabled sightseeingBus shuttleBus highFrequencyBus dedicatedLaneBus schoolBus schoolAndPublicServiceBus railReplacementBus demandAndResponseBus airportLinkBus internationalCoach nationalCoach shuttleCoach regionalCoach specialCoach schoolCoach sightseeingCoach touristCoach commuterCoach funicular streetCableCar allFunicularServices undefinedFunicular metro tube urbanRailway cityTram localTram regionalTram sightseeingTram shuttleTram trainTram telecabin cableCar lift chairLift dragLift telecabinLink local highSpeedRail suburbanRailway regionalRail interregionalRail longDistance international sleeperRailService nightRail carTransportRailService touristRailway airportLinkRail railShuttle replacementRailService specialTrain crossCountryRail rackAndPinionRailway internationalCarFerry nationalCarFerry regionalCarFerry localCarFerry internationalPassengerFerry nationalPassengerFerry regionalPassengerFerry localPassengerFerry postBoat trainFerry roadFerryLink airportBoatLink highSpeedVehicleService highSpeedPassengerService sightseeingService schoolBoat cableFerry riverBus scheduledFerry shuttleFerryService communalTaxi charterTaxi waterTaxi railTaxi bikeTaxi blackCab miniCab allTaxiServices hireCar hireVan hireMotorbike hireCycle allHireVehicles } """ 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! } """Description of a travel between two places.""" type Trip { """The time and date of travel""" dateTime: DateTime """The trip request metadata.""" metadata: TripSearchData """The origin""" fromPlace: Place! """The destination""" toPlace: Place! """A list of possible trip patterns""" tripPatterns: [TripPattern!]! """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") """A list of routing errors, and fields which caused them""" routingErrors: [RoutingError!]! """Information about the timings for the trip generation""" debugOutput: debugOutput! """ 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 """ 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 } """ 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 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 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 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 lines that should be included in/excluded from search""" lines: [ID!] """ Set of ids for authorities that should be included in/excluded from search """ authorities: [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!] """ Set of ids for group of lines that should be included in/excluded from the search """ groupOfLines: [ID!] } "One of the listed stop locations must be visited on-board a transit vehicle or the journey must\nalight or board at the location.\n" 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\nstop place or a group of stop places. It is enough to visit ONE of the locations\nlisted.\n" stopLocationIds: [String!]! } """ List of legs constituting a suggested sequence of rides and links for a specific trip. """ type TripPattern { """Time that the trip departs.""" startTime: DateTime @deprecated(reason: "Replaced with expectedStartTime") """Time that the trip arrives.""" endTime: DateTime @deprecated(reason: "Replaced with expectedEndTime") """The aimed date and time the trip starts.""" aimedStartTime: DateTime! """The expected, real-time adjusted date and time the trip starts.""" expectedStartTime: DateTime! """The aimed date and time the trip ends.""" aimedEndTime: DateTime! """The expected, real-time adjusted date and time the trip ends.""" expectedEndTime: DateTime! """Duration of the trip, in seconds.""" duration: Long """NOT IMPLEMENTED.""" directDuration: Long """How much time is spent waiting for transit to arrive, in seconds.""" waitingTime: Long """Total distance for the trip, in meters. NOT IMPLEMENTED""" distance: Float """How much time is spent walking, in seconds.""" walkTime: Long """ How far the user has to walk, bike and/or drive in meters. It includes all street (none transit) modes. """ streetDistance: Float walkDistance: Float @deprecated(reason: "Replaced by `streetDistance`.") """ 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!]! """Get all system notices.""" systemNotices: [SystemNotice!]! """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 cost calculated to distribute wait-time and avoid very short transfers. This field is meant for debugging only. """ waitTimeOptimizedCost: Int """ A cost calculated to favor transfer with higher priority. This field is meant for debugging only. """ transferPriorityCost: Int "A time and cost penalty applied to access and egress to favor regular scheduled\ntransit over potentially faster options with FLEX, Car, bike and scooter.\n\nNote! This field is meant for debugging only. The field can be removed without notice\nin the future.\n" timePenalty: [TimePenaltyWithCost!]! "The total emission per person. The total emission is only available if all transit\nand car leg emissions can be calculated. If only a partial result is obtained, this\nwill be null.\n" emission: Emission } """Trips search metadata.""" type TripSearchData { "The start-time of the search-window/page for trip departure times.\n\nThe search-window/page start and end time describe the time-window the search is\nperformed in. All results in the window is expected to be inside the given window. When\nnavigating to the next/previous window the new window might overlap.\n\n**Merging results from multiple searches**\n\nTrips from separate searches (multiple OTP calls or other search engines) can be merged\ninto the current page/result set if the following conditions are met:\n- The page is empty and the candidate trip departure time is between\n `pageDepartureTimeStart` and `pageDepartureTimeEnd`, or\n- The candidate trip sorts before the last trip in the current page(if trips exists).\n\nIf the trip sorts after the last trip, it should be merged into the next page instead.\nNote that the sort order is diffrent for arrive-by and depart-after search. The sort\nvector is:\n- Depart-after: _departure-time_ → _generalized-cost_ → _number-of-transfers_ → _arrival-time_\n- Arrive-by: _arrival-time_ → _generalized-cost_ → _number-of-transfers_ → _departure-time_\n\n**Special case for arrive-by searches:** For the first request (no paging cursor used)\nwith `arriveBy=true`, the `pageDepartureTimeEnd` can be ignored - trips departing after\nthis time can still be merged into the current page.\n" pageDepartureTimeStart: DateTime """ The end-time of the search-window/page for trip departure times. See `pageDepartureTimeStart` """ pageDepartureTimeEnd: DateTime """ 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! @deprecated(reason: "This not needed for debugging, and is misleading if the window is cropped.") """This will not be available after March 2026!""" nextDateTime: DateTime @deprecated(reason: "Use pageCursor instead") """This will not be available after March 2026!""" prevDateTime: DateTime @deprecated(reason: "Use pageCursor instead") } "A via-location is used to specifying a location as an intermediate place the router must\nroute through. The via-location is either a pass-through-location or a visit-via-location.\n" input TripViaLocationInput { """Board or alight at a stop location or visit a coordinate.""" visit: TripVisitViaLocationInput """Board, alight or pass-through (on-board) at the stop location.""" passThrough: TripPassThroughViaLocationInput } "A visit-via-location is a physical visit to one of the stop locations or coordinates listed. An\non-board visit does not count, the traveler must alight or board at the given stop for it to to\nbe accepted. To visit a coordinate, the traveler must walk (bike or drive) to the closest point\nin the street network from a stop and back to another stop to join the transit network.\n" input TripVisitViaLocationInput { """ 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\nvia-location before the trip is continued.\n" minimumWaitTime: Duration = "PT0S" "A list of stop locations. A stop location can be a quay, a stop place, a multimodal\nstop place or a group of stop places. It is enough to visit ONE of the locations\nlisted.\n" stopLocationIds: [String!] """A coordinate to route through.""" coordinate: InputCoordinates } type ValidityPeriod { """ The inclusive start of the validity period. Will return 'null' if the validity has an unbounded start. """ startTime: DateTime """ The exclusive end of the validity period. Will return 'null' if the validity has an unbounded end. """ endTime: DateTime } """Optimization methods for vehicle routing (bicycle, scooter, etc.).""" enum VehicleOptimisationMethod { """Prefer faster routes""" quick """Prefer safer routes""" safe """Prefer flat terrain""" flat """Custom optimization using triangle factors""" triangle } enum VertexType { normal transit bikePark bikeShare } """ 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 } """ 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 { """ 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 """ Coordinates for the location. This can be used alone or as fallback if the place id is not found. """ coordinates: InputCoordinates """ The minimum time the user wants to stay in the via location before continuing his journey """ minSlack: Duration = "PT5M" """ The maximum time the user wants to stay in the via location before continuing his journey """ maxSlack: Duration = "PT1H" } """Categorization for via locations.""" enum ViaLocationType { """ The via stop location must be visited as part of a transit trip as at the boarding stop, the intermediate stop, or the alighting stop. """ passThrough """ The location is visited physically by boarding or alighting a transit trip at a given stop, or by traveling via requested coordinate location as part of a access, transfer, egress or direct segment. Intermediate stops visited on-board do not count. """ visit } input ViaSegmentInput { """The set of access/egress/direct modes to be used for this search.""" modes: StreetModes """ 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!] } """ 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 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 list of the acceptable combinations of the trip patterns in this segment and the next segment. """ tripPatternCombinations: [[ViaConnection!]!]! """A list of routing errors, and fields which caused them""" routingErrors: [RoutingError!]! } """ 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!]! } 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 } type debugOutput { totalTime: Long } type infoLink { """URI""" uri: String! """Label""" label: 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 { """The item at the end of the edge""" node: PlaceAtDistance """cursor marks a unique position or index into the connection""" cursor: String! } """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 { """The item at the end of the edge""" node: QuayAtDistance """cursor marks a unique position or index into the connection""" cursor: String! }