@volant-autonomy/via-sdk 1.3420.1 → 1.3485.1

package/dist/composite.js

@@ -28,22 +28,22 @@ class Composite {
     }
     getAllDraftFlightplans() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.direct.getAllFlightplans(['Draft']);
+            return this.direct.getAllFlightplans({ 'filter[state]': ['Draft'] });
         });
     }
     getAllClosedFlightplans() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.direct.getAllFlightplans(['Closed']);
+            return this.direct.getAllFlightplans({ 'filter[state]': ['Closed'] });
         });
     }
     getAllPendingFlightplans() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.direct.getAllFlightplans(['Pending']);
+            return this.direct.getAllFlightplans({ 'filter[state]': ['Pending'] });
         });
     }
     getAllAcceptedFlightplans() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.direct.getAllFlightplans(['Accepted']);
+            return this.direct.getAllFlightplans({ 'filter[state]': ['Accepted'] });
         });
     }
     // TODO: make error 409 more obvious, as it is different

package/dist/direct.d.ts

@@ -1,5 +1,5 @@
 import createFetcher from './fetch';
-import { bodyOf, queryOf, pathOf, schemas } from './types';
+import { bodyOf, queryOf, pathOf } from './types';
 import type { paths } from './volant-schema';
 type requestOptions = {
     abortKey?: string;
@@ -27,6 +27,7 @@ export type getAircraft = paths['/aircraft/{aircraft_id}']['get'];
 export type getAllCharts = paths['/charts/']['get'];
 export type getChart = paths['/charts/{chart_id}']['get'];
 export type getSailV2_5 = paths['/risk_assessment/sora/v2.5/sail']['get'];
+export type calculateResidualArcV2_5 = paths['/risk_assessment/sora/v2.5/residual_arc']['post'];
 export type getAllArcsV2_5 = paths['/risk_assessment/sora/v2.5/air_risk_classifications']['get'];
 export type getArcV2_5 = paths['/risk_assessment/sora/v2.5/air_risk_classifications/{arc_id}']['get'];
 export type generateSoraReportV2_5 = paths['/risk_assessment/sora/v2.5/report']['post'];
@@ -34,6 +35,7 @@ export type generateSoraSemanticModelVolumesV2_5 = paths['/risk_assessment/sora/
 export type getAllArcsUk = paths['/risk_assessment/sora/uk/air_risk_classifications']['get'];
 export type getArcUk = paths['/risk_assessment/sora/uk/air_risk_classifications/{arc_id}']['get'];
 export type getSailUk = paths['/risk_assessment/sora/uk/sail']['get'];
+export type calculateResidualArcUk = paths['/risk_assessment/sora/uk/residual_arc']['post'];
 export type createSoraReportUk = paths['/risk_assessment/sora/uk/report']['post'];
 export type createSoraSemanticModelVolumesUk = paths['/risk_assessment/sora/uk/semantic_model_volumes']['post'];
 export type createSoraClassification = paths['/risk_assessment/sora/classifications']['post'];
@@ -50,6 +52,11 @@ export type getAtypicalAirspace = paths['/risk_assessment/sora/atypical_airspace
 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 type getGeocage = paths['/geocages/{geocage_id}']['get'];
+export type getAllGeocages = paths['/geocages/']['get'];
+export type createGeocage = paths['/geocages/']['post'];
+export type updateGeocage = paths['/geocages/{geocage_id}']['put'];
+export type deleteGeocage = paths['/geocages/{geocage_id}']['delete'];
 export declare class Direct {
     private fetcher;
     constructor(fetcher: ReturnType<typeof createFetcher<paths>>);
@@ -58,7 +65,7 @@ export declare class Direct {
      * @description List user's flightplans, including Flightplan ID and state.
      *     The most recent 20 flight plans are returned.
      */
-    getAllFlightplans<Opts extends requestOptions = {}>(filters?: schemas['AirspaceRestrictionState'][], opts?: Opts | requestOptions): Promise<{
+    getAllFlightplans<Opts extends requestOptions = {}>(args: queryOf<getAllFlightplans>, opts?: Opts | requestOptions): Promise<{
         data?: never;
         error: {
             errors: {
@@ -736,6 +743,35 @@ export declare class Direct {
         response: Response;
         aborted: false;
     }>;
+    /**
+     * Calculate Residual ARC
+     * @description Calculate the Residual ARC. The Residual ARC is determined as the "worst case".
+     */
+    calculateResidualArcV2_5<Opts extends requestOptions = {}>(args: bodyOf<calculateResidualArcV2_5>, 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: {
+            attributes: import("./volant-schema").components["schemas"]["JarusV2_5ResidualArcAttributes"];
+            id: "arc-a" | "arc-b" | "arc-c" | "arc-d";
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
     /**
      * List available ARCs
      * @description List available ARCs.
@@ -948,6 +984,36 @@ export declare class Direct {
         response: Response;
         aborted: false;
     }>;
+    /**
+     * Calculate Residual ARC
+     * @description Calculate the Residual ARC accounting for any strategic air risk mitigations. The Residual ARC is determined as
+     *     the "worst case".
+     */
+    calculateResidualArcUk<Opts extends requestOptions = {}>(args: bodyOf<calculateResidualArcUk>, 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: {
+            attributes: import("./volant-schema").components["schemas"]["UkResidualArcAttributes"];
+            id: "arc-a" | "arc-b" | "arc-c" | "arc-d";
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
     generateSoraReportUk<Opts extends requestOptions = {}>(args: bodyOf<createSoraReportUk>, opts?: Opts | requestOptions): Promise<{
         data?: never;
         error: {
@@ -1386,6 +1452,151 @@ export declare class Direct {
         response: Response;
         aborted: false;
     }>;
+    /**
+     * Create a Geocage
+     * @description Create a Geocage from GeoJSON
+     */
+    createGeocage<Opts extends requestOptions = {}>(args: bodyOf<createGeocage>, 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?: "geocage";
+            attributes: import("./volant-schema").components["schemas"]["Geocage-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Get a Geocage
+     * @description Get a Geocage
+     */
+    getGeocage<Opts extends requestOptions = {}>(args: pathOf<getGeocage>, 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?: "geocage";
+            attributes: import("./volant-schema").components["schemas"]["Geocage-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * List Geocages
+     * @description Get a list of Geocages, ordered by last time updated
+     */
+    getAllGeocages<Opts extends requestOptions = {}>(args: queryOf<getAllGeocages>, 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: {
+            data: import("./volant-schema").components["schemas"]["GeocageResponse"];
+            links: import("./volant-schema").components["schemas"]["Links"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Update a Geocage
+     * @description Modify an existing Geocage.
+     */
+    updateGeocage<Opts extends requestOptions = {}>(id: pathOf<updateGeocage>['geocage_id'], args: bodyOf<updateGeocage>, 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?: "geocage";
+            attributes: import("./volant-schema").components["schemas"]["Geocage-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /**
+     * Delete a Geocage
+     * @description Delete a Geocage.
+     */
+    deleteGeocage<Opts extends requestOptions = {}>(args: pathOf<deleteGeocage>, 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

@@ -15,9 +15,9 @@ class Direct {
         this.fetcher = fetcher;
     }
     /// flightplans
-    getAllFlightplans(filters, opts) {
+    getAllFlightplans(args, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const resp = yield this.fetcher.GET('/flightplans/', { query: { 'filter[state]': filters } }, opts);
+            const resp = yield 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) });
             }
@@ -223,6 +223,15 @@ class Direct {
             return resp;
         });
     }
+    calculateResidualArcV2_5(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
     getAllArcsV2_5(opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const resp = yield this.fetcher.GET('/risk_assessment/sora/v2.5/air_risk_classifications', {}, opts);
@@ -286,6 +295,15 @@ class Direct {
             return resp;
         });
     }
+    calculateResidualArcUk(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
     generateSoraReportUk(args, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const resp = yield this.fetcher.POST('/risk_assessment/sora/uk/report', { body: args }, opts);
@@ -427,6 +445,54 @@ class Direct {
             return resp;
         });
     }
+    /// geocages
+    createGeocage(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    getGeocage(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    getAllGeocages(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+            }
+        });
+    }
+    updateGeocage(id, args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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;
+        });
+    }
+    deleteGeocage(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield 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
     createRasterPattern(args, opts) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/volant-schema.d.ts

@@ -506,6 +506,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/risk_assessment/sora/v2.5/residual_arc": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Calculate Residual ARC
+         * @description Calculate the Residual ARC. The Residual ARC is determined as the "worst case".
+         */
+        post: operations["jarus_v2_5_residual_arc_v1_risk_assessment_sora_v2_5_residual_arc_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/risk_assessment/sora/v2.5/sail": {
         parameters: {
             query?: never;
@@ -611,6 +631,27 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/risk_assessment/sora/uk/residual_arc": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Calculate Residual ARC
+         * @description Calculate the Residual ARC accounting for any strategic air risk mitigations. The Residual ARC is determined as
+         *     the "worst case".
+         */
+        post: operations["uk_residual_arc_v1_risk_assessment_sora_uk_residual_arc_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/risk_assessment/sora/uk/sail": {
         parameters: {
             query?: never;
@@ -779,6 +820,58 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/geocages/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List Geocages
+         * @description Get a list of Geocages, ordered by last time updated
+         */
+        get: operations["list_geocage_v1_geocages__get"];
+        put?: never;
+        /**
+         * Create a Geocage
+         * @description Create a Geocage from GeoJSON
+         */
+        post: operations["create_geocage_v1_geocages__post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/geocages/{geocage_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a Geocage
+         * @description Get a Geocage
+         */
+        get: operations["get_geocage_v1_geocages__geocage_id__get"];
+        /**
+         * Update a Geocage
+         * @description Modify an existing Geocage.
+         */
+        put: operations["update_geocage_v1_geocages__geocage_id__put"];
+        post?: never;
+        /**
+         * Delete a Geocage
+         * @description Delete a Geocage.
+         */
+        delete: operations["delete_geocage_v1_geocages__geocage_id__delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1227,6 +1320,8 @@ export interface components {
             aircraft_id?: string;
             /** Sora Classification Id */
             sora_classification_id?: string | null;
+            /** Geocage Id */
+            geocage_id?: string | null;
             /**
              * Time Start
              * Format: date-time
@@ -1276,6 +1371,8 @@ export interface components {
             aircraft_id?: string;
             /** Sora Classification Id */
             sora_classification_id?: string | null;
+            /** Geocage Id */
+            geocage_id?: string | null;
             /**
              * Time Start
              * Format: date-time
@@ -1408,6 +1505,16 @@ export interface components {
             geometry: components["schemas"]["GeoJsonPolygon"];
             properties: components["schemas"]["ControlledGroundAreaProperties"];
         };
+        /** GeoJsonPolygonFeature[GeocageProperties] */
+        GeoJsonPolygonFeature_GeocageProperties_: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "Feature";
+            geometry: components["schemas"]["GeoJsonPolygon"];
+            properties: components["schemas"]["GeocageProperties"];
+        };
         /** GeoJsonPolygonFeature[SemanticModelProperties] */
         GeoJsonPolygonFeature_SemanticModelProperties_: {
             /**
@@ -1418,6 +1525,52 @@ export interface components {
             geometry: components["schemas"]["GeoJsonPolygon"];
             properties: components["schemas"]["SemanticModelProperties"];
         };
+        /**
+         * Geocage
+         * @description An area that the operation must be contained within. A Geocage may be composed of 1 or more polygons, unclosed
+         *     polygons will be automatically closed by setting the final coordinate equal to the first coordinate.
+         */
+        "Geocage-Input": {
+            /**
+             * Type
+             * @constant
+             */
+            type: "FeatureCollection";
+            /** Features */
+            features: components["schemas"]["GeoJsonPolygonFeature_GeocageProperties_"][];
+        };
+        /**
+         * Geocage
+         * @description An area that the operation must be contained within. A Geocage may be composed of 1 or more polygons, unclosed
+         *     polygons will be automatically closed by setting the final coordinate equal to the first coordinate.
+         */
+        "Geocage-Output": {
+            /**
+             * Type
+             * @constant
+             */
+            type: "FeatureCollection";
+            /** Features */
+            features: components["schemas"]["GeoJsonPolygonFeature_GeocageProperties_"][];
+        };
+        /** GeocageProperties */
+        GeocageProperties: Record<string, never>;
+        /** GeocageResponse */
+        GeocageResponse: {
+            /**
+             * Geocage ID
+             * Format: uuid
+             * @description Unique identifier of the geocage.
+             */
+            id: string;
+            /**
+             * Type
+             * @default geocage
+             * @constant
+             */
+            type?: "geocage";
+            attributes: components["schemas"]["Geocage-Output"];
+        };
         /**
          * GotoPathingCheckpoint
          * @description Generate a path to a specified location under given `flight_parameters` accounting for given `wind_parameters` and
@@ -1589,6 +1742,32 @@ export interface components {
              */
             m2: "none" | "medium" | "high";
         };
+        /** JarusV2_5ResidualArcAttributes */
+        JarusV2_5ResidualArcAttributes: {
+            /**
+             * Residual Air Risk Classification
+             * @description Determination of Air Risk after the application of any strategic mitigations intended to control             the crewed aircraft type, encounter rates or time of exposure, prior to take-off
+             * @example arc-c
+             * @enum {string}
+             */
+            residual_arc: "arc-a" | "arc-b" | "arc-c" | "arc-d";
+        };
+        /** JarusV2_5ResidualArcRequest */
+        JarusV2_5ResidualArcRequest: {
+            /** Initial Arc */
+            initial_arc: components["schemas"]["ARC"][];
+        };
+        /** JarusV2_5ResidualArcResponse */
+        JarusV2_5ResidualArcResponse: {
+            attributes: components["schemas"]["JarusV2_5ResidualArcAttributes"];
+            /**
+             * Residual Air Risk Classification
+             * @description Determination of Air Risk after the application of any strategic mitigations intended to control             the crewed aircraft type, encounter rates or time of exposure, prior to take-off
+             * @example arc-c
+             * @enum {string}
+             */
+            id: "arc-a" | "arc-b" | "arc-c" | "arc-d";
+        };
         /** JarusV2_5SoraClassification */
         "JarusV2_5SoraClassification-Input": {
             /**
@@ -1667,6 +1846,12 @@ export interface components {
             data: components["schemas"]["JsonApiResponse_FlightplanResponse_"][];
             links: components["schemas"]["Links"];
         };
+        /** JsonApiListResponse[JsonApiResponse[GeocageResponse]] */
+        JsonApiListResponse_JsonApiResponse_GeocageResponse__: {
+            /** Data */
+            data: components["schemas"]["JsonApiResponse_GeocageResponse_"][];
+            links: components["schemas"]["Links"];
+        };
         /** JsonApiListResponse[JsonApiResponse[UkArcResponse]] */
         JsonApiListResponse_JsonApiResponse_UkArcResponse__: {
             /** Data */
@@ -1719,6 +1904,16 @@ export interface components {
             data: components["schemas"]["GeoJsonCollection_SemanticModelProperties_"];
             links: components["schemas"]["Links"];
         };
+        /** JsonApiResponse[GeocageResponse] */
+        JsonApiResponse_GeocageResponse_: {
+            data: components["schemas"]["GeocageResponse"];
+            links: components["schemas"]["Links"];
+        };
+        /** JsonApiResponse[JarusV2_5ResidualArcResponse] */
+        JsonApiResponse_JarusV2_5ResidualArcResponse_: {
+            data: components["schemas"]["JarusV2_5ResidualArcResponse"];
+            links: components["schemas"]["Links"];
+        };
         /** JsonApiResponse[PathingTaskResponse] */
         JsonApiResponse_PathingTaskResponse_: {
             data: components["schemas"]["PathingTaskResponse"];
@@ -1754,6 +1949,11 @@ export interface components {
             data: components["schemas"]["UkArcResponse"];
             links: components["schemas"]["Links"];
         };
+        /** JsonApiResponse[UkResidualArcResponse] */
+        JsonApiResponse_UkResidualArcResponse_: {
+            data: components["schemas"]["UkResidualArcResponse"];
+            links: components["schemas"]["Links"];
+        };
         /** JsonApiResponse[UkSailResponse] */
         JsonApiResponse_UkSailResponse_: {
             data: components["schemas"]["UkSailResponse"];
@@ -1924,11 +2124,8 @@ export interface components {
              * @default NASADEM
              */
             terrain_source?: components["schemas"]["TerrainSource"];
-            /**
-             * Geocage Coordinates
-             * @description The boundary coordinates of a keep-in geocage. Currently geocage is only applied laterally and does not consider altitude.
-             */
-            geocage?: components["schemas"]["Polygon"] | null;
+            /** Geocage Id */
+            geocage_id?: string | null;
             /**
              * Time Start
              * @deprecated
@@ -2412,6 +2609,14 @@ export interface components {
             /** Initial Arc */
             initial_arc: ("arc-a1" | "arc-a2" | "arc-a3" | "arc-a4" | "arc-a5" | "arc-b1" | "arc-c1" | "arc-c2" | "arc-c3" | "arc-c4" | "arc-d1" | "arc-d2")[];
             ground_risk_mitigations: components["schemas"]["UkGroundRiskMitigations"];
+            /**
+             * Strategic Air Risk Mitigations
+             * @description Strategic air risk mitigations to be applied when determining the Residual ARC from the             Initial ARC. These are given as a mapping between the Initial ARC and a reduction in the air risk class.
+             * @default {}
+             */
+            air_risk_mitigations?: {
+                [key: string]: (1 | 2) | undefined;
+            };
             /**
              * Ground Risk Buffer
              * @description The ground risk buffer is an                 area on the ground that surrounds the footprint of the contingency volume. It is                 expected that if the flight exits the contingency volume during a loss of control                 of the operation that the flight will be terminated within this lateral distance.
@@ -2498,6 +2703,40 @@ export interface components {
              */
             m2: "none" | "medium" | "high";
         };
+        /** UkResidualArcAttributes */
+        UkResidualArcAttributes: {
+            /**
+             * Residual Air Risk Classification
+             * @description Determination of Air Risk after the application of any strategic mitigations intended to control             the crewed aircraft type, encounter rates or time of exposure, prior to take-off
+             * @example arc-c
+             * @enum {string}
+             */
+            residual_arc: "arc-a" | "arc-b" | "arc-c" | "arc-d";
+        };
+        /** UkResidualArcRequest */
+        UkResidualArcRequest: {
+            /** Initial Arc */
+            initial_arc: ("arc-a1" | "arc-a2" | "arc-a3" | "arc-a4" | "arc-a5" | "arc-b1" | "arc-c1" | "arc-c2" | "arc-c3" | "arc-c4" | "arc-d1" | "arc-d2")[];
+            /**
+             * Strategic Air Risk Mitigations
+             * @description Strategic air risk mitigations to be applied when determining the Residual ARC from the             Initial ARC. These are given as a mapping between the Initial ARC and a reduction in the air risk class.
+             * @default {}
+             */
+            air_risk_mitigations?: {
+                [key: string]: (1 | 2) | undefined;
+            };
+        };
+        /** UkResidualArcResponse */
+        UkResidualArcResponse: {
+            attributes: components["schemas"]["UkResidualArcAttributes"];
+            /**
+             * Residual Air Risk Classification
+             * @description Determination of Air Risk after the application of any strategic mitigations intended to control             the crewed aircraft type, encounter rates or time of exposure, prior to take-off
+             * @example arc-c
+             * @enum {string}
+             */
+            id: "arc-a" | "arc-b" | "arc-c" | "arc-d";
+        };
         /** UkSailAttributes */
         UkSailAttributes: {
             /**
@@ -4699,6 +4938,57 @@ export interface operations {
             };
         };
     };
+    jarus_v2_5_residual_arc_v1_risk_assessment_sora_v2_5_residual_arc_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["JarusV2_5ResidualArcRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiResponse_JarusV2_5ResidualArcResponse_"];
+                };
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     jarus_v2_5_sail_v1_risk_assessment_sora_v2_5_sail_get: {
         parameters: {
             query: {
@@ -5030,50 +5320,101 @@ export interface operations {
             };
         };
     };
-    uk_sail_v1_risk_assessment_sora_uk_sail_get: {
+    uk_residual_arc_v1_risk_assessment_sora_uk_residual_arc_post: {
         parameters: {
-            query: {
-                /** @description The Final GRC determination, based on the availability and correct application of mitigations to         the operation after determination of the intrinsic GRC. */
-                final_grc: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
-                /**
-                 * @description Qualitative classification of the air environment.
-                 *
-                 *             - 'arc-a1' - ARC-a (NMAC Encounter Rate)
-                 *
-                 *             - 'arc-a2' - ARC-a (Linear Infrastructure)
-                 *
-                 *             - 'arc-a3' - ARC-a (Restricted Airspace)
-                 *
-                 *             - 'arc-a4' - ARC-a (Danger Area)
-                 *
-                 *             - 'arc-a5' - ARC-a (Self Declared)
-                 *
-                 *             - 'arc-b1' - ARC-b (Class C or D Airspace <500ft AGL)
-                 *
-                 *             - 'arc-c1' - ARC-c (Class E or G Airspace)
-                 *
-                 *             - 'arc-c2' - ARC-c (Class C or D Airspace in area with Visual Flight Rules)
-                 *
-                 *             - 'arc-c3' - ARC-c (Class C or D Airspace in area with Low-Level Helicopter Route)
-                 *
-                 *             - 'arc-c4' - ARC-c (Class C or D Airspace >500ft AGL)
-                 *
-                 *             - 'arc-d1' - ARC-d (Class A Airspace)
-                 *
-                 *             - 'arc-d2' - ARC-d (Class C or D Airspace in area with known Instrument Flight Procedures)
-                 *
-                 * @example [
-                 *       "arc-b1",
-                 *       "arc-c4"
-                 *     ]
-                 */
-                arc: ("arc-a1" | "arc-a2" | "arc-a3" | "arc-a4" | "arc-a5" | "arc-b1" | "arc-c1" | "arc-c2" | "arc-c3" | "arc-c4" | "arc-d1" | "arc-d2")[];
-            };
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UkResidualArcRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiResponse_UkResidualArcResponse_"];
+                };
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    uk_sail_v1_risk_assessment_sora_uk_sail_get: {
+        parameters: {
+            query: {
+                /** @description The Final GRC determination, based on the availability and correct application of mitigations to         the operation after determination of the intrinsic GRC. */
+                final_grc: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+                /**
+                 * @description Qualitative classification of the air environment.
+                 *
+                 *             - 'arc-a1' - ARC-a (NMAC Encounter Rate)
+                 *
+                 *             - 'arc-a2' - ARC-a (Linear Infrastructure)
+                 *
+                 *             - 'arc-a3' - ARC-a (Restricted Airspace)
+                 *
+                 *             - 'arc-a4' - ARC-a (Danger Area)
+                 *
+                 *             - 'arc-a5' - ARC-a (Self Declared)
+                 *
+                 *             - 'arc-b1' - ARC-b (Class C or D Airspace <500ft AGL)
+                 *
+                 *             - 'arc-c1' - ARC-c (Class E or G Airspace)
+                 *
+                 *             - 'arc-c2' - ARC-c (Class C or D Airspace in area with Visual Flight Rules)
+                 *
+                 *             - 'arc-c3' - ARC-c (Class C or D Airspace in area with Low-Level Helicopter Route)
+                 *
+                 *             - 'arc-c4' - ARC-c (Class C or D Airspace >500ft AGL)
+                 *
+                 *             - 'arc-d1' - ARC-d (Class A Airspace)
+                 *
+                 *             - 'arc-d2' - ARC-d (Class C or D Airspace in area with known Instrument Flight Procedures)
+                 *
+                 * @example [
+                 *       "arc-b1",
+                 *       "arc-c4"
+                 *     ]
+                 */
+                arc: ("arc-a1" | "arc-a2" | "arc-a3" | "arc-a4" | "arc-a5" | "arc-b1" | "arc-c1" | "arc-c2" | "arc-c3" | "arc-c4" | "arc-d1" | "arc-d2")[];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
         responses: {
             /** @description Successful Response */
             200: {
@@ -5570,4 +5911,283 @@ export interface operations {
             };
         };
     };
+    list_geocage_v1_geocages__get: {
+        parameters: {
+            query?: {
+                "page[offset]"?: number;
+                "page[limit]"?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiListResponse_JsonApiResponse_GeocageResponse__"];
+                };
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    create_geocage_v1_geocages__post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["Geocage-Input"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiResponse_GeocageResponse_"];
+                };
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    get_geocage_v1_geocages__geocage_id__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Unique identifier of the geocage. */
+                geocage_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiResponse_GeocageResponse_"];
+                };
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description The requested resource could not be found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    update_geocage_v1_geocages__geocage_id__put: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                geocage_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["Geocage-Input"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiResponse_GeocageResponse_"];
+                };
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description The requested resource could not be found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    delete_geocage_v1_geocages__geocage_id__delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Unique identifier of the geocage. */
+                geocage_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description One or more input parameters were missing or invalid. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Bearer access token was not provided in Authorization header, token could not         be decoded, or token was invalid. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description The requested resource could not be found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsonApiExceptionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volant-autonomy/via-sdk",
-  "version": "1.3420.1",
+  "version": "1.3485.1",
   "license": "MIT",
   "source": "src/index.ts",
   "types": "dist/index.d.ts",