@volant-autonomy/via-sdk 1.3567.1 → 1.3595.1

package/dist/index.esm.js

@@ -0,0 +1,905 @@
+// eslint-disable-next-line promise/param-names
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class UnauthenticatedError extends Error {
+    constructor() {
+        super(...arguments);
+        // Both properties are needed to allow for errors to be identified when used in scenarios such
+        // as 'PromiseRejectionEvent' such as:
+        // `if (errorEvent.reason.name === UnauthenticatedError.name)`
+        // In the above, the first is the instance property and the latter a class property
+        this.name = 'Unauthenticated';
+        // FIXME: this was valid in the via codebase for some reason.
+        // public static override name = 'Unauthenticated'
+    }
+}
+
+class Composite {
+    constructor(direct) {
+        this.direct = direct;
+    }
+    /// flightplans
+    async upsertFlightplan(args, id) {
+        if (id) {
+            return this.direct.modifyDraftFlightplan(id, args);
+        }
+        else {
+            return this.direct.createDraftFlightplan(args);
+        }
+    }
+    async getAllDraftFlightplans() {
+        return this.direct.getAllFlightplans({ 'filter[state]': ['Draft'] });
+    }
+    async getAllClosedFlightplans() {
+        return this.direct.getAllFlightplans({ 'filter[state]': ['Closed'] });
+    }
+    async getAllPendingFlightplans() {
+        return this.direct.getAllFlightplans({ 'filter[state]': ['Pending'] });
+    }
+    async getAllAcceptedFlightplans() {
+        return this.direct.getAllFlightplans({ 'filter[state]': ['Accepted'] });
+    }
+    // TODO: make error 409 more obvious, as it is different
+    async attemptAcceptFlightplan(id) {
+        return this.direct.changeFlightplanState(id, 'Accepted');
+    }
+    async attemptTemporalDeconfliction(id, timeInterval = 60) {
+        const startTimeDeconflictArgs = {
+            time_interval: timeInterval
+        };
+        const { data, error } = await this.direct.getFlightplanDeconflictedStartTime(id, startTimeDeconflictArgs);
+        if (error) {
+            return { error };
+        }
+        return this.direct.modifyDraftFlightplan(id, data.attributes);
+    }
+    /// pathing tasks
+    /** Handles creating and polling a pathing task for you */
+    async doPathingTask(args) {
+        var _a, _b;
+        const { error, data } = await this.direct.createPathingTask(args);
+        if (error) {
+            return { error };
+        }
+        const id = data.id;
+        while (true) {
+            const { data, error } = await this.direct.getPathingTask(id);
+            if (error) {
+                return { error };
+            }
+            switch (data.meta.state) {
+                case 'queued':
+                    await sleep(500);
+                    continue;
+                case 'in-progress':
+                    await sleep(50);
+                    continue;
+                case 'successful':
+                    if ((_a = data.attributes) === null || _a === undefined ? undefined : _a.waypoints) {
+                        return { data: (_b = data.attributes) === null || _b === undefined ? undefined : _b.waypoints };
+                    }
+                    else {
+                        throw new Error(`endpoint did not return waypoints ${data}`); // TODO:
+                    }
+                case 'failed':
+                    // TODO: this is bad, do this better.
+                    return { error: data.meta.error_code };
+            }
+        }
+    }
+}
+
+class Direct {
+    constructor(fetcher) {
+        this.fetcher = fetcher;
+    }
+    /// flightplans
+    async getAllFlightplans(args, opts) {
+        const resp = await this.fetcher.GET('/flightplans/', { query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((flightplan) => flightplan.data) });
+        }
+        else {
+            return resp;
+        }
+    }
+    async createDraftFlightplan(args, opts) {
+        const resp = await this.fetcher.POST('/flightplans/', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async modifyDraftFlightplan(id, args, opts) {
+        const resp = await this.fetcher.PUT('/flightplans/{flightplan_id}', { body: args, path: { flightplan_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getFlightplan(id, opts) {
+        const resp = await this.fetcher.GET('/flightplans/{flightplan_id}', { path: { flightplan_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    // FIXME: this name is poor
+    async getFlightplanWaypointsDetailed(id, opts) {
+        const resp = await this.fetcher.GET('/flightplans/{flightplan_id}/waypoints_detail', { path: { flightplan_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getFlightplanStatistics(id, args, opts) {
+        const resp = await this.fetcher.GET('/flightplans/{flightplan_id}/statistics', { path: { flightplan_id: id }, query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getFlightplanVolumes(id, opts) {
+        const resp = await this.fetcher.GET('/flightplans/{flightplan_id}/volumes', { path: { flightplan_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    // TODO: make a wrapper for this which updates the existing flightplan to have this new start time
+    async getFlightplanDeconflictedStartTime(id, args, opts) {
+        const resp = await this.fetcher.GET('/flightplans/{flightplan_id}/start_time_deconflict', { path: { flightplan_id: id }, query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async changeFlightplanState(id, state, opts) {
+        const resp = await this.fetcher.POST('/flightplans/{flightplan_id}/state', { path: { flightplan_id: id }, body: { state } }, opts);
+        if (!resp.error && resp.aborted === false) {
+            return Object.assign(Object.assign({}, resp), { data: true });
+        }
+        return resp;
+    }
+    // TODO: use `args` instead of fileFormat
+    async getFlightplanAsFile(id, opts) {
+        const resp = await this.fetcher.GET('/flightplans/{flightplan_id}/content', { path: { flightplan_id: id }, header: { accept: 'application/vnd.google-earth.kml+xml' } }, Object.assign(Object.assign({}, opts), { parseAs: 'blob' }));
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: { file: resp.data, fileName: resp.response.headers.get('filename') } });
+        }
+        return resp;
+    }
+    /// airspace constraints
+    async createAirspaceConstraint(args, opts) {
+        const resp = await this.fetcher.POST('/airspace_constraints/', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getAllAirspaceConstraints(opts) {
+        const resp = await this.fetcher.GET('/airspace_constraints/', {}, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((constraint) => constraint.data) });
+        }
+        return resp;
+    }
+    async getAirspaceConstraint(id, opts) {
+        const resp = await this.fetcher.GET('/airspace_constraints/{airspace_constraint_id}', { path: { airspace_constraint_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async modifyAirspaceConstraint(id, args, opts) {
+        const resp = await this.fetcher.PUT('/airspace_constraints/{airspace_constraint_id}', { path: { airspace_constraint_id: id }, body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async changeAirspaceConstraintState(id, state, opts) {
+        const resp = await this.fetcher.POST('/airspace_constraints/{airspace_constraints_id}/state', { path: { airspace_constraints_id: id }, body: { state } }, opts);
+        if (!resp.error && resp.aborted === false) {
+            return Object.assign(Object.assign({}, resp), { data: true });
+        }
+        return resp;
+    }
+    /// pathing tasks
+    async createPathingTask(args, opts) {
+        const resp = await this.fetcher.POST('/pathing_tasks/', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getPathingTask(id, opts) {
+        const resp = await this.fetcher.GET('/pathing_tasks/{pathing_task_id}', { path: { pathing_task_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    /// charts
+    async getAllCharts(opts) {
+        const resp = await this.fetcher.GET('/charts/', {}, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((chart) => chart.data) });
+        }
+        return resp;
+    }
+    async getChart(id, opts) {
+        const resp = await this.fetcher.GET('/charts/{chart_id}', { path: { chart_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    /// risk assessment
+    async getSailV2_5(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/v2.5/sail', { query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async calculateResidualArcV2_5(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/v2.5/residual_arc', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getAllArcsV2_5(opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/v2.5/air_risk_classifications', {}, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((arc) => arc.data) });
+        }
+        return resp;
+    }
+    async getArcV2_5(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/v2.5/air_risk_classifications/{arc_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async generateSoraReportV2_5(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/v2.5/report', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async generateSoraSemanticModelVolumesV2_5(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/v2.5/semantic_model_volumes', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getAllArcsUk(opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/uk/air_risk_classifications', {}, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((arc) => arc.data) });
+        }
+        return resp;
+    }
+    async getArcUk(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/uk/air_risk_classifications/{arc_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getSailUk(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/uk/sail', { query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async calculateResidualArcUk(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/uk/residual_arc', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async generateSoraReportUk(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/uk/report', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async generateSoraSemanticModelVolumesUk(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/uk/semantic_model_volumes', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async createSoraClassification(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/classifications', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async updateSoraClassification(id, args, opts) {
+        const resp = await this.fetcher.PUT('/risk_assessment/sora/classifications/{classification_id}', { body: args, path: { classification_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getSoraClassification(id, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/classifications/{classification_id}', { path: { classification_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    /// controlled ground areas
+    async getAllControlledGroundAreas(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/controlled_ground_areas/', { query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((controlledGroundArea) => controlledGroundArea.data) });
+        }
+        else {
+            return resp;
+        }
+    }
+    async createControlledGroundArea(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/controlled_ground_areas/', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getControlledGroundArea(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/controlled_ground_areas/{controlled_ground_area_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async updateControlledGroundArea(id, args, opts) {
+        const resp = await this.fetcher.PUT('/risk_assessment/sora/controlled_ground_areas/{controlled_ground_area_id}', { body: args, path: { controlled_ground_area_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async deleteControlledGroundArea(args, opts) {
+        const resp = await this.fetcher.DELETE('/risk_assessment/sora/controlled_ground_areas/{controlled_ground_area_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: true });
+        }
+        return resp;
+    }
+    /// atypical airspaces
+    async getAllAtypicalAirspaces(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/atypical_airspaces/', { query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((atypicalAirspace) => atypicalAirspace.data) });
+        }
+        else {
+            return resp;
+        }
+    }
+    async createAtypicalAirspace(args, opts) {
+        const resp = await this.fetcher.POST('/risk_assessment/sora/atypical_airspaces/', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getAtypicalAirspace(args, opts) {
+        const resp = await this.fetcher.GET('/risk_assessment/sora/atypical_airspaces/{atypical_airspace_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async updateAtypicalAirspace(id, args, opts) {
+        const resp = await this.fetcher.PUT('/risk_assessment/sora/atypical_airspaces/{atypical_airspace_id}', { body: args, path: { atypical_airspace_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async deleteAtypicalAirspace(args, opts) {
+        const resp = await this.fetcher.DELETE('/risk_assessment/sora/atypical_airspaces/{atypical_airspace_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: true });
+        }
+        return resp;
+    }
+    /// geocages
+    async createGeocage(args, opts) {
+        const resp = await this.fetcher.POST('/geocages/', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getGeocage(args, opts) {
+        const resp = await this.fetcher.GET('/geocages/{geocage_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async getAllGeocages(args, opts) {
+        const resp = await this.fetcher.GET('/geocages/', { query: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        else {
+            return resp;
+        }
+    }
+    async updateGeocage(id, args, opts) {
+        const resp = await this.fetcher.PUT('/geocages/{geocage_id}', { body: args, path: { geocage_id: id } }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+    async deleteGeocage(args, opts) {
+        const resp = await this.fetcher.DELETE('/geocages/{geocage_id}', { path: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: true });
+        }
+        return resp;
+    }
+    /// flight patterns
+    async createRasterPattern(args, opts) {
+        const resp = await this.fetcher.POST('/flight_patterns/raster', { body: args }, opts);
+        if (resp.error === undefined && !resp.aborted) {
+            return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+        }
+        return resp;
+    }
+}
+
+// settings & const
+
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+
+// utils
+
+/**
+ * Serialize primitive param values
+ * @type {import("./index.js").serializePrimitiveParam}
+ */
+function serializePrimitiveParam(name, value, options) {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.",
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+
+/**
+ * Serialize object param (shallow only)
+ * @type {import("./index.js").serializeObjectParam}
+ */
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner =
+    {
+      simple: ",",
+      label: ".",
+      matrix: ";",
+    }[options.style] || "&";
+
+  // explode: false
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final = values.join(","); // note: values are always joined by comma in explode: false (but joiner can prefix)
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final}`;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      default: {
+        return final;
+      }
+    }
+  }
+
+  // explode: true
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+
+/**
+ * Serialize array param (shallow only)
+ * @type {import("./index.js").serializeArrayParam}
+ */
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+
+  // explode: false
+  if (options.explode === false) {
+    const joiner = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ","; // note: for arrays, joiners vary wildly based on style + explode behavior
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+
+  // explode: true
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix"
+    ? `${joiner}${values.join(joiner)}`
+    : values.join(joiner);
+}
+
+/**
+ * Serialize query params to string
+ * @type {import("./index.js").createQuerySerializer}
+ */
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === undefined || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: false,
+            }),
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: false,
+            }),
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+
+/**
+ * Handle different OpenAPI 3.x serialization styles
+ * @type {import("./index.js").defaultPathSerializer}
+ * @see https://swagger.io/docs/specification/serialization/#path
+ */
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === undefined || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+
+var version = "1.3595.1";
+
+const querySerializer = createQuerySerializer();
+class Fetcher {
+    constructor(args) {
+        var _a, _b, _c, _d;
+        this.opts = {
+            url: (_a = args.url) !== null && _a !== undefined ? _a : 'https://via.volantautonomy.com/api/v1.0',
+            fetchFn: (_b = args.fetchFn) !== null && _b !== undefined ? _b : undefined,
+            authFetchFn: (_c = args.authFetchFn) !== null && _c !== undefined ? _c : undefined,
+            username: args.username,
+            password: args.password,
+            ignoreAuth: (_d = args.ignoreAuth) !== null && _d !== undefined ? _d : false
+        };
+        this.aborts = {};
+        this.accessToken = undefined;
+        this.expiry = Date.now() - 5;
+    }
+    async doAuth() {
+        var _a;
+        // NOTE: THIS REQUEST IS NOT TYPE CHECKED PROPERLY AS paths IS NOT KNOWN HERE!
+        if (this.opts.username === undefined || this.opts.password === undefined) {
+            throw new UnauthenticatedError('ignoreAuth is not true and either username or password is missing');
+        }
+        const authFetchFn = (_a = this.opts.authFetchFn) !== null && _a !== undefined ? _a : globalThis.fetch;
+        const resp = await authFetchFn(this.opts.url + '/login', {
+            body: JSON.stringify({
+                username: this.opts.username,
+                password: this.opts.password
+            }),
+            redirect: 'follow',
+            method: 'post',
+            headers: { 'Content-Type': 'application/json', 'X-Via-Sdk-Version': version }
+        });
+        if (resp.ok) {
+            const data = (await resp.json());
+            this.expiry = Date.now() + data.expires_in - 10;
+            this.accessToken = data.access_token;
+        }
+        else {
+            throw new UnauthenticatedError('Invalid credentials');
+        }
+    }
+    /** Takes in an abort key to determine what abort signals should be fired and a new signal */
+    handleAbortKey(abortKey) {
+        var _a;
+        if (abortKey) {
+            (_a = this.aborts[abortKey]) === null || _a === undefined ? undefined : _a.abort();
+            const abortController = new AbortController();
+            this.aborts[abortKey] = abortController;
+            return abortController.signal;
+        }
+        return undefined;
+    }
+    /** Transforms an error from the api into an {@link SdkErrorModel} */
+    async parseError(response) {
+        var _a;
+        const error = (await response.json());
+        // NOTE: throws away the status codes inside of the individual errors
+        if (((_a = error === null || error === undefined ? undefined : error.errors) === null || _a === undefined ? undefined : _a.length) === 0) {
+            return {
+                status: String(response.status),
+                errors: [
+                    {
+                        status: String(response.status),
+                        detail: ''
+                    }
+                ]
+            };
+        }
+        else {
+            return {
+                status: String(response.status),
+                errors: error === null || error === undefined ? undefined : error.errors.map((err) => {
+                    return {
+                        status: String(err.status),
+                        detail: err.detail
+                    };
+                })
+            };
+        }
+    }
+    // source: https://github.com/openapi-ts/openapi-typescript/blob/f21c05b9afcc89ee6ef73edab4045620b410eb01/packages/openapi-fetch/src/index.js#L447
+    createFinalURL(path, options) {
+        var _a;
+        let finalURL = `${this.opts.url}${path}`;
+        if (options === null || options === undefined ? undefined : options.path) {
+            finalURL = defaultPathSerializer(finalURL, options.path);
+        }
+        const search = querySerializer((_a = options.query) !== null && _a !== undefined ? _a : {});
+        if (search) {
+            finalURL += `?${search}`;
+        }
+        return finalURL;
+    }
+    /** The actual fetch wrapper. It is type inference blind, beyond the parseAs type */
+    async fetcher(method, path, data, opts) {
+        var _a, _b, _c;
+        if (!this.opts.ignoreAuth) {
+            if (!this.accessToken || this.expiry <= Date.now()) {
+                await this.doAuth();
+            }
+        }
+        const fetchFn = (_b = (_a = opts === null || opts === undefined ? undefined : opts.fetch) !== null && _a !== undefined ? _a : this.opts.fetchFn) !== null && _b !== undefined ? _b : globalThis.fetch;
+        const parseAs = (_c = opts === null || opts === undefined ? undefined : opts.parseAs) !== null && _c !== undefined ? _c : 'json';
+        const request = new Request(this.createFinalURL(path, { query: data === null || data === undefined ? undefined : data.query, path: data === null || data === undefined ? undefined : data.path }), {
+            redirect: 'follow',
+            signal: this.handleAbortKey(opts === null || opts === undefined ? undefined : opts.abortKey),
+            body: JSON.stringify(data === null || data === undefined ? undefined : data.body),
+            headers: Object.assign({ 'Content-Type': 'application/json', 'X-Via-Sdk-Version': version }, data === null || data === undefined ? undefined : data.header),
+            method
+        });
+        if (!this.opts.ignoreAuth) {
+            request.headers.set('Authorization', `Bearer ${this.accessToken}`);
+        }
+        let response;
+        try {
+            response = await fetchFn(request);
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                return { aborted: true };
+            }
+            throw err;
+        }
+        if (response.status === 401) {
+            throw new UnauthenticatedError('Unauthenticated');
+        }
+        // handle empty content
+        // note: we return `{}` because we want user truthy checks for `.data` or `.error` to succeed
+        // NOTE: this does lie to the user, as we say it is undefined
+        if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+            return response.ok
+                ? { data: {}, aborted: false, response }
+                : { error: {}, aborted: false, response };
+        }
+        if (response.ok) {
+            // if "stream", skip parsing entirely
+            if (parseAs === 'stream') {
+                return { data: response.body, aborted: false, response };
+            }
+            return { data: await response[parseAs](), aborted: false, response };
+        }
+        return { error: await this.parseError(response), aborted: false };
+    }
+    async GET(path, data, opts) {
+        return this.fetcher('get', path, data, opts);
+    }
+    async PUT(path, data, opts) {
+        return this.fetcher('put', path, data, opts);
+    }
+    async POST(path, data, opts) {
+        return this.fetcher('post', path, data, opts);
+    }
+    async DELETE(path, data, opts) {
+        return this.fetcher('delete', path, data, opts);
+    }
+    async OPTIONS(path, data, opts) {
+        return this.fetcher('options', path, data, opts);
+    }
+    async HEAD(path, data, opts) {
+        return this.fetcher('post', path, data, opts);
+    }
+}
+// indirection is required to get ts to accept the type magic
+//* * `paths` MUST be passed in as a generic type arg or type inference falls apart */
+function createFetcher(...args) {
+    return new Fetcher(...args);
+}
+
+function createSDK(opts) {
+    if (!opts.ignoreAuth && (opts.username === undefined || opts.password === undefined)) {
+        throw new UnauthenticatedError('ignoreAuth is not true and either username or password is missing');
+    }
+    const fetcher = createFetcher(opts);
+    const newDirect = new Direct(fetcher);
+    return {
+        direct: newDirect,
+        composite: new Composite(newDirect)
+    };
+}
+
+/** Takes in an array of coordinates and flight options, and returns an array of checkpoints for use in the other functions */
+function generateCheckpointsFromCoordinates(args) {
+    const { coordinates, options } = args;
+    if (coordinates.length <= 2) {
+        throw Error('Must have at least two coordinates');
+    }
+    const waypoints = [
+        {
+            type: 'start',
+            position: coordinates[0] // first coord exists because of length check above
+        }
+    ];
+    for (const position of coordinates.slice(1)) {
+        waypoints.push({
+            type: 'goto',
+            position,
+            parameters: options
+        });
+    }
+    return waypoints;
+}
+/** Takes in an array of coordinates and flight options, and returns an array of waypoints for use in the other functions */
+function generateWaypointsFromCoordinates(args) {
+    const { coordinates, options } = args;
+    if (coordinates.length <= 2) {
+        throw Error('Must have at least two coordinates');
+    }
+    const waypoints = [
+        {
+            type: 'start',
+            position: coordinates[0] // first coord exists because of length check above
+        }
+    ];
+    for (const position of coordinates.slice(1)) {
+        if (options.wind_parameters)
+            waypoints.push({
+                type: 'goto',
+                position,
+                flight_parameters: options.flight_parameters,
+                wind_parameters: options.wind_parameters
+            });
+        else
+            waypoints.push({
+                type: 'goto',
+                position,
+                flight_parameters: options.flight_parameters
+            });
+    }
+    return waypoints;
+}
+/** Converts from seconds since epoch to a RFC3339-formatted datetime string */
+function rfcDateTime(secondsEpoch) {
+    return new Date(secondsEpoch * 1000).toISOString().slice(0, 16) + 'Z';
+}
+
+export { createSDK, generateCheckpointsFromCoordinates, generateWaypointsFromCoordinates, rfcDateTime };
+//# sourceMappingURL=index.esm.js.map