@volant-autonomy/via-sdk 1.0.2 → 1.2773.1

package/README.md

@@ -44,6 +44,21 @@ For example, `GET /flightplans/` takes in a filter from a query parameter. The S
 
 Another example, `GET /flightplans/{flightplan_id}` takes in a flightplan ID through the path. The SDK does this through function arguments, ie: `SDK.direct.getFlightplan('aaaaa-bbbbb-ccccc')`
 
+## Feature list
+As well as offering methods for all endpoints within the API, you have access to a variety of features in this API
+Wrapper that help make some common workflows more convenient. These features are as follows:
+| Feature                    | Remark                                                                              | Method                         |
+| -------------------------- |-------------------------------------------------------------------------------------| -------------------------------|
+| Upsert Flightplan          | Create a flightplan no ID is supplied. Update existing flightplan if ID is supplied | upsertFlightplan()             |
+| Fetch Draft Flightplans    | Will fetch a list flightplans that you own that are in `Draft` state                | getAllDraftFlightplans()       |
+| Fetch Closed Flightplans   | Will fetch a list flightplans that you own that are in `Closed` state               | getAllClosedFlightplans()      |
+| Fetch Pending Flightplans  | Will fetch a list flightplans that you own that are in `Pending` state              | getAllPendingFlightplans()     |
+| Fetch Accepted Flightplans | Will fetch a list flightplans that you own that are in `Accepted` state             | getAllAcceptedFlightplans()    |
+| Flightplan approval        | Will attempt to update the state of a Flightplan to `Accepted`                      | attemptAcceptFlightplan()      |
+| Temporal Deconfliction     | Will attempt to temporally deconflict your flightplan and update the departure time | attemptTemporalDeconfliction() |
+| Pathing                    | Will perform a pathing request and return the pathing result                        | doPathingTask()                |
+
+
 ### Response data format
 
 Direct functions return an object with a data field and an error field. Only exactly one of these is defined, the other is undefined.

package/dist/composite.d.ts

@@ -130,6 +130,36 @@ export declare class Composite {
         response: Response;
         aborted: false;
     }>;
+    attemptTemporalDeconfliction(id: string, timeInterval?: number): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "403" | "404";
+            }[];
+            status: "401" | "400" | "422" | "403" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "flightplan";
+            meta: import("./volant-schema").components["schemas"]["FlightplanMeta"];
+            attributes: import("./volant-schema").components["schemas"]["Flightplan-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    } | {
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+    }>;
     /** Handles creating and polling a pathing task for you */
     doPathingTask(args: createPathingTask['requestBody']['content']['application/json']): Promise<{
         error: {

package/dist/composite.js

@@ -52,6 +52,18 @@ class Composite {
             return this.direct.changeFlightplanState(id, 'Accepted');
         });
     }
+    attemptTemporalDeconfliction(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, timeInterval = 60) {
+            const startTimeDeconflictArgs = {
+                time_interval: timeInterval
+            };
+            const { data, error } = yield 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 */
     doPathingTask(args) {

package/dist/direct.d.ts

@@ -34,6 +34,16 @@ export type createSoraReportV2_5 = paths['/risk_assessment/sora/v2.5/report']['p
 export type createSoraSemanticModelVolumesV2_5 = paths['/risk_assessment/sora/v2.5/semantic_model_volumes']['post'];
 export type createSoraClassification = paths['/risk_assessment/sora/classifications']['post'];
 export type getSoraClassification = paths['/risk_assessment/sora/classifications/{classification_id}']['get'];
+export type getAllControlledGroundAreas = paths['/risk_assessment/sora/controlled_ground_areas/']['get'];
+export type createControlledGroundArea = paths['/risk_assessment/sora/controlled_ground_areas/']['post'];
+export type getControlledGroundArea = paths['/risk_assessment/sora/controlled_ground_areas/{controlled_ground_area_id}']['get'];
+export type updateControlledGroundArea = paths['/risk_assessment/sora/controlled_ground_areas/{controlled_ground_area_id}']['put'];
+export type deleteControlledGroundArea = paths['/risk_assessment/sora/controlled_ground_areas/{controlled_ground_area_id}']['delete'];
+export type getAllAtypicalAirspaces = paths['/risk_assessment/sora/atypical_airspaces/']['get'];
+export type createAtypicalAirspace = paths['/risk_assessment/sora/atypical_airspaces/']['post'];
+export type getAtypicalAirspace = paths['/risk_assessment/sora/atypical_airspaces/{atypical_airspace_id}']['get'];
+export type updateAtypicalAirspace = paths['/risk_assessment/sora/atypical_airspaces/{atypical_airspace_id}']['put'];
+export type deleteAtypicalAirspace = paths['/risk_assessment/sora/atypical_airspaces/{atypical_airspace_id}']['delete'];
 export type createRasterPattern = paths['/flight_patterns/raster']['post'];
 export declare class Direct {
     private fetcher;
@@ -103,9 +113,8 @@ export declare class Direct {
     }>;
     /**
      * Modify a Flightplan
-     * @description Modify the specified flightplan. This is only permitted while the flightplan state is not
-     *     `Closed`. If the flightplan is in state: `Accepted`, the flightplan will be subject to conflict
-     *     checking.
+     * @description Modify the specified flightplan. This is only permitted while the flightplan state is not `Closed`. If the
+     *     flightplan is in state: `Accepted`, the flightplan will be subject to conflict checking.
      */
     modifyDraftFlightplan<Opts extends requestOptions = {}>(id: pathOf<modifyDraftFlightplan>['flightplan_id'], args: bodyOf<modifyDraftFlightplan>, opts?: Opts | requestOptions): Promise<{
         data?: never;
@@ -229,10 +238,9 @@ export declare class Direct {
      * Retrieve Flightplan Operational Intent Volumes
      * @description Retrieve Operational Intent Volumes for the specified flightplan
      *
-     *     Volumes wholly contain the operational intent while being as small as practical. Start and end
-     *     times, as well as lower and upper altitudes, are required for each volume. The end time may not
-     *     be in the past. Volumes are generated based on the `LateralParameters` of the flightplan about
-     *     the mean flightpath as defined in each waypoint.
+     *     Volumes wholly contain the operational intent while being as small as practical. Start and end times, as well as
+     *     lower and upper altitudes, are required for each volume. The end time may not be in the past. Volumes are generated
+     *     based on the `LateralParameters` of the flightplan about the mean flightpath as defined in each waypoint.
      */
     getFlightplanVolumes<Opts extends requestOptions = {}>(id: pathOf<getFlightplanVolumes>['flightplan_id'], opts?: Opts | requestOptions): Promise<{
         data?: never;
@@ -261,14 +269,14 @@ export declare class Direct {
     }>;
     /**
      * Retrieve Flightplan Conflicts
+     * @deprecated
      * @description Retrieve all the conflicts for the specified flightplan, categorised by their state.
      *
      *     Flightplans of state `Closed` are ignored.
      *
-     *     Note that Flightplans which are in the category `Draft` will not prevent transitioning the
-     *     specified flightplan in to the `Accepted` state and instead are intended as a warning.
-     *     Flightplans in the `Accepted` state will prevent transition of the specified flightplan to
-     *     `Accepted`.
+     *     Note that Flightplans which are in the category `Draft` will not prevent transitioning the specified flightplan in
+     *     to the `Accepted` state and instead are intended as a warning. Flightplans in the `Accepted` state will prevent
+     *     transition of the specified flightplan to `Accepted`.
      */
     getFlightplanConflicts<Opts extends requestOptions = {}>(id: pathOf<getFlightplanConflicts>['flightplan_id'], opts?: Opts | requestOptions): Promise<{
         data?: never;
@@ -610,6 +618,7 @@ export declare class Direct {
     }>;
     /**
      * List available aircraft
+     * @deprecated
      * @description List available aircraft.
      */
     getAllAircraft<Opts extends requestOptions = {}>(opts?: Opts | requestOptions): Promise<{
@@ -640,6 +649,7 @@ export declare class Direct {
     }>;
     /**
      * Retrieve the specified aircraft
+     * @deprecated
      * @description Retrieve the specified aircraft.
      */
     getAircraft<Opts extends requestOptions = {}>(id: pathOf<getAircraft>['aircraft_id'], opts?: Opts | requestOptions): Promise<{
@@ -779,8 +789,9 @@ export declare class Direct {
         aborted: true;
     } : never) | {
         data: {
-            data: import("./volant-schema").components["schemas"]["ArcResponse"];
-            links: import("./volant-schema").components["schemas"]["Links"];
+            id: import("./volant-schema").components["schemas"]["ARC"];
+            name: string;
+            implemented: boolean;
         }[];
         error?: never;
         response: Response;
@@ -818,7 +829,13 @@ export declare class Direct {
     }>;
     /**
      * Generate a report containing derived SORA information used for regulatory evidence
-     * @description Generate a report containing derived SORA information used for regulatory evidence
+     * @description Generate a report containing derived SORA information used for regulatory evidence.
+     *
+     *
+     *     GRC and ARC determination is considered across the entire operational volume as determined by the supplied
+     *     `waypoints`. Where the operational environment differs across the volume, the worst case is taken, i.e. the highest
+     *     Intrinsic GRC determined and the highest likelihood to encounter another aircraft (as defined by Airspace Encounter
+     *     Class) determining the ARC.
      */
     createSoraReportV2_5<Opts extends requestOptions = {}>(args: bodyOf<createSoraReportV2_5>, opts?: Opts | requestOptions): Promise<{
         data?: never;
@@ -868,7 +885,7 @@ export declare class Direct {
     } : never) | {
         data: {
             type: "FeatureCollection";
-            features: (import("./volant-schema").components["schemas"]["GeoJsonPolygonFeature_GeoJsonSoraProperties_"] | import("./volant-schema").components["schemas"]["GeoJsonMultiPolygonFeature_GeoJsonSoraProperties_"])[];
+            features: (import("./volant-schema").components["schemas"]["GeoJsonPolygonFeature_GeoJsonSemanticModelProperties_"] | import("./volant-schema").components["schemas"]["GeoJsonMultiPolygonFeature_GeoJsonSemanticModelProperties_"])[];
         };
         error?: never;
         response: Response;
@@ -934,6 +951,304 @@ export declare class Direct {
         response: Response;
         aborted: false;
     }>;
+    /**
+     * List Controlled Ground Areas
+     * @description Get a list of Controlled Ground Areas, ordered by last time updated
+     */
+    getAllControlledGroundAreas<Opts extends requestOptions = {}>(args: queryOf<getAllControlledGroundAreas>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "controlled_ground_area";
+            attributes: import("./volant-schema").components["schemas"]["ControlledGroundArea-Output"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Create a Controlled Ground Area
+     * @description Create a Controlled Ground Area from GeoJSON
+     */
+    createControlledGroundArea<Opts extends requestOptions = {}>(args: bodyOf<createControlledGroundArea>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "controlled_ground_area";
+            attributes: import("./volant-schema").components["schemas"]["ControlledGroundArea-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Get a Controlled Ground Area
+     * @description Get a Controlled Ground Area
+     */
+    getControlledGroundArea<Opts extends requestOptions = {}>(args: pathOf<getControlledGroundArea>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "controlled_ground_area";
+            attributes: import("./volant-schema").components["schemas"]["ControlledGroundArea-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Update a Controlled Ground Area
+     * @description Modify an existing Controlled Ground Area. This cannot be performed when it is referenced by a flightplan in state
+     *     `Accepted`.
+     */
+    updateControlledGroundArea<Opts extends requestOptions = {}>(id: pathOf<updateControlledGroundArea>['controlled_ground_area_id'], args: bodyOf<updateControlledGroundArea>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "controlled_ground_area";
+            attributes: import("./volant-schema").components["schemas"]["ControlledGroundArea-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Delete a Controlled Ground Area
+     * @description Delete a Controlled Ground Area.
+     *
+     *     A Controlled Ground Area cannot be deleted if it is referenced by a SORA Classification
+     */
+    deleteControlledGroundArea<Opts extends requestOptions = {}>(args: pathOf<deleteControlledGroundArea>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: boolean;
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * List Controlled Ground Areas
+     * @description Get a list of Atypical Airspaces, ordered by last time updated
+     */
+    getAllAtypicalAirspaces<Opts extends requestOptions = {}>(args: queryOf<getAllAtypicalAirspaces>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "atypical_airspace";
+            attributes: import("./volant-schema").components["schemas"]["AtypicalAirspace-Output"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Create an Atypical Airspace
+     * @description Create an Atypical Airspace
+     */
+    createAtypicalAirspace<Opts extends requestOptions = {}>(args: bodyOf<createAtypicalAirspace>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "atypical_airspace";
+            attributes: import("./volant-schema").components["schemas"]["AtypicalAirspace-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Get an Atypical Airspace
+     * @description Get an Atypical Airspace
+     */
+    getAtypicalAirspace<Opts extends requestOptions = {}>(args: pathOf<getAtypicalAirspace>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "atypical_airspace";
+            attributes: import("./volant-schema").components["schemas"]["AtypicalAirspace-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Update an Atypical Airspace
+     * @description Modify an existing Atypical Airspace. This cannot be performed when it is referenced by a flightplan in state
+     *     `Accepted`.
+     */
+    updateAtypicalAirspace<Opts extends requestOptions = {}>(id: pathOf<updateAtypicalAirspace>['atypical_airspace_id'], args: bodyOf<updateAtypicalAirspace>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: {
+            id: string;
+            type?: "atypical_airspace";
+            attributes: import("./volant-schema").components["schemas"]["AtypicalAirspace-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Delete an Atypical Airspace
+     * @description Delete an Atypical Airspace.
+     *
+     *     A Atypical Airspace cannot be deleted if it is referenced by a SORA Classification
+     */
+    deleteAtypicalAirspace<Opts extends requestOptions = {}>(args: pathOf<deleteAtypicalAirspace>, opts?: Opts | requestOptions): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | (keyof Opts extends never ? never : Opts["abortKey"] extends undefined ? never : Opts["abortKey"] extends string | undefined ? {
+        data?: never;
+        error?: never;
+        response?: never;
+        aborted: true;
+    } : never) | {
+        data: boolean;
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
     /**
      * Generate a raster pattern
      * @description Generate a raster pattern that covers a specified search polygon

package/dist/direct.js

@@ -236,7 +236,7 @@ class Direct {
         return __awaiter(this, void 0, void 0, function* () {
             const resp = yield 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 });
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((arc) => arc.data) });
             }
             return resp;
         });
@@ -286,6 +286,102 @@ class Direct {
             return resp;
         });
     }
+    /// controlled ground areas
+    getAllControlledGroundAreas(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+            }
+        });
+    }
+    createControlledGroundArea(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    getControlledGroundArea(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    updateControlledGroundArea(id, args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    deleteControlledGroundArea(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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
+    getAllAtypicalAirspaces(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+            }
+        });
+    }
+    createAtypicalAirspace(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    getAtypicalAirspace(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    updateAtypicalAirspace(id, args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    deleteAtypicalAirspace(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
     /// flight patterns
     createRasterPattern(args, opts) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/types.d.ts

@@ -37,18 +37,18 @@ export type bodyOf<T> = T extends {
 /** Gets the type of the query input for an endpoint */
 export type queryOf<T> = T extends {
     parameters: {
-        query: infer P;
+        query?: infer P;
     };
 } ? P : never;
 /** Gets the type of the path input for an endpoint */
 export type pathOf<T> = T extends {
     parameters: {
-        path: infer P;
+        path?: infer P;
     };
 } ? P : never;
 /** Gets the type of the header input for an endpoint */
 export type headerOf<T> = T extends {
     parameters: {
-        header: infer P;
+        header?: infer P;
     };
 } ? P : never;