Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace JourneyPlannerTypes

Index

Enumerations

Type aliases

Type aliases

Authority: { __typename?: "Authority"; fareUrl?: Maybe<Scalars["String"]>; id: Scalars["ID"]; lang?: Maybe<Scalars["String"]>; lines: Maybe<JourneyPlannerTypes.Line>[]; name: Scalars["String"]; phone?: Maybe<Scalars["String"]>; situations: Maybe<PtSituationElement>[]; timezone: Scalars["String"]; url?: Maybe<Scalars["String"]> }

Authority involved in public transportation. An organisation under which the responsibility of organising the transport service in a certain area is placed.

Type declaration

BikePark: PlaceInterface & { __typename?: "BikePark"; id: Scalars["ID"]; latitude?: Maybe<Scalars["Float"]>; longitude?: Maybe<Scalars["Float"]>; name: Scalars["String"]; realtime?: Maybe<Scalars["Boolean"]>; spacesAvailable?: Maybe<Scalars["Int"]> }
BikeRentalStation: PlaceInterface & { __typename?: "BikeRentalStation"; allowDropoff?: Maybe<Scalars["Boolean"]>; bikesAvailable?: Maybe<Scalars["Int"]>; id: Scalars["ID"]; latitude?: Maybe<Scalars["Float"]>; longitude?: Maybe<Scalars["Float"]>; name: Scalars["String"]; networks: Maybe<Scalars["String"]>[]; realtimeOccupancyAvailable?: Maybe<Scalars["Boolean"]>; spacesAvailable?: Maybe<Scalars["Int"]> }
BookingArrangement: { __typename?: "BookingArrangement"; bookingContact?: Maybe<Contact>; bookingMethods?: Maybe<Maybe<JourneyPlannerTypes.BookingMethod>[]>; bookingNote?: Maybe<Scalars["String"]>; latestBookingDay?: Maybe<Scalars["Int"]>; latestBookingTime?: Maybe<Scalars["LocalTime"]>; minimumBookingPeriod?: Maybe<Scalars["String"]> }

Type declaration

  • Optional __typename?: "BookingArrangement"
  • Optional bookingContact?: Maybe<Contact>

    Who should ticket be contacted for booking

  • Optional bookingMethods?: Maybe<Maybe<JourneyPlannerTypes.BookingMethod>[]>

    How should service be booked?

  • Optional bookingNote?: Maybe<Scalars["String"]>

    Textual description of booking arrangement for service

  • Optional latestBookingDay?: Maybe<Scalars["Int"]>

    How many days prior to the travel the service needs to be booked

  • Optional latestBookingTime?: Maybe<Scalars["LocalTime"]>

    Latest time the service can be booked. ISO 8601 timestamp

  • Optional minimumBookingPeriod?: Maybe<Scalars["String"]>

    Minimum period in advance service can be booked as a ISO 8601 duration

Contact: { __typename?: "Contact"; contactPerson?: Maybe<Scalars["String"]>; email?: Maybe<Scalars["String"]>; furtherDetails?: Maybe<Scalars["String"]>; phone?: Maybe<Scalars["String"]>; url?: Maybe<Scalars["String"]> }

Type declaration

  • Optional __typename?: "Contact"
  • Optional contactPerson?: Maybe<Scalars["String"]>

    Name of person to contact

  • Optional email?: Maybe<Scalars["String"]>

    Email adress for contact

  • Optional furtherDetails?: Maybe<Scalars["String"]>

    Textual description of how to get in contact

  • Optional phone?: Maybe<Scalars["String"]>

    Phone number for contact

  • Optional url?: Maybe<Scalars["String"]>

    Url for contact

DebugOutput: { __typename?: "debugOutput"; totalTime?: Maybe<Scalars["Long"]> }

Type declaration

  • Optional __typename?: "debugOutput"
  • Optional totalTime?: Maybe<Scalars["Long"]>
DestinationDisplay: { __typename?: "DestinationDisplay"; frontText?: Maybe<Scalars["String"]> }

An advertised destination of a specific journey pattern, usually displayed on a head sign or at other on-board locations.

Type declaration

  • Optional __typename?: "DestinationDisplay"
  • Optional frontText?: Maybe<Scalars["String"]>

    Name of destination to show on front of vehicle.

EstimatedCall: { __typename?: "EstimatedCall"; actualArrivalTime?: Maybe<Scalars["DateTime"]>; actualDepartureTime?: Maybe<Scalars["DateTime"]>; aimedArrivalTime?: Maybe<Scalars["DateTime"]>; aimedDepartureTime?: Maybe<Scalars["DateTime"]>; bookingArrangements?: Maybe<JourneyPlannerTypes.BookingArrangement>; cancellation?: Maybe<Scalars["Boolean"]>; date?: Maybe<Scalars["Date"]>; destinationDisplay?: Maybe<JourneyPlannerTypes.DestinationDisplay>; expectedArrivalTime?: Maybe<Scalars["DateTime"]>; expectedDepartureTime?: Maybe<Scalars["DateTime"]>; forAlighting?: Maybe<Scalars["Boolean"]>; forBoarding?: Maybe<Scalars["Boolean"]>; notices: Maybe<JourneyPlannerTypes.Notice>[]; predictionInaccurate?: Maybe<Scalars["Boolean"]>; quay?: Maybe<JourneyPlannerTypes.Quay>; realtime?: Maybe<Scalars["Boolean"]>; realtimeState?: Maybe<RealtimeState>; requestStop?: Maybe<Scalars["Boolean"]>; serviceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; situations: Maybe<PtSituationElement>[]; timingPoint?: Maybe<Scalars["Boolean"]> }

List of visits to quays as part of vehicle journeys. Updated with real time information where available

Type declaration

  • Optional __typename?: "EstimatedCall"
  • Optional actualArrivalTime?: Maybe<Scalars["DateTime"]>

    Actual time of arrival at quay. Updated from real time information if available. NOT IMPLEMENTED

  • Optional actualDepartureTime?: Maybe<Scalars["DateTime"]>

    Actual time of departure from quay. Updated with real time information if available. NOT IMPLEMENTED

  • Optional aimedArrivalTime?: Maybe<Scalars["DateTime"]>

    Scheduled time of arrival at quay. Not affected by read time updated

  • Optional aimedDepartureTime?: Maybe<Scalars["DateTime"]>

    Scheduled time of departure from quay. Not affected by read time updated

  • Optional bookingArrangements?: Maybe<JourneyPlannerTypes.BookingArrangement>

    Booking arrangements for this EstimatedCall.

  • Optional cancellation?: Maybe<Scalars["Boolean"]>

    Whether stop is cancelled. This means that either the ServiceJourney has a planned cancellation, the ServiceJourney has been cancelled by realtime data, or this particular StopPoint has been cancelled. This also means that both boarding and alighting has been cancelled.

  • Optional date?: Maybe<Scalars["Date"]>

    The date the estimated call is valid for.

  • Optional destinationDisplay?: Maybe<JourneyPlannerTypes.DestinationDisplay>
  • Optional expectedArrivalTime?: Maybe<Scalars["DateTime"]>

    Expected time of arrival at quay. Updated with real time information if available. Will be null if an actualArrivalTime exists

  • Optional expectedDepartureTime?: Maybe<Scalars["DateTime"]>

    Expected time of departure from quay. Updated with real time information if available. Will be null if an actualDepartureTime exists

  • Optional forAlighting?: Maybe<Scalars["Boolean"]>

    Whether vehicle may be alighted at quay according to the planned data. If the cancellation flag is set, alighting is not possible, even if this field is set to true.

  • Optional forBoarding?: Maybe<Scalars["Boolean"]>

    Whether vehicle may be boarded at quay according to the planned data. If the cancellation flag is set, boarding is not possible, even if this field is set to true.

  • notices: Maybe<JourneyPlannerTypes.Notice>[]
  • Optional predictionInaccurate?: Maybe<Scalars["Boolean"]>

    Whether the updated estimates are expected to be inaccurate. NOT IMPLEMENTED

  • Optional quay?: Maybe<JourneyPlannerTypes.Quay>
  • Optional realtime?: Maybe<Scalars["Boolean"]>

    Whether this call has been updated with real time information.

  • Optional realtimeState?: Maybe<RealtimeState>
  • Optional requestStop?: Maybe<Scalars["Boolean"]>

    Whether vehicle will only stop on request.

  • Optional serviceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>
  • situations: Maybe<PtSituationElement>[]

    Get all relevant situations for this EstimatedCall.

  • Optional timingPoint?: Maybe<Scalars["Boolean"]>

    Whether this is a timing point or not. Boarding and alighting is not allowed at timing points.

Exact<T>: { [ K in keyof T]: T[K] }

Type parameters

  • T: {}

InfoLink: { __typename?: "infoLink"; label?: Maybe<Scalars["String"]>; uri?: Maybe<Scalars["String"]> }

Type declaration

  • Optional __typename?: "infoLink"
  • Optional label?: Maybe<Scalars["String"]>

    Label

  • Optional uri?: Maybe<Scalars["String"]>

    URI

InputBanned: { authorities?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; lines?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; quays?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; quaysHard?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; serviceJourneys?: InputMaybe<InputMaybe<Scalars["ID"]>[]> }

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.

Type declaration

  • Optional authorities?: InputMaybe<InputMaybe<Scalars["ID"]>[]>

    Set of ids for authorities that should not be used

  • Optional lines?: InputMaybe<InputMaybe<Scalars["ID"]>[]>

    Set of ids for lines that should not be used

  • Optional quays?: InputMaybe<InputMaybe<Scalars["ID"]>[]>

    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.

  • Optional quaysHard?: InputMaybe<InputMaybe<Scalars["ID"]>[]>

    Set of ids of quays that should not be allowed for boarding, alighting or traveling thorugh.

  • Optional serviceJourneys?: InputMaybe<InputMaybe<Scalars["ID"]>[]>

    Set of ids of service journeys that should not be used.

InputCoordinates: { latitude: Scalars["Float"]; longitude: Scalars["Float"] }

Input type for coordinates in the WGS84 system

Type declaration

  • latitude: Scalars["Float"]

    The latitude of the place.

  • longitude: Scalars["Float"]

    The longitude of the place.

InputMaybe<T>: Maybe<T>

Type parameters

  • T

InputPlaceIds: { bikeParks?: InputMaybe<InputMaybe<Scalars["String"]>[]>; bikeRentalStations?: InputMaybe<InputMaybe<Scalars["String"]>[]>; carParks?: InputMaybe<InputMaybe<Scalars["String"]>[]>; lines?: InputMaybe<InputMaybe<Scalars["String"]>[]>; quays?: InputMaybe<InputMaybe<Scalars["String"]>[]> }

Type declaration

InputWhiteListed: { authorities?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; lines?: InputMaybe<InputMaybe<Scalars["ID"]>[]> }

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.

Type declaration

Interchange: { FromLine?: Maybe<JourneyPlannerTypes.Line>; FromServiceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; ToLine?: Maybe<JourneyPlannerTypes.Line>; ToServiceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; __typename?: "Interchange"; fromServiceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; guaranteed?: Maybe<Scalars["Boolean"]>; maximumWaitTime?: Maybe<Scalars["Int"]>; priority?: Maybe<InterchangePriority>; staySeated?: Maybe<Scalars["Boolean"]>; toServiceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney> }

Type declaration

ItineraryFilters: { groupSimilarityKeepOne?: InputMaybe<Scalars["Float"]>; groupSimilarityKeepThree?: InputMaybe<Scalars["Float"]>; groupedOtherThanSameLegsMaxCostMultiplier?: InputMaybe<Scalars["Float"]>; transitGeneralizedCostLimit?: InputMaybe<Scalars["DoubleFunction"]> }

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.

Type declaration

  • Optional groupSimilarityKeepOne?: InputMaybe<Scalars["Float"]>

    Pick ONE itinerary from each group after putting itineraries that is 85% similar together.

  • Optional groupSimilarityKeepThree?: InputMaybe<Scalars["Float"]>

    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%.

  • Optional groupedOtherThanSameLegsMaxCostMultiplier?: InputMaybe<Scalars["Float"]>

    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

  • Optional transitGeneralizedCostLimit?: InputMaybe<Scalars["DoubleFunction"]>

    Set a relative limit for all transit itineraries. The limit is calculated based on the best transit itinerary generalized-cost. Itineraries without transit legs are excluded from this filter. Example: f(x) = 3600 + 2.0 x. If the lowest cost returned is 10 000, then the limit is set to: 3 600 + 2 * 10 000 = 26 600. Then all itineraries with at least one transit leg and a cost above 26 600 is removed from the result. Default: 3600.0 + 2.5 x

JourneyPattern: { __typename?: "JourneyPattern"; directionType?: Maybe<DirectionType>; id: Scalars["ID"]; line: JourneyPlannerTypes.Line; name?: Maybe<Scalars["String"]>; notices: Maybe<JourneyPlannerTypes.Notice>[]; pointsOnLink?: Maybe<JourneyPlannerTypes.PointsOnLink>; quays: JourneyPlannerTypes.Quay[]; serviceJourneys: JourneyPlannerTypes.ServiceJourney[]; serviceJourneysForDate: JourneyPlannerTypes.ServiceJourney[]; situations: Maybe<PtSituationElement>[] }

Type declaration

JourneyPatternServiceJourneysForDateArgs: { date?: InputMaybe<Scalars["Date"]> }

Type declaration

Leg: { __typename?: "Leg"; aimedEndTime?: Maybe<Scalars["DateTime"]>; aimedStartTime?: Maybe<Scalars["DateTime"]>; authority?: Maybe<JourneyPlannerTypes.Authority>; bikeRentalNetworks: Maybe<Scalars["String"]>[]; bookingArrangements?: Maybe<JourneyPlannerTypes.BookingArrangement>; directDuration?: Maybe<Scalars["Long"]>; distance?: Maybe<Scalars["Float"]>; duration?: Maybe<Scalars["Long"]>; expectedEndTime?: Maybe<Scalars["DateTime"]>; expectedStartTime?: Maybe<Scalars["DateTime"]>; fromEstimatedCall?: Maybe<JourneyPlannerTypes.EstimatedCall>; fromPlace: JourneyPlannerTypes.Place; generalizedCost?: Maybe<Scalars["Int"]>; interchangeFrom?: Maybe<JourneyPlannerTypes.Interchange>; interchangeTo?: Maybe<JourneyPlannerTypes.Interchange>; intermediateEstimatedCalls: Maybe<JourneyPlannerTypes.EstimatedCall>[]; intermediateQuays: Maybe<JourneyPlannerTypes.Quay>[]; line?: Maybe<JourneyPlannerTypes.Line>; mode?: Maybe<Mode>; operator?: Maybe<JourneyPlannerTypes.Operator>; pointsOnLink?: Maybe<JourneyPlannerTypes.PointsOnLink>; realtime?: Maybe<Scalars["Boolean"]>; rentedBike?: Maybe<Scalars["Boolean"]>; ride?: Maybe<Scalars["Boolean"]>; serviceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; serviceJourneyEstimatedCalls: Maybe<JourneyPlannerTypes.EstimatedCall>[]; situations: Maybe<PtSituationElement>[]; steps: Maybe<PathGuidance>[]; toEstimatedCall?: Maybe<JourneyPlannerTypes.EstimatedCall>; toPlace: JourneyPlannerTypes.Place; transportSubmode?: Maybe<JourneyPlannerTypes.TransportSubmode>; walkingBike?: Maybe<Scalars["Boolean"]> }

Part of a trip pattern. Either a ride on a public transport vehicle or access or path link to/from/between places

Type declaration

Line: { __typename?: "Line"; authority?: Maybe<JourneyPlannerTypes.Authority>; bikesAllowed?: Maybe<BikesAllowed>; bookingArrangements?: Maybe<JourneyPlannerTypes.BookingArrangement>; description?: Maybe<Scalars["String"]>; flexibleLineType?: Maybe<Scalars["String"]>; id: Scalars["ID"]; journeyPatterns?: Maybe<Maybe<JourneyPattern>[]>; name?: Maybe<Scalars["String"]>; notices: Maybe<JourneyPlannerTypes.Notice>[]; operator?: Maybe<JourneyPlannerTypes.Operator>; presentation?: Maybe<Presentation>; publicCode?: Maybe<Scalars["String"]>; quays: Maybe<JourneyPlannerTypes.Quay>[]; serviceJourneys: Maybe<JourneyPlannerTypes.ServiceJourney>[]; situations: Maybe<PtSituationElement>[]; transportMode?: Maybe<JourneyPlannerTypes.TransportMode>; transportSubmode?: Maybe<JourneyPlannerTypes.TransportSubmode>; url?: Maybe<Scalars["String"]> }

A group of routes which is generally known to the public by a similar name or number

Type declaration

Location: { coordinates?: InputMaybe<InputCoordinates>; name?: InputMaybe<Scalars["String"]>; place?: InputMaybe<Scalars["String"]> }

Input format for specifying a location through either a place reference (id), coordinates or both. If both place and coordinates are provided the place ref will be used if found, coordinates will only be used if place is not known.

Type declaration

  • Optional coordinates?: InputMaybe<InputCoordinates>

    Coordinates for the location. This can be used alone or as fallback if the place id is not found.

  • Optional name?: InputMaybe<Scalars["String"]>

    The name of the location. This is pass-through informationand is not used in routing.

  • Optional place?: InputMaybe<Scalars["String"]>

    The id of an element in the OTP model. Currently supports Quay, StopPlace, multimodal StopPlace, and GroupOfStopPlaces.

MakeMaybe<T, K>: Omit<T, K> & { [ SubKey in K]: Maybe<T[SubKey]> }

Type parameters

  • T

  • K: keyof T

MakeOptional<T, K>: Omit<T, K> & { [ SubKey in K]?: Maybe<T[SubKey]> }

Type parameters

  • T

  • K: keyof T

Maybe<T>: T | null

Type parameters

  • T

Modes: { accessMode?: InputMaybe<StreetMode>; directMode?: InputMaybe<StreetMode>; egressMode?: InputMaybe<StreetMode>; transportModes?: InputMaybe<InputMaybe<TransportModes>[]> }

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.

Type declaration

  • Optional accessMode?: InputMaybe<StreetMode>

    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.

  • Optional directMode?: InputMaybe<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.

  • Optional egressMode?: InputMaybe<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.

  • Optional transportModes?: InputMaybe<InputMaybe<TransportModes>[]>

    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.

MultilingualString: { __typename?: "MultilingualString"; language?: Maybe<Scalars["String"]>; value?: Maybe<Scalars["String"]> }

Text with language

Type declaration

  • Optional __typename?: "MultilingualString"
  • Optional language?: Maybe<Scalars["String"]>
  • Optional value?: Maybe<Scalars["String"]>
Notice: { __typename?: "Notice"; id: Scalars["ID"]; publicCode?: Maybe<Scalars["String"]>; text?: Maybe<Scalars["String"]> }

Type declaration

Operator: { __typename?: "Operator"; id: Scalars["ID"]; lines: Maybe<JourneyPlannerTypes.Line>[]; name: Scalars["String"]; phone?: Maybe<Scalars["String"]>; serviceJourney: Maybe<JourneyPlannerTypes.ServiceJourney>[]; url?: Maybe<Scalars["String"]> }

Organisation providing public transport services.

Type declaration

PageInfo: { __typename?: "PageInfo"; endCursor?: Maybe<Scalars["String"]>; hasNextPage: Scalars["Boolean"]; hasPreviousPage: Scalars["Boolean"]; startCursor?: Maybe<Scalars["String"]> }

Information about pagination in a connection.

Type declaration

  • Optional __typename?: "PageInfo"
  • Optional endCursor?: Maybe<Scalars["String"]>

    When paginating forwards, the cursor to continue.

  • hasNextPage: Scalars["Boolean"]

    When paginating forwards, are there more items?

  • hasPreviousPage: Scalars["Boolean"]

    When paginating backwards, are there more items?

  • Optional startCursor?: Maybe<Scalars["String"]>

    When paginating backwards, the cursor to continue.

PathGuidance: { __typename?: "PathGuidance"; area?: Maybe<Scalars["Boolean"]>; bogusName?: Maybe<Scalars["Boolean"]>; distance?: Maybe<Scalars["Float"]>; exit?: Maybe<Scalars["String"]>; heading?: Maybe<AbsoluteDirection>; latitude?: Maybe<Scalars["Float"]>; longitude?: Maybe<Scalars["Float"]>; relativeDirection?: Maybe<RelativeDirection>; stayOn?: Maybe<Scalars["Boolean"]>; streetName?: Maybe<Scalars["String"]> }

A series of turn by turn instructions used for walking, biking and driving.

Type declaration

  • Optional __typename?: "PathGuidance"
  • Optional area?: Maybe<Scalars["Boolean"]>

    This step is on an open area, such as a plaza or train platform, and thus the directions should say something like "cross"

  • Optional bogusName?: Maybe<Scalars["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

  • Optional distance?: Maybe<Scalars["Float"]>

    The distance in meters that this step takes.

  • Optional exit?: Maybe<Scalars["String"]>

    When exiting a highway or traffic circle, the exit name/number.

  • Optional heading?: Maybe<AbsoluteDirection>

    The absolute direction of this step.

  • Optional latitude?: Maybe<Scalars["Float"]>

    The latitude of the step.

  • Optional longitude?: Maybe<Scalars["Float"]>

    The longitude of the step.

  • Optional relativeDirection?: Maybe<RelativeDirection>

    The relative direction of this step.

  • Optional stayOn?: Maybe<Scalars["Boolean"]>

    Indicates whether or not a street changes direction at an intersection.

  • Optional streetName?: Maybe<Scalars["String"]>

    The name of the street.

Place: { __typename?: "Place"; bikeRentalStation?: Maybe<JourneyPlannerTypes.BikeRentalStation>; flexibleArea?: Maybe<Scalars["Coordinates"]>; latitude: Scalars["Float"]; longitude: Scalars["Float"]; name?: Maybe<Scalars["String"]>; quay?: Maybe<JourneyPlannerTypes.Quay>; rentalVehicle?: Maybe<RentalVehicle>; vertexType?: Maybe<VertexType> }

Common super class for all places (stop places, quays, car parks, bike parks and bike rental stations )

Type declaration

  • Optional __typename?: "Place"
  • Optional bikeRentalStation?: Maybe<JourneyPlannerTypes.BikeRentalStation>

    The bike rental station related to the place

  • Optional flexibleArea?: Maybe<Scalars["Coordinates"]>

    The flexible area related to the place.

  • latitude: Scalars["Float"]

    The latitude of the place.

  • longitude: Scalars["Float"]

    The longitude of the place.

  • Optional name?: Maybe<Scalars["String"]>

    For transit quays, the name of the quay. For points of interest, the name of the POI.

  • Optional quay?: Maybe<JourneyPlannerTypes.Quay>

    The quay related to the place.

  • Optional rentalVehicle?: Maybe<RentalVehicle>

    The rental vehicle related to the place

  • Optional vertexType?: Maybe<VertexType>

    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

PlaceAtDistance: { __typename?: "PlaceAtDistance"; distance?: Maybe<Scalars["Float"]>; id: Scalars["ID"]; place?: Maybe<PlaceInterface> }

Type declaration

  • Optional __typename?: "PlaceAtDistance"
  • Optional distance?: Maybe<Scalars["Float"]>
  • id: Scalars["ID"]
    deprecated

    Id is not referable or meaningful and will be removed

  • Optional place?: Maybe<PlaceInterface>
PlaceAtDistanceConnection: { __typename?: "placeAtDistanceConnection"; edges?: Maybe<Maybe<PlaceAtDistanceEdge>[]>; pageInfo: PageInfo }

A connection to a list of items.

Type declaration

PlaceAtDistanceEdge: { __typename?: "placeAtDistanceEdge"; cursor: Scalars["String"]; node?: Maybe<PlaceAtDistance> }

An edge in a connection

Type declaration

  • Optional __typename?: "placeAtDistanceEdge"
  • cursor: Scalars["String"]

    cursor marks a unique position or index into the connection

  • Optional node?: Maybe<PlaceAtDistance>

    The item at the end of the edge

PlaceInterface: { id: Scalars["ID"]; latitude?: Maybe<Scalars["Float"]>; longitude?: Maybe<Scalars["Float"]> }

Interface for places, i.e. quays, stop places, parks

Type declaration

PointsOnLink: { __typename?: "PointsOnLink"; length?: Maybe<Scalars["Int"]>; points?: Maybe<Scalars["String"]> }

A list of coordinates encoded as a polyline string (see http://code.google.com/apis/maps/documentation/polylinealgorithm.html)

Type declaration

Presentation: { __typename?: "Presentation"; colour?: Maybe<Scalars["String"]>; textColour?: Maybe<Scalars["String"]> }

Types describing common presentation properties

Type declaration

  • Optional __typename?: "Presentation"
  • Optional colour?: Maybe<Scalars["String"]>
  • Optional textColour?: Maybe<Scalars["String"]>
PtSituationElement: { __typename?: "PtSituationElement"; advice: JourneyPlannerTypes.MultilingualString[]; authority?: Maybe<JourneyPlannerTypes.Authority>; description: JourneyPlannerTypes.MultilingualString[]; id: Scalars["ID"]; infoLinks?: Maybe<Maybe<JourneyPlannerTypes.InfoLink>[]>; lines: Maybe<JourneyPlannerTypes.Line>[]; priority?: Maybe<Scalars["Int"]>; quays: Maybe<JourneyPlannerTypes.Quay>[]; reportAuthority?: Maybe<JourneyPlannerTypes.Authority>; reportType?: Maybe<JourneyPlannerTypes.ReportType>; serviceJourneys: Maybe<JourneyPlannerTypes.ServiceJourney>[]; severity?: Maybe<Severity>; situationNumber?: Maybe<Scalars["String"]>; summary: JourneyPlannerTypes.MultilingualString[]; validityPeriod?: Maybe<JourneyPlannerTypes.ValidityPeriod> }

Simple public transport situation element

Type declaration

Quay: PlaceInterface & { __typename?: "Quay"; description?: Maybe<Scalars["String"]>; estimatedCalls: JourneyPlannerTypes.EstimatedCall[]; id: Scalars["ID"]; journeyPatterns: Maybe<JourneyPattern>[]; latitude?: Maybe<Scalars["Float"]>; lines: JourneyPlannerTypes.Line[]; longitude?: Maybe<Scalars["Float"]>; name: Scalars["String"]; publicCode?: Maybe<Scalars["String"]>; situations: Maybe<PtSituationElement>[]; stopPlace?: Maybe<JourneyPlannerTypes.StopPlace>; tariffZones: Maybe<JourneyPlannerTypes.TariffZone>[]; wheelchairAccessible?: Maybe<WheelchairBoarding> }

A place such as platform, stance, or quayside where passengers have access to PT vehicles.

QuayAtDistance: { __typename?: "QuayAtDistance"; distance?: Maybe<Scalars["Float"]>; id: Scalars["ID"]; quay?: Maybe<JourneyPlannerTypes.Quay> }

Type declaration

QuayAtDistanceConnection: { __typename?: "quayAtDistanceConnection"; edges?: Maybe<Maybe<QuayAtDistanceEdge>[]>; pageInfo: PageInfo }

A connection to a list of items.

Type declaration

QuayAtDistanceEdge: { __typename?: "quayAtDistanceEdge"; cursor: Scalars["String"]; node?: Maybe<QuayAtDistance> }

An edge in a connection

Type declaration

  • Optional __typename?: "quayAtDistanceEdge"
  • cursor: Scalars["String"]

    cursor marks a unique position or index into the connection

  • Optional node?: Maybe<QuayAtDistance>

    The item at the end of the edge

QuayEstimatedCallsArgs: { arrivalDeparture?: InputMaybe<ArrivalDeparture>; includeCancelledTrips?: InputMaybe<Scalars["Boolean"]>; numberOfDepartures?: InputMaybe<Scalars["Int"]>; numberOfDeparturesPerLineAndDestinationDisplay?: InputMaybe<Scalars["Int"]>; omitNonBoarding?: InputMaybe<Scalars["Boolean"]>; startTime?: InputMaybe<Scalars["DateTime"]>; timeRange?: InputMaybe<Scalars["Int"]>; whiteListed?: InputMaybe<JourneyPlannerTypes.InputWhiteListed>; whiteListedModes?: InputMaybe<InputMaybe<JourneyPlannerTypes.TransportMode>[]> }

A place such as platform, stance, or quayside where passengers have access to PT vehicles.

Type declaration

QueryType: { __typename?: "QueryType"; authorities: Maybe<JourneyPlannerTypes.Authority>[]; authority?: Maybe<JourneyPlannerTypes.Authority>; bikePark?: Maybe<BikePark>; bikeParks: Maybe<BikePark>[]; bikeRentalStation?: Maybe<JourneyPlannerTypes.BikeRentalStation>; bikeRentalStations: Maybe<JourneyPlannerTypes.BikeRentalStation>[]; bikeRentalStationsByBbox: Maybe<JourneyPlannerTypes.BikeRentalStation>[]; line?: Maybe<JourneyPlannerTypes.Line>; lines: Maybe<JourneyPlannerTypes.Line>[]; nearest?: Maybe<PlaceAtDistanceConnection>; operator?: Maybe<JourneyPlannerTypes.Operator>; operators: Maybe<JourneyPlannerTypes.Operator>[]; quay?: Maybe<JourneyPlannerTypes.Quay>; quays: Maybe<JourneyPlannerTypes.Quay>[]; quaysByBbox: Maybe<JourneyPlannerTypes.Quay>[]; quaysByRadius?: Maybe<QuayAtDistanceConnection>; routingParameters?: Maybe<RoutingParameters>; serverInfo: ServerInfo; serviceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; serviceJourneys: Maybe<JourneyPlannerTypes.ServiceJourney>[]; situation?: Maybe<PtSituationElement>; situations: Maybe<PtSituationElement>[]; stopPlace?: Maybe<JourneyPlannerTypes.StopPlace>; stopPlaces: Maybe<JourneyPlannerTypes.StopPlace>[]; stopPlacesByBbox: Maybe<JourneyPlannerTypes.StopPlace>[]; trip: Trip }

Type declaration

QueryTypeAuthorityArgs: { id: Scalars["String"] }

Type declaration

QueryTypeBikeParkArgs: { id: Scalars["String"] }

Type declaration

QueryTypeBikeRentalStationArgs: { id: Scalars["String"] }

Type declaration

QueryTypeBikeRentalStationsArgs: { ids?: InputMaybe<InputMaybe<Scalars["String"]>[]> }

Type declaration

QueryTypeBikeRentalStationsByBboxArgs: { maximumLatitude?: InputMaybe<Scalars["Float"]>; maximumLongitude?: InputMaybe<Scalars["Float"]>; minimumLatitude?: InputMaybe<Scalars["Float"]>; minimumLongitude?: InputMaybe<Scalars["Float"]> }

Type declaration

QueryTypeLineArgs: { id: Scalars["ID"] }

Type declaration

QueryTypeLinesArgs: { authorities?: InputMaybe<InputMaybe<Scalars["String"]>[]>; flexibleOnly?: InputMaybe<Scalars["Boolean"]>; ids?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; name?: InputMaybe<Scalars["String"]>; publicCode?: InputMaybe<Scalars["String"]>; publicCodes?: InputMaybe<InputMaybe<Scalars["String"]>[]>; transportModes?: InputMaybe<InputMaybe<JourneyPlannerTypes.TransportMode>[]> }

Type declaration

QueryTypeNearestArgs: { after?: InputMaybe<Scalars["String"]>; before?: InputMaybe<Scalars["String"]>; filterByIds?: InputMaybe<InputPlaceIds>; filterByInUse?: InputMaybe<Scalars["Boolean"]>; filterByModes?: InputMaybe<InputMaybe<JourneyPlannerTypes.TransportMode>[]>; filterByPlaceTypes?: InputMaybe<InputMaybe<FilterPlaceType>[]>; first?: InputMaybe<Scalars["Int"]>; last?: InputMaybe<Scalars["Int"]>; latitude: Scalars["Float"]; longitude: Scalars["Float"]; maximumDistance?: Scalars["Float"]; maximumResults?: InputMaybe<Scalars["Int"]>; multiModalMode?: InputMaybe<MultiModalMode> }

Type declaration

QueryTypeOperatorArgs: { id: Scalars["String"] }

Type declaration

QueryTypeQuayArgs: { id: Scalars["String"] }

Type declaration

QueryTypeQuaysArgs: { ids?: InputMaybe<InputMaybe<Scalars["String"]>[]>; name?: InputMaybe<Scalars["String"]> }

Type declaration

QueryTypeQuaysByBboxArgs: { authority?: InputMaybe<Scalars["String"]>; filterByInUse?: InputMaybe<Scalars["Boolean"]>; maximumLatitude: Scalars["Float"]; maximumLongitude: Scalars["Float"]; minimumLatitude: Scalars["Float"]; minimumLongitude: Scalars["Float"] }

Type declaration

QueryTypeQuaysByRadiusArgs: { after?: InputMaybe<Scalars["String"]>; authority?: InputMaybe<Scalars["String"]>; before?: InputMaybe<Scalars["String"]>; first?: InputMaybe<Scalars["Int"]>; last?: InputMaybe<Scalars["Int"]>; latitude: Scalars["Float"]; longitude: Scalars["Float"]; radius: Scalars["Float"] }

Type declaration

QueryTypeServiceJourneyArgs: { id: Scalars["String"] }

Type declaration

QueryTypeServiceJourneysArgs: { activeDates?: InputMaybe<InputMaybe<Scalars["Date"]>[]>; authorities?: InputMaybe<InputMaybe<Scalars["String"]>[]>; lines?: InputMaybe<InputMaybe<Scalars["ID"]>[]>; privateCodes?: InputMaybe<InputMaybe<Scalars["String"]>[]> }

Type declaration

QueryTypeSituationArgs: { situationNumber: Scalars["String"] }

Type declaration

QueryTypeSituationsArgs: { authorities?: InputMaybe<InputMaybe<Scalars["String"]>[]>; severities?: InputMaybe<InputMaybe<Severity>[]> }

Type declaration

QueryTypeStopPlaceArgs: { id: Scalars["String"] }

Type declaration

QueryTypeStopPlacesArgs: { ids?: InputMaybe<InputMaybe<Scalars["String"]>[]> }

Type declaration

QueryTypeStopPlacesByBboxArgs: { authority?: InputMaybe<Scalars["String"]>; filterByInUse?: InputMaybe<Scalars["Boolean"]>; maximumLatitude: Scalars["Float"]; maximumLongitude: Scalars["Float"]; minimumLatitude: Scalars["Float"]; minimumLongitude: Scalars["Float"]; multiModalMode?: InputMaybe<MultiModalMode> }

Type declaration

QueryTypeTripArgs: { alightSlackDefault?: InputMaybe<Scalars["Int"]>; alightSlackList?: InputMaybe<InputMaybe<TransportModeSlack>[]>; arriveBy?: InputMaybe<Scalars["Boolean"]>; banned?: InputMaybe<JourneyPlannerTypes.InputBanned>; bicycleOptimisationMethod?: InputMaybe<BicycleOptimisationMethod>; bikeSpeed?: InputMaybe<Scalars["Float"]>; boardSlackDefault?: InputMaybe<Scalars["Int"]>; boardSlackList?: InputMaybe<InputMaybe<TransportModeSlack>[]>; dateTime?: InputMaybe<Scalars["DateTime"]>; debugItineraryFilter?: InputMaybe<Scalars["Boolean"]>; extraSearchCoachReluctance?: InputMaybe<Scalars["Float"]>; from: JourneyPlannerTypes.Location; ignoreRealtimeUpdates?: InputMaybe<Scalars["Boolean"]>; includePlannedCancellations?: InputMaybe<Scalars["Boolean"]>; itineraryFilters?: InputMaybe<ItineraryFilters>; locale?: InputMaybe<Locale>; maximumTransfers?: InputMaybe<Scalars["Int"]>; modes?: InputMaybe<Modes>; numTripPatterns?: InputMaybe<Scalars["Int"]>; pageCursor?: InputMaybe<Scalars["String"]>; searchWindow?: InputMaybe<Scalars["Int"]>; timetableView?: InputMaybe<Scalars["Boolean"]>; to: JourneyPlannerTypes.Location; transferPenalty?: InputMaybe<Scalars["Int"]>; transferSlack?: InputMaybe<Scalars["Int"]>; transitGeneralizedCostLimit?: InputMaybe<Scalars["DoubleFunction"]>; triangleFactors?: InputMaybe<TriangleFactors>; useBikeRentalAvailabilityInformation?: InputMaybe<Scalars["Boolean"]>; waitReluctance?: InputMaybe<Scalars["Float"]>; walkReluctance?: InputMaybe<Scalars["Float"]>; walkSpeed?: InputMaybe<Scalars["Float"]>; wheelchairAccessible?: InputMaybe<Scalars["Boolean"]>; whiteListed?: InputMaybe<JourneyPlannerTypes.InputWhiteListed> }

Type declaration

RentalVehicle: PlaceInterface & { __typename?: "RentalVehicle"; currentRangeMeters?: Maybe<Scalars["Float"]>; id: Scalars["ID"]; latitude: Scalars["Float"]; longitude: Scalars["Float"]; network: Scalars["String"]; vehicleType: RentalVehicleType }
RentalVehicleType: { __typename?: "RentalVehicleType"; formFactor: Scalars["String"]; maxRangeMeters?: Maybe<Scalars["Float"]>; name?: Maybe<Scalars["String"]>; propulsionType: Scalars["String"]; vehicleTypeId: Scalars["String"] }

Type declaration

RoutingError: { __typename?: "RoutingError"; code: RoutingErrorCode; description: Scalars["String"]; inputField?: Maybe<InputField> }

Description of the reason, why the planner did not return any results

Type declaration

  • Optional __typename?: "RoutingError"
  • code: RoutingErrorCode

    An enum describing the reason

  • description: Scalars["String"]

    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.

  • Optional inputField?: Maybe<InputField>

    An enum describing the field which should be changed, in order for the search to succeed

RoutingParameters: { __typename?: "RoutingParameters"; alightSlackDefault?: Maybe<Scalars["Int"]>; alightSlackList?: Maybe<Maybe<TransportModeSlackType>[]>; allowBikeRental?: Maybe<Scalars["Boolean"]>; bikeBoardCost?: Maybe<Scalars["Int"]>; bikeParkCost?: Maybe<Scalars["Int"]>; bikeParkTime?: Maybe<Scalars["Int"]>; bikeRentalDropOffCost?: Maybe<Scalars["Int"]>; bikeRentalDropOffTime?: Maybe<Scalars["Int"]>; bikeRentalPickupCost?: Maybe<Scalars["Int"]>; bikeRentalPickupTime?: Maybe<Scalars["Int"]>; bikeSpeed?: Maybe<Scalars["Float"]>; boardSlackDefault?: Maybe<Scalars["Int"]>; boardSlackList?: Maybe<Maybe<TransportModeSlackType>[]>; carAccelerationSpeed?: Maybe<Scalars["Float"]>; carDecelerationSpeed?: Maybe<Scalars["Float"]>; carDropOffTime?: Maybe<Scalars["Int"]>; carSpeed?: Maybe<Scalars["Float"]>; compactLegsByReversedSearch?: Maybe<Scalars["Boolean"]>; debugItineraryFilter?: Maybe<Scalars["Boolean"]>; disableAlertFiltering?: Maybe<Scalars["Boolean"]>; disableRemainingWeightHeuristic?: Maybe<Scalars["Boolean"]>; elevatorBoardCost?: Maybe<Scalars["Int"]>; elevatorBoardTime?: Maybe<Scalars["Int"]>; elevatorHopCost?: Maybe<Scalars["Int"]>; elevatorHopTime?: Maybe<Scalars["Int"]>; geoIdElevation?: Maybe<Scalars["Boolean"]>; ignoreRealTimeUpdates?: Maybe<Scalars["Boolean"]>; includedPlannedCancellations?: Maybe<Scalars["Boolean"]>; kissAndRide?: Maybe<Scalars["Boolean"]>; maxDirectStreetDuration?: Maybe<Scalars["Float"]>; maxSlope?: Maybe<Scalars["Float"]>; maxTransfers?: Maybe<Scalars["Int"]>; numItineraries?: Maybe<Scalars["Int"]>; onlyTransitTrips?: Maybe<Scalars["Boolean"]>; otherThanPreferredRoutesPenalty?: Maybe<Scalars["Int"]>; parkAndRide?: Maybe<Scalars["Boolean"]>; reverseOptimizeOnTheFly?: Maybe<Scalars["Boolean"]>; showIntermediateStops?: Maybe<Scalars["Boolean"]>; stairsReluctance?: Maybe<Scalars["Float"]>; transferPenalty?: Maybe<Scalars["Int"]>; transferSlack?: Maybe<Scalars["Int"]>; turnReluctance?: Maybe<Scalars["Float"]>; waitAtBeginningFactor?: Maybe<Scalars["Float"]>; waitReluctance?: Maybe<Scalars["Float"]>; walkBoardCost?: Maybe<Scalars["Int"]>; walkReluctance?: Maybe<Scalars["Float"]>; walkSpeed?: Maybe<Scalars["Float"]>; wheelChairAccessible?: Maybe<Scalars["Boolean"]> }

The default parameters used in travel searches.

Type declaration

  • Optional __typename?: "RoutingParameters"
  • Optional alightSlackDefault?: Maybe<Scalars["Int"]>

    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'.

  • Optional alightSlackList?: Maybe<Maybe<TransportModeSlackType>[]>

    List of alightSlack for a given set of modes.

  • Optional allowBikeRental?: Maybe<Scalars["Boolean"]>
    deprecated

    Rental is specified by modes

  • Optional bikeBoardCost?: Maybe<Scalars["Int"]>

    Separate cost for boarding a vehicle with a bicycle, which is more difficult than on foot.

  • Optional bikeParkCost?: Maybe<Scalars["Int"]>

    Cost to park a bike.

  • Optional bikeParkTime?: Maybe<Scalars["Int"]>

    Time to park a bike.

  • Optional bikeRentalDropOffCost?: Maybe<Scalars["Int"]>

    Cost to drop-off a rented bike.

  • Optional bikeRentalDropOffTime?: Maybe<Scalars["Int"]>

    Time to drop-off a rented bike.

  • Optional bikeRentalPickupCost?: Maybe<Scalars["Int"]>

    Cost to rent a bike.

  • Optional bikeRentalPickupTime?: Maybe<Scalars["Int"]>

    Time to rent a bike.

  • Optional bikeSpeed?: Maybe<Scalars["Float"]>

    Max bike speed along streets, in meters per second

  • Optional boardSlackDefault?: Maybe<Scalars["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 apply to to the first transit leg in the trip. This is the default value used, if not overridden by the 'boardSlackList'.

  • Optional boardSlackList?: Maybe<Maybe<TransportModeSlackType>[]>

    List of boardSlack for a given set of modes.

  • Optional carAccelerationSpeed?: Maybe<Scalars["Float"]>

    The acceleration speed of an automobile, in meters per second per second.

  • Optional carDecelerationSpeed?: Maybe<Scalars["Float"]>

    The deceleration speed of an automobile, in meters per second per second.

  • Optional carDropOffTime?: Maybe<Scalars["Int"]>

    Time to park a car in a park and ride, w/o taking into account driving and walking cost.

  • Optional carSpeed?: Maybe<Scalars["Float"]>

    Max car speed along streets, in meters per second

  • Optional compactLegsByReversedSearch?: Maybe<Scalars["Boolean"]>
    deprecated

    NOT IN USE IN OTP2.

  • Optional debugItineraryFilter?: Maybe<Scalars["Boolean"]>
  • Optional disableAlertFiltering?: Maybe<Scalars["Boolean"]>

    Option to disable the default filtering of GTFS-RT alerts by time.

  • Optional disableRemainingWeightHeuristic?: Maybe<Scalars["Boolean"]>

    If true, the remaining weight heuristic is disabled.

  • Optional elevatorBoardCost?: Maybe<Scalars["Int"]>

    What is the cost of boarding a elevator?

  • Optional elevatorBoardTime?: Maybe<Scalars["Int"]>

    How long does it take to get on an elevator, on average.

  • Optional elevatorHopCost?: Maybe<Scalars["Int"]>

    What is the cost of travelling one floor on an elevator?

  • Optional elevatorHopTime?: Maybe<Scalars["Int"]>

    How long does it take to advance one floor on an elevator?

  • Optional geoIdElevation?: Maybe<Scalars["Boolean"]>

    Whether to apply the ellipsoid->geoid offset to all elevations in the response.

  • Optional ignoreRealTimeUpdates?: Maybe<Scalars["Boolean"]>

    When true, realtime updates are ignored during this search.

  • Optional includedPlannedCancellations?: Maybe<Scalars["Boolean"]>

    When true, service journeys cancelled in scheduled route data will be included during this search.

  • Optional kissAndRide?: Maybe<Scalars["Boolean"]>
  • Optional maxDirectStreetDuration?: Maybe<Scalars["Float"]>

    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.

  • Optional maxSlope?: Maybe<Scalars["Float"]>

    The maximum slope of streets for wheelchair trips.

  • Optional maxTransfers?: Maybe<Scalars["Int"]>

    Maximum number of transfers returned in a trip plan.

  • Optional numItineraries?: Maybe<Scalars["Int"]>

    The maximum number of itineraries to return.

  • Optional onlyTransitTrips?: Maybe<Scalars["Boolean"]>

    Accept only paths that use transit (no street-only paths).

  • Optional otherThanPreferredRoutesPenalty?: Maybe<Scalars["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.

  • Optional parkAndRide?: Maybe<Scalars["Boolean"]>
  • Optional reverseOptimizeOnTheFly?: Maybe<Scalars["Boolean"]>
    deprecated

    NOT IN USE IN OTP2.

  • Optional showIntermediateStops?: Maybe<Scalars["Boolean"]>

    Whether the planner should return intermediate stops lists for transit legs.

  • Optional stairsReluctance?: Maybe<Scalars["Float"]>

    Used instead of walkReluctance for stairs.

  • Optional transferPenalty?: Maybe<Scalars["Int"]>

    An extra penalty added on transfers (i.e. all boardings except the first one).

  • Optional transferSlack?: Maybe<Scalars["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.

  • Optional turnReluctance?: Maybe<Scalars["Float"]>

    Multiplicative factor on expected turning time.

  • Optional waitAtBeginningFactor?: Maybe<Scalars["Float"]>

    How much less bad is waiting at the beginning of the trip (replaces waitReluctance on the first boarding).

  • Optional waitReluctance?: Maybe<Scalars["Float"]>

    How much worse is waiting for a transit vehicle than being on a transit vehicle, as a multiplier.

  • Optional walkBoardCost?: Maybe<Scalars["Int"]>

    This prevents unnecessary transfers by adding a cost for boarding a vehicle.

  • Optional walkReluctance?: Maybe<Scalars["Float"]>

    A multiplier for how bad walking is, compared to being in transit for equal lengths of time.

  • Optional walkSpeed?: Maybe<Scalars["Float"]>

    Max walk speed along streets, in meters per second

  • Optional wheelChairAccessible?: Maybe<Scalars["Boolean"]>

    Whether the trip must be wheelchair accessible.

Scalars: { Boolean: boolean; Coordinates: any; Date: any; DateTime: any; DoubleFunction: any; Float: number; ID: string; Int: number; LocalTime: any; Long: any; String: string; Time: any }

All built-in and custom scalars, mapped to their actual values

Type declaration

  • Boolean: boolean
  • Coordinates: any

    List of coordinates like: [[60.89, 11.12], [62.56, 12.10]]

  • Date: any

    Local date using the ISO 8601 format: YYYY-MM-DD. Example: 2020-05-17.

  • DateTime: any

    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

  • DoubleFunction: any

    A linear function to calculate a value(y) based on a parameter (x): y = f(x) = a + bx. It allows setting both a constant(a) and a coefficient(b) and the use those in the computation. Format: a + b x. Example: 1800 + 2.0 x

  • Float: number
  • ID: string
  • Int: number
  • LocalTime: any

    Time using the format: HH:mm:SS. Example: 18:25:SS

  • Long: any

    Long type

  • String: string
  • Time: any

    Time using the format: HH:MM:SS. Example: 18:25:43

ServerInfo: { __typename?: "ServerInfo"; buildConfigVersion?: Maybe<Scalars["String"]>; buildTime?: Maybe<Scalars["String"]>; gitBranch?: Maybe<Scalars["String"]>; gitCommit?: Maybe<Scalars["String"]>; gitCommitTime?: Maybe<Scalars["String"]>; otpConfigVersion?: Maybe<Scalars["String"]>; otpSerializationVersionId?: Maybe<Scalars["String"]>; routerConfigVersion?: Maybe<Scalars["String"]>; version?: Maybe<Scalars["String"]> }

Type declaration

  • Optional __typename?: "ServerInfo"
  • Optional buildConfigVersion?: Maybe<Scalars["String"]>

    The 'configVersion' of the build-config.json file.

  • Optional buildTime?: Maybe<Scalars["String"]>

    OTP Build timestamp

  • Optional gitBranch?: Maybe<Scalars["String"]>
  • Optional gitCommit?: Maybe<Scalars["String"]>
  • Optional gitCommitTime?: Maybe<Scalars["String"]>
  • Optional otpConfigVersion?: Maybe<Scalars["String"]>

    The 'configVersion' of the otp-config.json file.

  • Optional otpSerializationVersionId?: Maybe<Scalars["String"]>

    The otp-serialization-version-id used to check graphs for compatibility with current version of OTP.

  • Optional routerConfigVersion?: Maybe<Scalars["String"]>

    The 'configVersion' of the router-config.json file.

  • Optional version?: Maybe<Scalars["String"]>

    Maven version

ServiceJourney: { __typename?: "ServiceJourney"; activeDates: Maybe<Scalars["Date"]>[]; bikesAllowed?: Maybe<BikesAllowed>; bookingArrangements?: Maybe<JourneyPlannerTypes.BookingArrangement>; directionType?: Maybe<DirectionType>; estimatedCalls?: Maybe<Maybe<JourneyPlannerTypes.EstimatedCall>[]>; id: Scalars["ID"]; journeyPattern?: Maybe<JourneyPattern>; line: JourneyPlannerTypes.Line; notices: Maybe<JourneyPlannerTypes.Notice>[]; operator?: Maybe<JourneyPlannerTypes.Operator>; passingTimes: Maybe<TimetabledPassingTime>[]; pointsOnLink?: Maybe<JourneyPlannerTypes.PointsOnLink>; privateCode?: Maybe<Scalars["String"]>; publicCode?: Maybe<Scalars["String"]>; quays: JourneyPlannerTypes.Quay[]; serviceAlteration?: Maybe<ServiceAlteration>; situations: Maybe<PtSituationElement>[]; transportMode?: Maybe<JourneyPlannerTypes.TransportMode>; transportSubmode?: Maybe<JourneyPlannerTypes.TransportSubmode>; wheelchairAccessible?: Maybe<WheelchairBoarding> }

A planned vehicle journey with passengers.

Type declaration

ServiceJourneyEstimatedCallsArgs: { date?: InputMaybe<Scalars["Date"]> }

A planned vehicle journey with passengers.

Type declaration

StopPlace: PlaceInterface & { __typename?: "StopPlace"; description?: Maybe<Scalars["String"]>; estimatedCalls: JourneyPlannerTypes.EstimatedCall[]; id: Scalars["ID"]; latitude?: Maybe<Scalars["Float"]>; longitude?: Maybe<Scalars["Float"]>; name: Scalars["String"]; parent?: Maybe<JourneyPlannerTypes.StopPlace>; quays?: Maybe<Maybe<JourneyPlannerTypes.Quay>[]>; tariffZones: Maybe<JourneyPlannerTypes.TariffZone>[]; transportMode?: Maybe<Maybe<JourneyPlannerTypes.TransportMode>[]>; transportSubmode?: Maybe<Maybe<JourneyPlannerTypes.TransportSubmode>[]>; weighting?: Maybe<InterchangeWeighting> }

Named place where public transport may be accessed. May be a building complex (e.g. a station) or an on-street location.

StopPlaceEstimatedCallsArgs: { arrivalDeparture?: InputMaybe<ArrivalDeparture>; includeCancelledTrips?: InputMaybe<Scalars["Boolean"]>; numberOfDepartures?: InputMaybe<Scalars["Int"]>; numberOfDeparturesPerLineAndDestinationDisplay?: InputMaybe<Scalars["Int"]>; startTime?: InputMaybe<Scalars["DateTime"]>; timeRange?: InputMaybe<Scalars["Int"]>; whiteListed?: InputMaybe<JourneyPlannerTypes.InputWhiteListed>; whiteListedModes?: InputMaybe<InputMaybe<JourneyPlannerTypes.TransportMode>[]> }

Named place where public transport may be accessed. May be a building complex (e.g. a station) or an on-street location.

Type declaration

StopPlaceQuaysArgs: { filterByInUse?: InputMaybe<Scalars["Boolean"]> }

Named place where public transport may be accessed. May be a building complex (e.g. a station) or an on-street location.

Type declaration

SystemNotice: { __typename?: "SystemNotice"; tag?: Maybe<Scalars["String"]>; text?: Maybe<Scalars["String"]> }

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: true'. 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.

Type declaration

TariffZone: { __typename?: "TariffZone"; id: Scalars["ID"]; name?: Maybe<Scalars["String"]> }

Type declaration

TimeAndDayOffset: { __typename?: "TimeAndDayOffset"; dayOffset?: Maybe<Scalars["Int"]>; time?: Maybe<Scalars["Time"]> }

Type declaration

  • Optional __typename?: "TimeAndDayOffset"
  • Optional dayOffset?: Maybe<Scalars["Int"]>

    Number of days offset from base line time

  • Optional time?: Maybe<Scalars["Time"]>

    Local time

TimetabledPassingTime: { __typename?: "TimetabledPassingTime"; arrival?: Maybe<TimeAndDayOffset>; bookingArrangements?: Maybe<JourneyPlannerTypes.BookingArrangement>; departure?: Maybe<TimeAndDayOffset>; destinationDisplay?: Maybe<JourneyPlannerTypes.DestinationDisplay>; forAlighting?: Maybe<Scalars["Boolean"]>; forBoarding?: Maybe<Scalars["Boolean"]>; notices: Maybe<JourneyPlannerTypes.Notice>[]; quay?: Maybe<JourneyPlannerTypes.Quay>; requestStop?: Maybe<Scalars["Boolean"]>; serviceJourney?: Maybe<JourneyPlannerTypes.ServiceJourney>; timingPoint?: Maybe<Scalars["Boolean"]> }

Scheduled passing times. These are not affected by real time updates.

Type declaration

TransportModeSlack: { modes: JourneyPlannerTypes.TransportMode[]; slack: Scalars["Int"] }

Used to specify board and alight slack for a given modes.

Type declaration

TransportModeSlackType: { __typename?: "TransportModeSlackType"; modes: JourneyPlannerTypes.TransportMode[]; slack: Scalars["Int"] }

Used to specify board and alight slack for a given modes.

Type declaration

TransportModes: { transportMode?: InputMaybe<JourneyPlannerTypes.TransportMode>; transportSubModes?: InputMaybe<InputMaybe<JourneyPlannerTypes.TransportSubmode>[]> }

Type declaration

  • Optional transportMode?: InputMaybe<JourneyPlannerTypes.TransportMode>

    A transportMode that should be allowed for this search. You can furthernarrow it down by specifying a list of transportSubModes

  • Optional transportSubModes?: InputMaybe<InputMaybe<JourneyPlannerTypes.TransportSubmode>[]>

    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.

TriangleFactors: { safety: Scalars["Float"]; slope: Scalars["Float"]; time: Scalars["Float"] }

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.

Type declaration

  • safety: Scalars["Float"]

    How important is bicycle safety expressed as a fraction of 1.

  • slope: Scalars["Float"]

    How important is slope/elevation expressed as a fraction of 1.

  • time: Scalars["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).

Trip: { __typename?: "Trip"; dateTime?: Maybe<Scalars["DateTime"]>; debugOutput: DebugOutput; fromPlace: JourneyPlannerTypes.Place; messageEnums: Maybe<Scalars["String"]>[]; messageStrings: Maybe<Scalars["String"]>[]; metadata?: Maybe<TripSearchData>; nextPageCursor?: Maybe<Scalars["String"]>; previousPageCursor?: Maybe<Scalars["String"]>; routingErrors: RoutingError[]; toPlace: JourneyPlannerTypes.Place; tripPatterns: JourneyPlannerTypes.TripPattern[] }

Description of a travel between two places.

Type declaration

  • Optional __typename?: "Trip"
  • Optional dateTime?: Maybe<Scalars["DateTime"]>

    The time and date of travel

  • debugOutput: DebugOutput

    Information about the timings for the trip generation

  • fromPlace: JourneyPlannerTypes.Place

    The origin

  • messageEnums: Maybe<Scalars["String"]>[]

    A list of possible error messages as enum

    deprecated

    Use routingErrors instead

  • messageStrings: Maybe<Scalars["String"]>[]

    A list of possible error messages in cleartext

    deprecated

    Use routingErrors instead

  • Optional metadata?: Maybe<TripSearchData>

    The trip request metadata.

    deprecated

    Use pageCursor instead

  • Optional nextPageCursor?: Maybe<Scalars["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.

  • Optional previousPageCursor?: Maybe<Scalars["String"]>

    Use the cursor to get the previous page of results. Use this cursor for the pageCursor parameter in the trip query in order to get the previous page. The previous page is a set of itineraries departing BEFORE the first itinerary in this result.

  • routingErrors: RoutingError[]

    A list of routing errors, and fields which caused them

  • toPlace: JourneyPlannerTypes.Place

    The destination

  • tripPatterns: JourneyPlannerTypes.TripPattern[]

    A list of possible trip patterns

TripPattern: { __typename?: "TripPattern"; aimedEndTime?: Maybe<Scalars["DateTime"]>; aimedStartTime?: Maybe<Scalars["DateTime"]>; directDuration?: Maybe<Scalars["Long"]>; distance?: Maybe<Scalars["Float"]>; duration?: Maybe<Scalars["Long"]>; endTime?: Maybe<Scalars["DateTime"]>; expectedEndTime?: Maybe<Scalars["DateTime"]>; expectedStartTime?: Maybe<Scalars["DateTime"]>; generalizedCost?: Maybe<Scalars["Int"]>; legs: Maybe<JourneyPlannerTypes.Leg>[]; startTime?: Maybe<Scalars["DateTime"]>; systemNotices: Maybe<SystemNotice>[]; transferPriorityCost?: Maybe<Scalars["Int"]>; waitTimeOptimizedCost?: Maybe<Scalars["Int"]>; waitingTime?: Maybe<Scalars["Long"]>; walkDistance?: Maybe<Scalars["Float"]>; walkTime?: Maybe<Scalars["Long"]> }

List of legs constituting a suggested sequence of rides and links for a specific trip.

Type declaration

  • Optional __typename?: "TripPattern"
  • Optional aimedEndTime?: Maybe<Scalars["DateTime"]>

    The aimed date and time the trip ends.

  • Optional aimedStartTime?: Maybe<Scalars["DateTime"]>

    The aimed date and time the trip starts.

  • Optional directDuration?: Maybe<Scalars["Long"]>

    NOT IMPLEMENTED.

  • Optional distance?: Maybe<Scalars["Float"]>

    Total distance for the trip, in meters. NOT IMPLEMENTED

  • Optional duration?: Maybe<Scalars["Long"]>

    Duration of the trip, in seconds.

  • Optional endTime?: Maybe<Scalars["DateTime"]>

    Time that the trip arrives.

    deprecated

    Replaced with expectedEndTime

  • Optional expectedEndTime?: Maybe<Scalars["DateTime"]>

    The expected, realtime adjusted date and time the trip ends.

  • Optional expectedStartTime?: Maybe<Scalars["DateTime"]>

    The expected, realtime adjusted date and time the trip starts.

  • Optional generalizedCost?: Maybe<Scalars["Int"]>

    Generalized cost or weight of the itinerary. Used for debugging.

  • legs: Maybe<JourneyPlannerTypes.Leg>[]

    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.

  • Optional startTime?: Maybe<Scalars["DateTime"]>

    Time that the trip departs.

    deprecated

    Replaced with expectedStartTime

  • systemNotices: Maybe<SystemNotice>[]

    Get all system notices.

  • Optional transferPriorityCost?: Maybe<Scalars["Int"]>

    A cost calculated to favor transfer with higher priority. This field is meant for debugging only.

  • Optional waitTimeOptimizedCost?: Maybe<Scalars["Int"]>

    A cost calculated to distribute wait-time and avoid very short transfers. This field is meant for debugging only.

  • Optional waitingTime?: Maybe<Scalars["Long"]>

    How much time is spent waiting for transit to arrive, in seconds.

  • Optional walkDistance?: Maybe<Scalars["Float"]>

    How far the user has to walk, in meters.

  • Optional walkTime?: Maybe<Scalars["Long"]>

    How much time is spent walking, in seconds.

TripSearchData: { __typename?: "TripSearchData"; nextDateTime?: Maybe<Scalars["DateTime"]>; prevDateTime?: Maybe<Scalars["DateTime"]>; searchWindowUsed: Scalars["Int"] }

Trips search metadata.

Type declaration

  • Optional __typename?: "TripSearchData"
  • Optional nextDateTime?: Maybe<Scalars["DateTime"]>

    This is the suggested search time for the "next page" or time window. Insert it together with the 'searchWindowUsed' in the request to get a new set of trips following in the time-window AFTER the current search.

    deprecated

    Use pageCursor instead

  • Optional prevDateTime?: Maybe<Scalars["DateTime"]>

    This is the suggested search time for the "previous page" or time-window. Insert it together with the 'searchWindowUsed' in the request to get a new set of trips preceding in the time-window BEFORE the current search.

    deprecated

    Use pageCursor instead

  • searchWindowUsed: Scalars["Int"]

    The search-window used in the current trip request. Use the value in the next request and set the request 'dateTime' to 'nextDateTime' or 'prevDateTime' to get the previous/next "window" of results. No duplicate trips should be returned, unless a trip is delayed and new realtime-data is available.Unit: minutes.

    deprecated

    Use pageCursor instead

ValidityPeriod: { __typename?: "ValidityPeriod"; endTime?: Maybe<Scalars["DateTime"]>; startTime?: Maybe<Scalars["DateTime"]> }

Type declaration

  • Optional __typename?: "ValidityPeriod"
  • Optional endTime?: Maybe<Scalars["DateTime"]>

    End of validity period. Will return 'null' if validity is open-ended.

  • Optional startTime?: Maybe<Scalars["DateTime"]>

    Start of validity period

Generated using TypeDoc