/// <summary>Gets the TravelTime overlay.</summary>
/// <param name="z">The zoom level.</param>
/// <param name="pinLat">The latitude of the pin.</param>
/// <param name="pinLon">The longitude of the pin.</param>
/// <param name="mapCenterLat">The map center latitude.</param>
/// <param name="mapCenterLon">The map center longitude.</param>
/// <param name="scenarioTitle">The title of the scenario.</param>
/// <param name="timeOfDayId">The id for the time of day (AM/INTER/PM)</param>
/// <param name="modeId">The id of the mode.</param>
/// <param name="width">The width of the requested overlay.</param>
/// <param name="height">The height of the requested overlay.</param>
/// <param name="direction">The direction of travel.</param>
/// <param name="travelTimeInterval">The total minutes between the travel time bands</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiTravelTimeException">A server side error occurred.</exception>
public async Task <object> GetOverlayAsync(int z, double pinLat, double pinLon, double mapCenterLat, double mapCenterLon, string scenarioTitle, string timeOfDayId, string modeId, int width, int height, OverlayDirection direction, int travelTimeInterval, CancellationToken cancellationToken)
{
if (scenarioTitle == null)
{
throw new ArgumentNullException("scenarioTitle");
}
if (timeOfDayId == null)
{
throw new ArgumentNullException("timeOfDayId");
}
if (modeId == null)
{
throw new ArgumentNullException("modeId");
}
return(await GetAsync <object>(cancellationToken,
"/TravelTimes/overlay/{z}/mapcenter/{mapCenterLat}/{mapCenterLon}/pinlocation/{pinLat}/{pinLon}/dimensions/{width}/{height}",
("z", z),
("mapCenterLat", mapCenterLat),
("mapCenterLon", mapCenterLon),
("pinLat", pinLat),
("pinLon", pinLon),
("width", width),
("height", height),
("scenarioTitle", scenarioTitle),
("timeOfDayId", timeOfDayId),
("modeId", modeId),
("direction", direction),
("travelTimeInterval", travelTimeInterval)
));
}
/// <summary>Gets the place overlay for a given set of co-ordinates and a given width/height.</summary>
/// <param name="z">The zoom level</param>
/// <param name="type">The place type (a valid list of place types can be obtained from the /Place/Meta/placeTypes endpoint)</param>
/// <param name="width">The width of the requested overlay.</param>
/// <param name="height">The height of the requested overlay.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiPlaceException">A server side error occurred.</exception>
public async Task <object> GetOverlayAsync(int z, IEnumerable <string> type, int width, int height, string lat, string lon, double locationlat, double locationlon, CancellationToken cancellationToken)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (lat == null)
{
throw new ArgumentNullException("lat");
}
if (lon == null)
{
throw new ArgumentNullException("lon");
}
return(await GetAsync <object>(cancellationToken,
"/Place/{type}/overlay/{z}/{Lat}/{Lon}/{width}/{height}",
("type", type),
("z", z),
("lat", lat),
("lon", lon),
("width", width),
("height", height)
));
}
public async Task <IEnumerable <RundownFunction> > GetByHandlerAsync(EHandlerType handler)
{
HttpResponseMessage response = await GetAsync(GetByHandlerAddress, (nameof(handler), handler.ToString()))
.ConfigureAwait(false);
return(await response.DeserializeOrDefaultAsync <IEnumerable <RundownFunction> >().ConfigureAwait(false));
}
/// <summary>Gets a StopPoint for a given sms code.</summary>
/// <param name="id">A 5-digit Countdown Bus Stop Code e.g. 73241, 50435, 56334.</param>
/// <param name="output">If set to "web", a 302 redirect to relevant website bus stop page is returned. Valid values are : web. All other values are ignored.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <object> GetBySmsAsync(string id, string output, CancellationToken cancellationToken)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
return(await GetAsync <object>(cancellationToken, "/StopPoint/Sms/{id}", ("id", id), ("output", output)));
}
/// <summary>Gets a list of StopPoints filtered by the modes available at that StopPoint.</summary>
/// <param name="modes">A comma-seperated list of modes e.g. tube,dlr</param>
/// <param name="page">The data set page to return. Page 1 equates to the first 1000 stop points, page 2 equates to 1001-2000 etc. Must be entered for bus mode as data set is too large.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <StopPointsResponse> GetByModeAsync(IEnumerable <string> modes, int?page, CancellationToken cancellationToken)
{
if (modes == null)
{
throw new ArgumentNullException("modes");
}
return(await GetAsync <StopPointsResponse>(cancellationToken, "/StopPoint/Mode/{modes}", ("modes", modes), ("page", page)));
}
/// <summary>Gets the line status of for given line ids e.g Minor Delays</summary>
/// <param name="ids">A comma-separated list of line ids e.g. victoria,circle,N133. Max. approx. 20 ids.</param>
/// <param name="detail">Include details of the disruptions that are causing the line status including the affected stops and routes</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiLineException">A server side error occurred.</exception>
public async Task <ObservableCollection <Line> > StatusByIdsAsync(IEnumerable <string> ids, bool?detail, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <Line> >(cancellationToken, "/Line/{ids}/Status", ("ids", ids)));
}
/// <summary>Gets the bike point with the given id.</summary>
/// <param name="id">A bike point id (a list of ids can be obtained from the above BikePoint call)</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiBikePointException">A server side error occurred.</exception>
public async Task <Place> GetAsync(string id, CancellationToken cancellationToken)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
return(await GetAsync <Place>(cancellationToken, "/BikePoint/{id}", ("id", id)));
}
/// <summary>Gets the specified roads with the status aggregated over the date range specified, or now until the end of today if no dates are passed.</summary>
/// <param name="ids">Comma-separated list of road identifiers e.g. "A406, A2" or use "all" to ignore id filter (a full list of supported road identifiers can be found at the /Road/ endpoint)</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiRoadException">A server side error occurred.</exception>
public async Task <ObservableCollection <RoadCorridor> > StatusAsync(IEnumerable <string> ids, DateTime?startDate, DateTime?dateRangeNullableendDate, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <RoadCorridor> >(cancellationToken, "/Road/{ids}/Status", ("ids", ids), ("dateRangeNullableStartDate", startDate), ("dateRangeNullableEndDate", dateRangeNullableendDate)));;
}
/// <summary>Gets the line status of for all lines for the given modes</summary>
/// <param name="modes">A comma-separated list of modes to filter by. e.g. tube,dlr</param>
/// <param name="detail">Include details of the disruptions that are causing the line status including the affected stops and routes</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiLineException">A server side error occurred.</exception>
public async Task <ObservableCollection <Line> > StatusByModeAsync(IEnumerable <string> modes, bool?detail, CancellationToken cancellationToken)
{
if (modes == null)
{
throw new ArgumentNullException("modes");
}
return(await GetAsync <ObservableCollection <Line> >(cancellationToken, "/Line/Mode/{modes}/Status", ("modes", modes)));
}
/// <summary>Gets the occupancy for a car park with a given id</summary>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiOccupancyException">A server side error occurred.</exception>
public async Task <CarParkOccupancy> GetAsync(string id, CancellationToken cancellationToken)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
return(await GetAsync <CarParkOccupancy>(cancellationToken, "/Occupancy/CarPark/{id}", ("id", id)));
}
/// <summary>Gets all stop points of a given type</summary>
/// <param name="types">A comma-separated list of the types to return. Max. approx. 12 types.
/// A list of valid stop types can be obtained from the StopPoint/meta/stoptypes endpoint.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <StopPoint> > GetByTypeAsync(IEnumerable <string> types, CancellationToken cancellationToken)
{
if (types == null)
{
throw new ArgumentNullException("types");
}
return(await GetAsync <ObservableCollection <StopPoint> >(cancellationToken, "/StopPoint/Type/{types}", ("types", types)));
}
/// <summary>Gets the Emissions Surcharge compliance for the Vehicle</summary>
/// <param name="vrm">The Vehicle Registration Mark</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiVehicleException">A server side error occurred.</exception>
public async Task <EmissionsSurchargeVehicle> GetVehicleAsync(string vrm, CancellationToken cancellationToken)
{
if (vrm == null)
{
throw new ArgumentNullException("vrm");
}
return(await GetAsync <EmissionsSurchargeVehicle>(cancellationToken, "/Vehicle/EmissionSurcharge", ("vrm", vrm)));
}
/// <summary>Searches the bus schedules folder on S3 for a given bus number.</summary>
/// <param name="query">The search query</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiSearchException">A server side error occurred.</exception>
public async Task <SearchResponse> BusSchedulesAsync(string query, CancellationToken cancellationToken)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
return(await GetAsync <SearchResponse>(cancellationToken, "/Search/BusSchedules", ("query", query)));
}
/// <summary>Gets the predictions for a given list of vehicle Id's.</summary>
/// <param name="ids">A comma-separated list of vehicle ids e.g. LX58CFV,LX11AZB,LX58CFE. Max approx. 25 ids.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiVehicleException">A server side error occurred.</exception>
public async Task <ObservableCollection <Prediction> > GetAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <Prediction> >(cancellationToken, "/Vehicle/{ids}/Arrivals", ("ids", ids)));
}
/// <summary>Get disruptions for all lines of the given modes.</summary>
/// <param name="modes">A comma-separated list of modes e.g. tube,dlr</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiLineException">A server side error occurred.</exception>
public async Task <ObservableCollection <Disruption> > DisruptionByModeAsync(IEnumerable <string> modes, CancellationToken cancellationToken)
{
if (modes == null)
{
throw new ArgumentNullException("modes");
}
return(await GetAsync <ObservableCollection <Disruption> >(cancellationToken, "/Line/Mode/{modes}/Disruption", ("modes", modes)));
}
/// <summary>Get disruptions for the given line ids</summary>
/// <param name="ids">A comma-separated list of line ids e.g. victoria,circle,N133. Max. approx. 20 ids.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiLineException">A server side error occurred.</exception>
public async Task <ObservableCollection <Disruption> > DisruptionAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <Disruption> >(cancellationToken, "/Line/{ids}/Disruption", ("ids", ids)));
}
/// <summary>Gets a list of taxi ranks corresponding to the given stop point id.</summary>
/// <param name="stopPointId">stopPointId is required to get the taxi ranks.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <Place> > GetTaxiRanksByIdsAsync(string stopPointId, CancellationToken cancellationToken)
{
if (stopPointId == null)
{
throw new ArgumentNullException("stopPointId");
}
return(await GetAsync <ObservableCollection <Place> >(cancellationToken, "/StopPoint/{stopPointId}/TaxiRanks", ("stopPointId", stopPointId)));
}
/// <summary>Gets the next arrival predictions for all stops of a given mode</summary>
/// <param name="mode">A mode name e.g. tube, dlr</param>
/// <param name="count">A number of arrivals to return for each stop, -1 to return all available.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiModeException">A server side error occurred.</exception>
public async Task <ObservableCollection <Prediction> > ArrivalsAsync(string mode, int?count, CancellationToken cancellationToken)
{
if (mode == null)
{
throw new ArgumentNullException("mode");
}
return(await GetAsync <ObservableCollection <Prediction> >(cancellationToken, "/Mode/{mode}/Arrivals", ("mode", mode)));
}
/// <summary>Gets a list of StopPoints corresponding to the given list of stop ids.</summary>
/// <param name="ids">A comma-separated list of stop point ids (station naptan code e.g. 940GZZLUASL). Max. approx. 20 ids.
/// You can use /StopPoint/Search/{query} endpoint to find a stop point id from a station name.</param>
/// <param name="includeCrowdingData">Include the crowding data (static). To Filter further use: /StopPoint/{ids}/Crowding/{line}</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <StopPoint> > GetAsync(IEnumerable <string> ids, bool?includeCrowdingData, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <StopPoint> >(cancellationToken, "/StopPoint/{ids}", ("ids", ids)));
}
/// <summary>Gets a list of active disruptions filtered by disruption Ids.</summary>
/// <param name="disruptionIds">Comma-separated list of disruption identifiers to filter by.</param>
/// <param name="stripContent">Optional, defaults to false. When true, removes every property/node except for id, point, severity, severityDescription, startDate, endDate, corridor details, location and comments.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiRoadException">A server side error occurred.</exception>
public async Task <RoadDisruption> DisruptionByIdAsync(IEnumerable <string> disruptionIds, bool?stripContent, CancellationToken cancellationToken)
{
if (disruptionIds == null)
{
throw new ArgumentNullException("disruptionIds");
}
return(await GetAsync <RoadDisruption>(cancellationToken, "/Road/all/Disruption/{disruptionIds}", ("disruptionIds", disruptionIds), ("stripContent", stripContent)));
}
/// <summary>Gets the service types for a given stoppoint</summary>
/// <param name="id">The Naptan id of the stop</param>
/// <param name="lineIds">The lines which contain the given Naptan id (all lines relevant to the given stoppoint if empty)</param>
/// <param name="modes">The modes which the lines are relevant to (all if empty)</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <LineServiceType> > GetServiceTypesAsync(string id, IEnumerable <string> lineIds, IEnumerable <string> modes, CancellationToken cancellationToken)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
return(await GetAsync <ObservableCollection <LineServiceType> >(cancellationToken, "/StopPoint/ServiceTypes", ("id", id), ("lineIds", lineIds), ("modes", modes)));
}
/// <summary>Search for lines or routes matching the query string</summary>
/// <param name="query">Search term e.g victoria</param>
/// <param name="modes">Optionally filter by the specified modes</param>
/// <param name="serviceTypes">A comma seperated list of service types to filter on. If not specified. Supported values: Regular, Night. Defaulted to 'Regular' if not specified</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiLineException">A server side error occurred.</exception>
public async Task <RouteSearchResponse> SearchAsync(string query, IEnumerable <string> modes, IEnumerable <ServiceType> serviceTypes, CancellationToken cancellationToken)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
return(await GetAsync <RouteSearchResponse>(cancellationToken, "/Line/Search/{query}", ("query", query)));
}
/// <summary>Get active disruptions, filtered by road ids</summary>
/// <param name="ids">Comma-separated list of road identifiers e.g. "A406, A2" use all for all to ignore id filter (a full list of supported road identifiers can be found at the /Road/ endpoint)</param>
/// <param name="stripContent">Optional, defaults to false. When true, removes every property/node except for id, point, severity, severityDescription, startDate, endDate, corridor details, location, comments and streets</param>
/// <param name="severities">an optional list of Severity names to filter on (a valid list of severities can be obtained from the /Road/Meta/severities endpoint)</param>
/// <param name="categories">an optional list of category names to filter on (a valid list of categories can be obtained from the /Road/Meta/categories endpoint)</param>
/// <param name="closures">Optional, defaults to true. When true, always includes disruptions that have road closures, regardless of the severity filter. When false, the severity filter works as normal.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiRoadException">A server side error occurred.</exception>
public async Task <ObservableCollection <RoadDisruption> > DisruptionAsync(IEnumerable <string> ids, bool?stripContent, IEnumerable <string> severities, IEnumerable <string> categories, bool?closures, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <RoadDisruption> >(cancellationToken, "/Road/{ids}/Disruption", ("ids", ids), ("stripContent", stripContent), ("severities", severities), ("categories", categories), ("closures", closures)));
}
/// <summary>Gets the list of arrival predictions for the given stop point id</summary>
/// <param name="id">A StopPoint id (station naptan code e.g. 940GZZLUASL, you can use /StopPoint/Search/{query} endpoint to find a stop point id from a station name)</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <Prediction> > ArrivalsAsync(string id, CancellationToken cancellationToken)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
return(await GetAsync <ObservableCollection <Prediction> >(cancellationToken, "/StopPoint/{id}/Arrivals", ("id", id)));
}
/// <summary>Gets the road with the specified id (e.g. A1)</summary>
/// <param name="ids">Comma-separated list of road identifiers e.g. "A406, A2" (a full list of supported road identifiers can be found at the /Road/ endpoint)</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiRoadException">A server side error occurred.</exception>
public async Task <ObservableCollection <RoadCorridor> > GetAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <RoadCorridor> >(cancellationToken, "/Road", ("ids", ids)));
}
/// <summary>Returns the route sections for all the lines that service the given stop point ids</summary>
/// <param name="id">A stop point id (station naptan codes e.g. 940GZZLUASL, you can use /StopPoint/Search/{query} endpoint to find a stop point id from a station name)</param>
/// <param name="serviceTypes">A comma-separated list of service types to filter on. If not specified. Supported values: Regular, Night. Defaulted to 'Regular' if not specified</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <StopPointRouteSection> > RouteAsync(string id, IEnumerable <ServiceType> serviceTypes, CancellationToken cancellationToken)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
return(await GetAsync <ObservableCollection <StopPointRouteSection> >(cancellationToken, "/StopPoint/{id}/Route", ("id", id), ("serviceTypes", serviceTypes)));
}
/// <summary>
/// Gets various backpack.tf user information.
/// <para /> This method functions correctly but is undocumented and may be removed from the API without warning.
/// </summary>
/// <param name="steamIds">A collection of SteamID64 identifiers.</param>
public async Task <BackpackUsers> GetUsersAsync(params ulong[] steamIds)
{
if (steamIds.Length == 0)
{
throw new ArgumentException("Steam ID collection must not be empty", nameof(steamIds));
}
return(await GetAsync <BackpackUsers>("users/info/v1", ("steamids", string.Join(",", steamIds.Distinct()))).ConfigureAwait(false));
}
/// <summary>Gets a distinct list of disrupted stop points for the given modes</summary>
/// <param name="modes">A comma-seperated list of modes e.g. tube,dlr</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <DisruptedPoint> > DisruptionByModeAsync(IEnumerable <string> modes, bool?includeRouteBlockedStops, CancellationToken cancellationToken)
{
if (modes == null)
{
throw new ArgumentNullException("modes");
}
return(await GetAsync <ObservableCollection <DisruptedPoint> >(cancellationToken, "/StopPoint/Mode/{modes}/Disruption", ("modes", modes), ("includeRouteBlockedStops", includeRouteBlockedStops)));
}
/// <summary>Search for bike stations by their name, a bike point's name often contains information about the name of the street
/// or nearby landmarks, for example. Note that the search result does not contain the PlaceProperties i.e. the status
/// or occupancy of the BikePoint, to get that information you should retrieve the BikePoint by its id on /BikePoint/id.</summary>
/// <param name="query">The search term e.g. "St. James"</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiBikePointException">A server side error occurred.</exception>
public async Task <ObservableCollection <Place> > SearchAsync(string query, CancellationToken cancellationToken)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
return(await GetAsync <ObservableCollection <Place> >(cancellationToken, "/BikePoint/Search", ("query", query)));
}
/// <summary>Gets all disruptions for the specified StopPointId, plus disruptions for any child Naptan records it may have.</summary>
/// <param name="ids">A comma-seperated list of stop point ids. Max. approx. 20 ids.
/// You can use /StopPoint/Search/{query} endpoint to find a stop point id from a station name.</param>
/// <param name="getFamily">Specify true to return disruptions for entire family, or false to return disruptions for just this stop point. Defaults to false.</param>
/// <param name="flattenResponse">Specify true to associate all disruptions with parent stop point. (Only applicable when getFamily is true).</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>OK</returns>
/// <exception cref="TflUnifiedApiStopPointException">A server side error occurred.</exception>
public async Task <ObservableCollection <DisruptedPoint> > DisruptionAsync(IEnumerable <string> ids, bool?getFamily, bool?includeRouteBlockedStops, bool?flattenResponse, CancellationToken cancellationToken)
{
if (ids == null)
{
throw new ArgumentNullException("ids");
}
return(await GetAsync <ObservableCollection <DisruptedPoint> >(cancellationToken, "/StopPoint/{ids}/Disruption", ("ids", ids), ("getFamily", getFamily), ("includeRouteBlockedStops", includeRouteBlockedStops), ("flattenResponse", flattenResponse)));
}
