@volant-autonomy/via-sdk 1.3427.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
@@ -2506,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: {
             /**
@@ -4707,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: {
@@ -5038,6 +5320,57 @@ export interface operations {
             };
         };
     };
+    uk_residual_arc_v1_risk_assessment_sora_uk_residual_arc_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: 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: {
@@ -5578,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.3427.1",
+  "version": "1.3485.1",
   "license": "MIT",
   "source": "src/index.ts",
   "types": "dist/index.d.ts",