@everyonesoftware/common 12.0.0 → 14.0.0

package/outputs/sources/wonderlandTrailClient.js

@@ -0,0 +1,1094 @@
+import { HttpClient } from "./httpClient.js";
+import { Iterable } from "./iterable.js";
+import { PreCondition } from "./preCondition.js";
+import { RecreationDotGovClient } from "./recreationDotGovClient.js";
+import { Map } from "./map.js";
+import { List } from "./list.js";
+import { hasProperty, isNumber, isObject, isUndefinedOrNull } from "./types.js";
+import { MutableMap } from "./mutableMap.js";
+import { NotFoundError } from "./notFoundError.js";
+import { Stack } from "./stack.js";
+import { PromiseAsyncResult } from "./promiseAsyncResult.js";
+export function isWonderlandTrailLocation(value) {
+    return isObject(value) &&
+        hasProperty(value, "name") &&
+        hasProperty(value, "trailhead") &&
+        hasProperty(value, "foodCacheStorage") &&
+        hasProperty(value, "divisionId") &&
+        hasProperty(value, "groupSiteDivisionId");
+}
+export class WonderlandTrailLocations {
+    static graniteCreek = {
+        name: "Granite Creek",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170009",
+        groupSiteDivisionId: "46753170010",
+        latitude: 46.92058,
+        longitude: -121.70800,
+        elevationFeet: 5851,
+    };
+    static sunriseCamp = {
+        name: "Sunrise Camp",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170058",
+        groupSiteDivisionId: "46753170059",
+        latitude: 46.91129,
+        longitude: -121.66002,
+        elevationFeet: 6258,
+    };
+    static sunriseVisitorCenter = {
+        name: "Sunrise Visitor Center",
+        trailhead: true,
+        foodCacheStorage: true,
+        divisionId: "",
+        groupSiteDivisionId: "",
+        latitude: 46.91448,
+        longitude: -121.64337,
+        elevationFeet: 6410,
+    };
+    static whiteRiver = {
+        name: "White River",
+        trailhead: true,
+        foodCacheStorage: true,
+        divisionId: "46753170066",
+        groupSiteDivisionId: "46753170067",
+        latitude: 46.90255,
+        longitude: -121.63869,
+        elevationFeet: 4229,
+    };
+    static fryingPanCreek = {
+        name: "Fryingpan Creek",
+        trailhead: true,
+        foodCacheStorage: false,
+        divisionId: "",
+        groupSiteDivisionId: "",
+        latitude: 46.88809,
+        longitude: -121.61019,
+        elevationFeet: 3835,
+    };
+    static summerland = {
+        name: "Summerland",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170056",
+        groupSiteDivisionId: "46753170057",
+        latitude: 46.86616,
+        longitude: -121.65843,
+        elevationFeet: 5988,
+    };
+    static indianBar = {
+        name: "Indian Bar",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170046",
+        groupSiteDivisionId: "46753170047",
+        latitude: 46.82593,
+        longitude: -121.63942,
+        elevationFeet: 5101,
+    };
+    static nickelCreek = {
+        name: "Nickel Creek",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170051",
+        groupSiteDivisionId: "46753170052",
+        latitude: 46.77204,
+        longitude: -121.62402,
+        elevationFeet: 3383,
+    };
+    static boxCanyon = {
+        name: "Box Canyon",
+        trailhead: true,
+        foodCacheStorage: false,
+        divisionId: "",
+        groupSiteDivisionId: "",
+        latitude: 46.76570,
+        longitude: -121.63517,
+        elevationFeet: 3025,
+    };
+    static mapleCreek = {
+        name: "Maple Creek",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170027",
+        groupSiteDivisionId: "46753170028",
+        latitude: 46.75745,
+        longitude: -121.65764,
+        elevationFeet: 2806,
+    };
+    static reflectionLakes = {
+        name: "Reflection Lakes",
+        trailhead: true,
+        foodCacheStorage: false,
+        divisionId: "",
+        groupSiteDivisionId: "",
+        latitude: 46.76824,
+        longitude: -121.72890,
+        elevationFeet: 4862,
+    };
+    static paradiseRiver = {
+        name: "Paradise River",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170031",
+        groupSiteDivisionId: "46753170032",
+        latitude: 46.77076,
+        longitude: -121.75909,
+        elevationFeet: 3960,
+    };
+    static longmire = {
+        name: "Longmire",
+        trailhead: true,
+        foodCacheStorage: true,
+        divisionId: "",
+        groupSiteDivisionId: "",
+        latitude: 46.75011,
+        longitude: -121.81253,
+        elevationFeet: 2750,
+    };
+    static pyramidCreek = {
+        name: "Pyramid Creek",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170033",
+        groupSiteDivisionId: "",
+        latitude: 46.77832,
+        longitude: -121.80963,
+        elevationFeet: 3721,
+    };
+    static devilsDream = {
+        name: "Devil's Dream",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170040",
+        groupSiteDivisionId: "46753170041",
+        latitude: 46.78196,
+        longitude: -121.83297,
+        elevationFeet: 4929,
+    };
+    static southPuyallupRiver = {
+        name: "South Puyallup River",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170035",
+        groupSiteDivisionId: "46753170036",
+        latitude: 46.81331,
+        longitude: -121.86445,
+        elevationFeet: 4183,
+    };
+    static klapatchePark = {
+        name: "Klapatche Park",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170024",
+        groupSiteDivisionId: "",
+        latitude: 46.83571,
+        longitude: -121.87752,
+        elevationFeet: 5496,
+    };
+    static northPuyallupRiver = {
+        name: "North Puyallup River",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170029",
+        groupSiteDivisionId: "46753170030",
+        latitude: 46.84751,
+        longitude: -121.87005,
+        elevationFeet: 3733,
+    };
+    static goldenLakes = {
+        name: "Golden Lakes",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170022",
+        groupSiteDivisionId: "46753170023",
+        latitude: 46.88327,
+        longitude: -121.89919,
+        elevationFeet: 4927,
+    };
+    static southMowichRiver = {
+        name: "South Mowich River",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170019",
+        groupSiteDivisionId: "46753170020",
+        latitude: 46.91146,
+        longitude: -121.89314,
+        elevationFeet: 2686,
+    };
+    static mowichLake = {
+        name: "Mowich Lake",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170015",
+        groupSiteDivisionId: "46753170016",
+        latitude: 46.93204,
+        longitude: -121.86351,
+        elevationFeet: 4868,
+    };
+    static eaglesRoost = {
+        name: "Eagle's Roost",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170006",
+        groupSiteDivisionId: "",
+        latitude: 46.91529,
+        longitude: -121.84816,
+        elevationFeet: 4834,
+    };
+    static cataractValley = {
+        name: "Cataract Valley",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170003",
+        groupSiteDivisionId: "46753170004",
+        latitude: 46.94049,
+        longitude: -121.80486,
+        elevationFeet: 4488,
+    };
+    static ipsutCreek = {
+        name: "Ipsut Creek",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170011",
+        groupSiteDivisionId: "46753170012",
+        latitude: 46.97615,
+        longitude: -121.83022,
+        elevationFeet: 2359,
+    };
+    static carbonRiver = {
+        name: "Carbon River",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170001",
+        groupSiteDivisionId: "46753170002",
+        latitude: 46.95063,
+        longitude: -121.79991,
+        elevationFeet: 3255,
+    };
+    static dickCreek = {
+        name: "Dick Creek",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170005",
+        groupSiteDivisionId: "",
+        latitude: 46.94071,
+        longitude: -121.78431,
+        elevationFeet: 4114,
+    };
+    static mysticLake = {
+        name: "Mystic Lake",
+        trailhead: false,
+        foodCacheStorage: false,
+        divisionId: "46753170017",
+        groupSiteDivisionId: "46753170018",
+        latitude: 46.91570,
+        longitude: -121.75045,
+        elevationFeet: 5538,
+    };
+    static getLocations() {
+        return Iterable.create([
+            this.graniteCreek,
+            this.sunriseCamp,
+            this.sunriseVisitorCenter,
+            this.whiteRiver,
+            this.fryingPanCreek,
+            this.summerland,
+            this.indianBar,
+            this.nickelCreek,
+            this.boxCanyon,
+            this.mapleCreek,
+            this.reflectionLakes,
+            this.paradiseRiver,
+            this.longmire,
+            this.pyramidCreek,
+            this.devilsDream,
+            this.southPuyallupRiver,
+            this.klapatchePark,
+            this.northPuyallupRiver,
+            this.goldenLakes,
+            this.southMowichRiver,
+            this.mowichLake,
+            this.eaglesRoost,
+            this.cataractValley,
+            this.ipsutCreek,
+            this.carbonRiver,
+            this.dickCreek,
+            this.mysticLake,
+        ]);
+    }
+    static getTrailheads() {
+        return this.getLocations().where(location => location.trailhead);
+    }
+}
+export var WonderlandTrailReservationType;
+(function (WonderlandTrailReservationType) {
+    WonderlandTrailReservationType[WonderlandTrailReservationType["Reserved"] = 0] = "Reserved";
+    WonderlandTrailReservationType[WonderlandTrailReservationType["Walkup"] = 1] = "Walkup";
+})(WonderlandTrailReservationType || (WonderlandTrailReservationType = {}));
+export class WonderlandTrailAvailability {
+    availabilityMap;
+    constructor() {
+        this.availabilityMap = Map.create();
+    }
+    static create() {
+        return new WonderlandTrailAvailability();
+    }
+    any() {
+        return this.availabilityMap.any().await();
+    }
+    addAvailability(location, date, individualSite, groupSite) {
+        PreCondition.assertNotUndefinedAndNotNull(location, "location");
+        PreCondition.assertNotUndefinedAndNotNull(date, "date");
+        const locationAvailability = this.getAvailability(location);
+        const dateString = date.toDateString();
+        const locationDayAvailability = locationAvailability.getOrSet(dateString, () => { return {}; }).await();
+        locationAvailability.set(dateString, {
+            individualSite: individualSite ?? locationDayAvailability.individualSite,
+            groupSite: groupSite ?? locationDayAvailability.groupSite,
+        });
+    }
+    getAvailability(location) {
+        PreCondition.assertNotUndefinedAndNotNull(location, "location");
+        return this.availabilityMap.getOrSet(location, () => MutableMap.create()).await();
+    }
+    getDayAvailability(location, date) {
+        PreCondition.assertNotUndefinedAndNotNull(location, "location");
+        PreCondition.assertNotUndefinedAndNotNull(date, "date");
+        return this.getAvailability(location).get(date.toDateString())
+            .convertError(NotFoundError, () => new NotFoundError(`No availability was found for ${location.name} on ${date.toDateString()}.`));
+    }
+}
+export class WonderlandTrailDirection {
+    value;
+    constructor(value) {
+        PreCondition.assertNotEmpty(value, "value");
+        this.value = value;
+    }
+    static clockwise = new WonderlandTrailDirection("Clockwise");
+    static counterClockwise = new WonderlandTrailDirection("CounterClockwise");
+    toString() {
+        return this.value;
+    }
+    reverse() {
+        return this === WonderlandTrailDirection.clockwise ? WonderlandTrailDirection.counterClockwise : WonderlandTrailDirection.clockwise;
+    }
+}
+export class WonderlandTrailConnection {
+    startLocation;
+    endLocation;
+    distanceMiles;
+    ascentFeet;
+    descentFeet;
+    direction;
+    intermediateLocations;
+    constructor(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations) {
+        PreCondition.assertNotUndefinedAndNotNull(startLocation, "startLocation");
+        PreCondition.assertNotUndefinedAndNotNull(endLocation, "endLocation");
+        PreCondition.assertGreaterThanOrEqualTo(distanceMiles, 0, "distanceMiles");
+        PreCondition.assertGreaterThanOrEqualTo(ascentFeet, 0, "ascentFeet");
+        PreCondition.assertGreaterThanOrEqualTo(descentFeet, 0, "descentFeet");
+        PreCondition.assertNotUndefinedAndNotNull(intermediateLocations, "intermediateLocations");
+        this.startLocation = startLocation;
+        this.endLocation = endLocation;
+        this.distanceMiles = distanceMiles;
+        this.ascentFeet = ascentFeet;
+        this.descentFeet = descentFeet;
+        this.direction = direction;
+        this.intermediateLocations = intermediateLocations;
+    }
+    static create(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations) {
+        return new WonderlandTrailConnection(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations);
+    }
+    getLocations() {
+        const result = List.create();
+        WonderlandTrailConnection.ensureExists(result, this.startLocation);
+        WonderlandTrailConnection.ensureAllExist(result, this.intermediateLocations);
+        WonderlandTrailConnection.ensureExists(result, this.endLocation);
+        return result;
+    }
+    static ensureExists(list, location) {
+        if (!list.contains(location).await()) {
+            list.add(location);
+        }
+    }
+    static ensureAllExist(list, locations) {
+        for (const location of locations) {
+            WonderlandTrailConnection.ensureExists(list, location);
+        }
+    }
+    reverseDirection() {
+        return WonderlandTrailConnection.create(this.endLocation, this.startLocation, this.distanceMiles, this.descentFeet, this.ascentFeet, this.direction.reverse(), this.intermediateLocations);
+    }
+    join(connection) {
+        const intermediateLocations = List.create();
+        WonderlandTrailConnection.ensureAllExist(intermediateLocations, this.intermediateLocations);
+        WonderlandTrailConnection.ensureExists(intermediateLocations, this.endLocation);
+        WonderlandTrailConnection.ensureExists(intermediateLocations, connection.startLocation);
+        WonderlandTrailConnection.ensureAllExist(intermediateLocations, connection.intermediateLocations);
+        return WonderlandTrailConnection.create(this.startLocation, connection.endLocation, this.distanceMiles + connection.distanceMiles, this.ascentFeet + connection.ascentFeet, this.descentFeet + connection.descentFeet, this.direction, intermediateLocations);
+    }
+    containsLocation(location) {
+        return this.getLocations().contains(location).await();
+    }
+    isLoop() {
+        return this.startLocation === this.endLocation;
+    }
+}
+export class WonderlandTrailConnections {
+    connections;
+    addReverseConnectionDefault;
+    constructor(addReverseConnectionDefault) {
+        this.connections = Map.create();
+        this.addReverseConnectionDefault = addReverseConnectionDefault;
+    }
+    static create(addReverseConnectionDefault) {
+        return new WonderlandTrailConnections(!!addReverseConnectionDefault);
+    }
+    static createDefault() {
+        return WonderlandTrailConnections.create(true)
+            .addConnection({
+            startLocation: WonderlandTrailLocations.whiteRiver,
+            endLocation: WonderlandTrailLocations.fryingPanCreek,
+            distanceMiles: 2.7,
+            ascentFeet: 100,
+            descentFeet: 600,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.fryingPanCreek,
+            endLocation: WonderlandTrailLocations.summerland,
+            distanceMiles: 4.3,
+            ascentFeet: 2200,
+            descentFeet: 100,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.summerland,
+            endLocation: WonderlandTrailLocations.indianBar,
+            distanceMiles: 4.7,
+            ascentFeet: 1200,
+            descentFeet: 2100,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.indianBar,
+            endLocation: WonderlandTrailLocations.nickelCreek,
+            distanceMiles: 6.8,
+            ascentFeet: 1400,
+            descentFeet: 3200,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.nickelCreek,
+            endLocation: WonderlandTrailLocations.boxCanyon,
+            distanceMiles: 0.9,
+            ascentFeet: 100,
+            descentFeet: 400,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.boxCanyon,
+            endLocation: WonderlandTrailLocations.mapleCreek,
+            distanceMiles: 2.7,
+            ascentFeet: 500,
+            descentFeet: 700,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.mapleCreek,
+            endLocation: WonderlandTrailLocations.reflectionLakes,
+            distanceMiles: 4.7,
+            ascentFeet: 2300,
+            descentFeet: 200,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.reflectionLakes,
+            endLocation: WonderlandTrailLocations.paradiseRiver,
+            distanceMiles: 2.6,
+            ascentFeet: 200,
+            descentFeet: 1200,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.paradiseRiver,
+            endLocation: WonderlandTrailLocations.longmire,
+            distanceMiles: 3.6,
+            ascentFeet: 100,
+            descentFeet: 1200,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.longmire,
+            endLocation: WonderlandTrailLocations.pyramidCreek,
+            distanceMiles: 3.3,
+            ascentFeet: 1400,
+            descentFeet: 400,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.pyramidCreek,
+            endLocation: WonderlandTrailLocations.devilsDream,
+            distanceMiles: 2.5,
+            ascentFeet: 1400,
+            descentFeet: 100,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.devilsDream,
+            endLocation: WonderlandTrailLocations.southPuyallupRiver,
+            distanceMiles: 6.5,
+            ascentFeet: 1900,
+            descentFeet: 2700,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.southPuyallupRiver,
+            endLocation: WonderlandTrailLocations.klapatchePark,
+            distanceMiles: 4.1,
+            ascentFeet: 2100,
+            descentFeet: 800,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.klapatchePark,
+            endLocation: WonderlandTrailLocations.northPuyallupRiver,
+            distanceMiles: 2.6,
+            ascentFeet: 100,
+            descentFeet: 1900,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.northPuyallupRiver,
+            endLocation: WonderlandTrailLocations.goldenLakes,
+            distanceMiles: 5.1,
+            ascentFeet: 1900,
+            descentFeet: 600,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.goldenLakes,
+            endLocation: WonderlandTrailLocations.southMowichRiver,
+            distanceMiles: 5.8,
+            ascentFeet: 200,
+            descentFeet: 2400,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.southMowichRiver,
+            endLocation: WonderlandTrailLocations.mowichLake,
+            distanceMiles: 4.4,
+            ascentFeet: 2400,
+            descentFeet: 300,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.mowichLake,
+            endLocation: WonderlandTrailLocations.ipsutCreek,
+            distanceMiles: 5.6,
+            ascentFeet: 400,
+            descentFeet: 3000,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.ipsutCreek,
+            endLocation: WonderlandTrailLocations.carbonRiver,
+            distanceMiles: 4,
+            ascentFeet: 1300,
+            descentFeet: 400,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.mowichLake,
+            endLocation: WonderlandTrailLocations.eaglesRoost,
+            distanceMiles: 2,
+            ascentFeet: 500,
+            descentFeet: 600,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.eaglesRoost,
+            endLocation: WonderlandTrailLocations.cataractValley,
+            distanceMiles: 12.4,
+            ascentFeet: 3300,
+            descentFeet: 3700,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.cataractValley,
+            endLocation: WonderlandTrailLocations.carbonRiver,
+            distanceMiles: 1.6,
+            ascentFeet: 100,
+            descentFeet: 1300,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.carbonRiver,
+            endLocation: WonderlandTrailLocations.dickCreek,
+            distanceMiles: 1.3,
+            ascentFeet: 1000,
+            descentFeet: 100,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.dickCreek,
+            endLocation: WonderlandTrailLocations.mysticLake,
+            distanceMiles: 3.7,
+            ascentFeet: 2100,
+            descentFeet: 600,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.mysticLake,
+            endLocation: WonderlandTrailLocations.graniteCreek,
+            distanceMiles: 4.1,
+            ascentFeet: 1500,
+            descentFeet: 1200,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.graniteCreek,
+            endLocation: WonderlandTrailLocations.sunriseCamp,
+            distanceMiles: 4.6,
+            ascentFeet: 1400,
+            descentFeet: 1000,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.sunriseCamp,
+            endLocation: WonderlandTrailLocations.whiteRiver,
+            distanceMiles: 3.5,
+            ascentFeet: 100,
+            descentFeet: 2100,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.sunriseCamp,
+            endLocation: WonderlandTrailLocations.sunriseVisitorCenter,
+            distanceMiles: 1.4,
+            ascentFeet: 400,
+            descentFeet: 200,
+        })
+            .addConnection({
+            startLocation: WonderlandTrailLocations.sunriseVisitorCenter,
+            endLocation: WonderlandTrailLocations.whiteRiver,
+            distanceMiles: 3.1,
+            ascentFeet: 0,
+            descentFeet: 2200,
+        });
+    }
+    iterateConnections(startLocationOrProperties, endLocation, direction) {
+        let startLocation;
+        if (isWonderlandTrailLocation(startLocationOrProperties)) {
+            startLocation = startLocationOrProperties;
+        }
+        else if (startLocationOrProperties) {
+            startLocation = startLocationOrProperties.startLocation;
+            endLocation = startLocationOrProperties.endLocation;
+            direction = startLocationOrProperties.direction;
+        }
+        let result;
+        if (!startLocation) {
+            result = this.connections.iterateValues().flatMap(x => x);
+        }
+        else {
+            result = this.connections.get(startLocation)
+                .catch(NotFoundError, () => Iterable.create())
+                .await()
+                .iterate();
+        }
+        if (endLocation) {
+            result = result.where(connection => connection.endLocation == endLocation);
+        }
+        if (direction != null) {
+            result = result.where(connection => connection.direction == direction);
+        }
+        return result;
+    }
+    addConnectionInner(connection) {
+        const startLocationConnections = this.connections.getOrSet(connection.startLocation, () => List.create()).await();
+        startLocationConnections.add(connection);
+    }
+    addConnection(connectionStartLocationOrProperties, addReverseConnectionOrEndLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations, addReverseConnection) {
+        let startLocation;
+        let endLocation;
+        if (isWonderlandTrailLocation(connectionStartLocationOrProperties)) {
+            startLocation = connectionStartLocationOrProperties;
+        }
+        else if (connectionStartLocationOrProperties instanceof WonderlandTrailConnection) {
+            startLocation = connectionStartLocationOrProperties.startLocation;
+            endLocation = connectionStartLocationOrProperties.endLocation;
+            distanceMiles = connectionStartLocationOrProperties.distanceMiles;
+            ascentFeet = connectionStartLocationOrProperties.ascentFeet;
+            descentFeet = connectionStartLocationOrProperties.descentFeet;
+            direction = connectionStartLocationOrProperties.direction;
+            intermediateLocations = connectionStartLocationOrProperties.intermediateLocations;
+            addReverseConnection = !!addReverseConnectionOrEndLocation;
+        }
+        else {
+            startLocation = connectionStartLocationOrProperties.startLocation;
+            endLocation = connectionStartLocationOrProperties.endLocation;
+            distanceMiles = connectionStartLocationOrProperties.distanceMiles;
+            ascentFeet = connectionStartLocationOrProperties.ascentFeet;
+            descentFeet = connectionStartLocationOrProperties.descentFeet;
+            direction = connectionStartLocationOrProperties.direction;
+            intermediateLocations = connectionStartLocationOrProperties.intermediateLocations;
+            addReverseConnection = connectionStartLocationOrProperties.addReverseConnection;
+        }
+        const connection = WonderlandTrailConnection.create(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction ?? WonderlandTrailDirection.clockwise, intermediateLocations ?? Iterable.create());
+        this.addConnectionInner(connection);
+        if (addReverseConnection ?? this.addReverseConnectionDefault) {
+            this.addConnectionInner(connection.reverseDirection());
+        }
+        return this;
+    }
+    containsConnection(connection) {
+        PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
+        const startLocationConnections = this.connections.get(connection.startLocation).catch(() => undefined).await();
+        return startLocationConnections?.contains(connection)?.await() === true;
+    }
+    reverseDirection() {
+        const result = WonderlandTrailConnections.create(this.addReverseConnectionDefault);
+        for (const connection of this.iterateConnections()) {
+            result.addConnection(connection.reverseDirection());
+        }
+        return result;
+    }
+    expandConnections(startLocation, endLocation, direction) {
+        if (isUndefinedOrNull(direction)) {
+            direction = WonderlandTrailDirection.clockwise;
+        }
+        const result = WonderlandTrailConnections.create(this.addReverseConnectionDefault);
+        const toVisit = Stack.create();
+        toVisit.addAll(this.iterateConnections(startLocation, undefined, direction));
+        while (toVisit.any().await()) {
+            const currentConnection = toVisit.remove().await();
+            result.addConnection(currentConnection, false);
+            if (!currentConnection.isLoop() && currentConnection.endLocation !== endLocation) {
+                for (const endLocationConnection of this.iterateConnections(currentConnection.endLocation, undefined, direction)) {
+                    if (!result.containsConnection(endLocationConnection) &&
+                        !toVisit.contains(endLocationConnection)) {
+                        toVisit.add(endLocationConnection);
+                    }
+                    if (!currentConnection.intermediateLocations.contains(endLocationConnection.endLocation)) {
+                        toVisit.add(currentConnection.join(endLocationConnection));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+export class WonderlandTrailItinerary {
+    startDay;
+    connections;
+    availabilityTypes;
+    constructor(startDay) {
+        PreCondition.assertNotUndefinedAndNotNull(startDay, "startDay");
+        this.startDay = startDay;
+        this.connections = List.create();
+        this.availabilityTypes = List.create();
+    }
+    static create(startDay) {
+        return new WonderlandTrailItinerary(startDay);
+    }
+    clone() {
+        return WonderlandTrailItinerary.create(this.startDay)
+            .addConnections(this.connections)
+            .addAvailabilityTypes(this.availabilityTypes);
+    }
+    getConnections() {
+        return this.connections;
+    }
+    getEndDay() {
+        return this.startDay.addDays(this.getDayCount() - 1);
+    }
+    getDayCount() {
+        return this.connections.getCount().await();
+    }
+    getStartLocation() {
+        return this.connections.first().then(firstConnection => firstConnection.startLocation);
+    }
+    getIntermediateLocations() {
+        const result = List.create();
+        for (const connection of this.connections) {
+            if (result.any().await()) {
+                result.add(connection.startLocation);
+            }
+            result.addAll(connection.intermediateLocations);
+        }
+        return result;
+    }
+    getEndLocation() {
+        return this.connections.last().then(lastConnection => lastConnection.endLocation);
+    }
+    getPath() {
+        const result = List.create();
+        for (const connection of this.connections) {
+            if (!result.any().await()) {
+                result.add(connection.startLocation);
+            }
+            result.add(connection.endLocation);
+        }
+        return result;
+    }
+    getPathStrings(includeAvailabilityTypes) {
+        includeAvailabilityTypes = includeAvailabilityTypes ?? true;
+        const result = List.create();
+        let availabilityTypeIndex = 0;
+        const availabilityTypeCount = this.availabilityTypes.getCount().await();
+        for (const connection of this.connections) {
+            if (!result.any().await()) {
+                result.add(connection.startLocation.name);
+            }
+            let pathString = connection.endLocation.name;
+            if (includeAvailabilityTypes && availabilityTypeIndex < availabilityTypeCount) {
+                pathString += " ";
+                const availabilityType = this.availabilityTypes.get(availabilityTypeIndex).await();
+                availabilityTypeIndex++;
+                if (availabilityType.individualSite !== undefined) {
+                    if (availabilityType.groupSite !== undefined) {
+                        pathString += `(Individual ${availabilityType.individualSite}/Group ${availabilityType.groupSite})`;
+                    }
+                    else {
+                        pathString += `(Individual ${availabilityType.individualSite})`;
+                    }
+                }
+                else {
+                    pathString += `(Group ${availabilityType.groupSite})`;
+                }
+            }
+            result.add(pathString);
+        }
+        return result;
+    }
+    contains(parameters) {
+        PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
+        const location = parameters.location;
+        const checkItineraryStartLocation = parameters.checkItineraryStartLocation ?? true;
+        const checkItineraryIntermediateLocations = parameters.checkItineraryIntermediateLocations ?? true;
+        const checkItineraryEndLocation = parameters.checkItineraryEndLocation ?? true;
+        PreCondition.assertNotUndefinedAndNotNull(location, "location");
+        let result = false;
+        const connectionCount = this.connections.getCount().await();
+        for (let i = 0; i < connectionCount; i++) {
+            if (i !== 0 || checkItineraryStartLocation) {
+                result = (this.connections.get(i).await().startLocation === location);
+                if (result) {
+                    break;
+                }
+            }
+            if (checkItineraryIntermediateLocations) {
+                result = this.connections.get(i).await().intermediateLocations.contains(location).await();
+                if (result) {
+                    break;
+                }
+            }
+            if (i === connectionCount - 1 && checkItineraryEndLocation) {
+                result = (this.connections.get(i).await().endLocation === location);
+                if (result) {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    containsAny(parameters) {
+        PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
+        const connection = parameters.connection;
+        const checkConnectionStartLocation = parameters.checkConnectionStartLocation ?? true;
+        const checkConnectionIntermediateLocations = parameters.checkConnectionIntermediateLocations ?? true;
+        const checkConnectionEndLocation = parameters.checkConnectionEndLocation ?? true;
+        const checkItineraryStartLocation = parameters.checkItineraryStartLocation ?? true;
+        const checkItineraryIntermediateLocations = parameters.checkItineraryIntermediateLocations ?? true;
+        const checkItineraryEndLocation = parameters.checkItineraryEndLocation ?? true;
+        PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
+        let result = false;
+        if (!result && checkConnectionStartLocation) {
+            result = this.contains({
+                location: connection.startLocation,
+                checkItineraryStartLocation,
+                checkItineraryIntermediateLocations,
+                checkItineraryEndLocation,
+            });
+        }
+        if (!result && checkConnectionIntermediateLocations) {
+            for (const connectionIntermediateLocation of connection.intermediateLocations) {
+                result = this.contains({
+                    location: connectionIntermediateLocation,
+                    checkItineraryStartLocation,
+                    checkItineraryIntermediateLocations,
+                    checkItineraryEndLocation,
+                });
+                if (result) {
+                    break;
+                }
+            }
+        }
+        if (!result && checkConnectionEndLocation) {
+            result = this.contains({
+                location: connection.endLocation,
+                checkItineraryStartLocation,
+                checkItineraryIntermediateLocations,
+                checkItineraryEndLocation,
+            });
+        }
+        return result;
+    }
+    addConnection(connection) {
+        PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
+        this.connections.add(connection);
+        return this;
+    }
+    addConnections(connections) {
+        PreCondition.assertNotUndefinedAndNotNull(connections, "connections");
+        this.connections.addAll(connections);
+        return this;
+    }
+    addAvailabilityType(availabilityType) {
+        PreCondition.assertNotUndefinedAndNotNull(availabilityType, "availabilityType");
+        this.availabilityTypes.add(availabilityType);
+        return this;
+    }
+    addAvailabilityTypes(availabilityTypes) {
+        PreCondition.assertNotUndefinedAndNotNull(availabilityTypes, "availabilityTypes");
+        this.availabilityTypes.addAll(availabilityTypes);
+        return this;
+    }
+    toString(includeAvailabilityTypes) {
+        includeAvailabilityTypes = includeAvailabilityTypes ?? true;
+        return `startDay:${this.startDay.toDateString()},path:${this.getPathStrings(includeAvailabilityTypes)}`;
+    }
+}
+export class WonderlandTrailClient {
+    static permitItineraryId = "4675317";
+    httpClient;
+    recreationDotGovClient;
+    constructor(httpClient) {
+        PreCondition.assertNotUndefinedAndNotNull(httpClient, "httpClient");
+        this.httpClient = httpClient;
+        this.recreationDotGovClient = RecreationDotGovClient.create(httpClient);
+    }
+    static create(httpClient) {
+        return new WonderlandTrailClient(httpClient);
+    }
+    sendRequest(request) {
+        return this.httpClient.sendRequest(request);
+    }
+    sendGetRequest(url) {
+        return HttpClient.sendGetRequest(this, url);
+    }
+    getAvailability(monthOrOptions, year, allowWalkupPermits, allowIndividualSites, allowGroupSites, earlyAccessPermitLotteryId) {
+        let month;
+        if (isNumber(monthOrOptions)) {
+            month = monthOrOptions;
+            year = year;
+            allowWalkupPermits = allowWalkupPermits;
+            allowIndividualSites = allowIndividualSites;
+            allowGroupSites = allowGroupSites;
+        }
+        else {
+            month = monthOrOptions.month;
+            year = monthOrOptions.year;
+            allowWalkupPermits = monthOrOptions.allowWalkupPermits;
+            allowIndividualSites = monthOrOptions.allowIndividualSites;
+            allowGroupSites = monthOrOptions.allowGroupSites;
+            earlyAccessPermitLotteryId = monthOrOptions.earlyAccessPermitLotteryId;
+        }
+        return PromiseAsyncResult.create(async () => {
+            const result = WonderlandTrailAvailability.create();
+            for (const location of WonderlandTrailLocations.getLocations()) {
+                if (allowIndividualSites && location.divisionId) {
+                    const divisionAvailability = await this.recreationDotGovClient.getDivisionAvailability(WonderlandTrailClient.permitItineraryId, location.divisionId, month, year, earlyAccessPermitLotteryId);
+                    const divisionDayAvailabilities = divisionAvailability.dayAvailabilities;
+                    if (divisionDayAvailabilities) {
+                        for (const divisionDayAvailability of divisionDayAvailabilities) {
+                            const hasWalkupPermits = (allowWalkupPermits && divisionDayAvailability.walkup);
+                            const hasReservationPermits = (divisionDayAvailability.reservationsRemaining > 0);
+                            if (hasWalkupPermits || hasReservationPermits) {
+                                result.addAvailability(location, divisionDayAvailability.date, hasWalkupPermits ? WonderlandTrailReservationType.Walkup : WonderlandTrailReservationType.Reserved, undefined);
+                            }
+                        }
+                    }
+                }
+                if (allowGroupSites && location.groupSiteDivisionId) {
+                    const groupSiteDivisionAvailability = await this.recreationDotGovClient.getDivisionAvailability(WonderlandTrailClient.permitItineraryId, location.groupSiteDivisionId, month, year, earlyAccessPermitLotteryId);
+                    const groupSiteDivisionDayAvailabilities = groupSiteDivisionAvailability.dayAvailabilities;
+                    if (groupSiteDivisionDayAvailabilities) {
+                        for (const groupSiteDayAvailability of groupSiteDivisionDayAvailabilities) {
+                            const hasWalkupPermits = (allowWalkupPermits && groupSiteDayAvailability.walkup);
+                            const hasReservationPermits = (groupSiteDayAvailability.reservationsRemaining > 0);
+                            if (hasWalkupPermits || hasReservationPermits) {
+                                result.addAvailability(location, groupSiteDayAvailability.date, undefined, hasWalkupPermits ? WonderlandTrailReservationType.Walkup : WonderlandTrailReservationType.Reserved);
+                            }
+                        }
+                    }
+                }
+            }
+            return result;
+        });
+    }
+    findItineraries(parameters) {
+        PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
+        const availability = parameters.availability;
+        const startDate = parameters.startDate;
+        const startLocation = parameters.startLocation;
+        const endLocation = parameters.endLocation;
+        const direction = parameters.direction;
+        const maximumDayDistanceMiles = parameters.maximumDayDistanceMiles;
+        const maximumItineraryDays = parameters.maximumItineraryDays;
+        const campsitesToAvoid = Iterable.create(parameters.campsitesToAvoid ?? []);
+        const result = List.create();
+        const connections = WonderlandTrailConnections.createDefault()
+            .expandConnections(startLocation, endLocation, direction);
+        let startLocationConnections = connections.iterateConnections(startLocation, undefined, direction);
+        if (!isUndefinedOrNull(maximumDayDistanceMiles)) {
+            startLocationConnections = startLocationConnections.where(connection => connection.distanceMiles <= maximumDayDistanceMiles);
+        }
+        const possibleItineraries = Stack.create();
+        possibleItineraries.addAll(startLocationConnections.map(c => WonderlandTrailItinerary.create(startDate).addConnection(c)));
+        while (possibleItineraries.any().await()) {
+            const currentItinerary = possibleItineraries.remove().await();
+            const currentItineraryEndLocation = currentItinerary.getEndLocation().await();
+            if ((maximumItineraryDays === undefined || currentItinerary.getDayCount() <= maximumItineraryDays) &&
+                (startLocation === currentItineraryEndLocation || endLocation === currentItineraryEndLocation || !campsitesToAvoid.contains(currentItineraryEndLocation).await())) {
+                if (currentItineraryEndLocation === endLocation) {
+                    result.add(currentItinerary);
+                }
+                else {
+                    const dayAvailability = availability.getDayAvailability(currentItineraryEndLocation, currentItinerary.getEndDay())
+                        .catch(() => undefined)
+                        .await();
+                    if (dayAvailability) {
+                        currentItinerary.addAvailabilityType(dayAvailability);
+                        for (const nextDayConnection of connections.iterateConnections(currentItineraryEndLocation, undefined, direction)) {
+                            if (!currentItinerary.containsAny({
+                                connection: nextDayConnection,
+                                checkConnectionStartLocation: false,
+                                checkItineraryStartLocation: false,
+                                checkItineraryEndLocation: false,
+                            })) {
+                                if (maximumDayDistanceMiles === undefined || nextDayConnection.distanceMiles <= maximumDayDistanceMiles) {
+                                    possibleItineraries.add(currentItinerary.clone().addConnection(nextDayConnection));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    findItinerariesAsync(parameters) {
+        PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
+        const startDay = parameters.startDay;
+        const startLocation = parameters.startLocation;
+        const endLocation = parameters.endLocation;
+        const direction = parameters.direction;
+        const maximumDayDistanceMiles = parameters.maximumDayDistanceMiles;
+        const maximumItineraryDays = parameters.maximumItineraryDays;
+        const allowWalkupPermits = parameters.allowWalkupPermits ?? true;
+        const allowIndividualSites = parameters.allowIndividualSites ?? true;
+        const allowGroupSites = parameters.allowGroupSites ?? false;
+        const campsitesToAvoid = parameters.campsitesToAvoid ?? [];
+        PreCondition.assertNotUndefinedAndNotNull(startDay, "startDay");
+        return PromiseAsyncResult.create(async () => {
+            const result = List.create();
+            const startLocationsToCheck = (!isUndefinedOrNull(startLocation) ? Iterable.create([startLocation]) : WonderlandTrailLocations.getTrailheads());
+            const directionsToCheck = (!isUndefinedOrNull(direction) ? Iterable.create([direction]) : Iterable.create([WonderlandTrailDirection.clockwise, WonderlandTrailDirection.counterClockwise]));
+            const availability = await this.getAvailability(startDay.getMonth(), startDay.getYear(), allowWalkupPermits, allowIndividualSites, allowGroupSites);
+            for (const startLocationToCheck of startLocationsToCheck) {
+                for (const directionToCheck of directionsToCheck) {
+                    result.addAll(this.findItineraries({
+                        availability,
+                        startDate: startDay,
+                        startLocation: startLocationToCheck,
+                        endLocation: endLocation ?? startLocationToCheck,
+                        direction: directionToCheck,
+                        maximumDayDistanceMiles,
+                        maximumItineraryDays,
+                        campsitesToAvoid,
+                    }));
+                }
+            }
+            return result;
+        });
+    }
+}
+//# sourceMappingURL=wonderlandTrailClient.js.map