swoop-common 2.1.49 → 2.1.51

package/dist/api/generated/itinerary/models/Error.d.ts

@@ -0,0 +1 @@
+export type Error = Record<string, any>;

package/dist/api/generated/itinerary/models/Error.js

@@ -0,0 +1 @@
+export {};

package/dist/api/generated/itinerary/models/itineraryIdQuery.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Itinerary Id
+ */
+export type itineraryIdQuery = string;

package/dist/api/generated/itinerary/models/itineraryIdQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/api/generated/itinerary/services/AuditService.d.ts

@@ -0,0 +1,12 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class AuditService {
+    /**
+     * Audit a Copy to Clipboard
+     * Audits when a user copies something to their clipboard
+     * @param itineraryId Itinerary id
+     * @param content Base64 encoding of the copied content
+     * @returns void
+     * @throws ApiError
+     */
+    static auditCopyClipboard(itineraryId: string, content: string): CancelablePromise<void>;
+}

package/dist/api/generated/itinerary/services/AuditService.js

@@ -0,0 +1,28 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class AuditService {
+    /**
+     * Audit a Copy to Clipboard
+     * Audits when a user copies something to their clipboard
+     * @param itineraryId Itinerary id
+     * @param content Base64 encoding of the copied content
+     * @returns void
+     * @throws ApiError
+     */
+    static auditCopyClipboard(itineraryId, content) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/audit/copyClipboard/{itineraryId}',
+            path: {
+                'itineraryId': itineraryId,
+            },
+            query: {
+                'content': content,
+            },
+            errors: {
+                400: `When the content query b64 string is invalid`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+            },
+        });
+    }
+}

package/dist/api/generated/itinerary/services/ItineraryService.d.ts

@@ -8,56 +8,60 @@ import type { DTOSnapshotRead } from '../models/DTOSnapshotRead';
 import type { Pagination } from '../models/Pagination';
 import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class ItineraryService {
+    /**
+     * Audit a Copy to Clipboard
+     * Audits when a user copies something to their clipboard
+     * @param itineraryId Itinerary id
+     * @param content Base64 encoding of the copied content
+     * @returns void
+     * @throws ApiError
+     */
+    auditCopyClipboard(itineraryId: string, content: string): CancelablePromise<void>;
     /**
      * Create a Snapshot
      * Creates a new snapshot. A snapshot is a reference to a specific itinerary revision group id.
      * @param requestBody
-     * @returns DTOSnapshotRead OK
+     * @returns DTOSnapshotRead When a snapshot is created
      * @throws ApiError
      */
     snapshotCreate(requestBody: DTOSnapshotCreate): CancelablePromise<DTOSnapshotRead>;
     /**
      * List Snapshots
      * List all available snapshots
-     * @param enquiryId Enquiry Id
      * @param page Pagination, starting at page 1
      * @param limit Number of items per page
      * @param sort List of fields to sort by
-     * @returns any OK
+     * @returns any The list of all snapshots given the parameters used
      * @throws ApiError
      */
-    snapshotList(enquiryId: string, page?: number, limit?: number, sort?: any[]): CancelablePromise<{
-        data: Array<DTOSnapshotRead>;
+    snapshotList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTOSnapshotRead>;
         pagination?: Pagination;
     }>;
     /**
      * Get Snapshot va ID
-     * Returns the specific snapshot
+     * Returns the specific snapshot given its Id
      * @param snapshotId
      * @returns any OK
      * @throws ApiError
      */
-    snapshotGet(snapshotId: string): CancelablePromise<{
-        data: Array<DTOSnapshotRead>;
-    }>;
+    snapshotGet(snapshotId: string): CancelablePromise<any>;
     /**
      * Delete Snapshot via ID
-     * Deletes a specific snapshot
+     * Deletes a specific snapshot given its Id
      * @param snapshotId
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
-    snapshotDelete(snapshotId: string): CancelablePromise<any>;
+    snapshotDelete(snapshotId: string): CancelablePromise<void>;
     /**
      * Restore Snapshot
      * Creates a new itinerary revision given the content the snapshot refers to
      * @param snapshotId
-     * @returns any OK
+     * @returns any When a snapshot is restored as the latest version
      * @throws ApiError
      */
-    snapshotRestore(snapshotId: string): CancelablePromise<{
-        data: Array<DTOSnapshotRead>;
-    }>;
+    snapshotRestore(snapshotId: string): CancelablePromise<any>;
     /**
      * List Itineraries
      * List all itineraries
@@ -66,18 +70,18 @@ export declare class ItineraryService {
      * @param search Search term
      * @param sort List of fields to sort by
      * @param enquiryId Filter itineraries via enquiryId
-     * @returns any OK
+     * @returns any The list of all itineraries given the parameters used
      * @throws ApiError
      */
     itineraryList(page?: number, limit?: number, search?: string, sort?: any[], enquiryId?: string): CancelablePromise<{
-        data: Array<DTOItineraryRead>;
+        data?: Array<DTOItineraryRead>;
         pagination?: Pagination;
     }>;
     /**
-     * Create Itinerary
-     * Creates an itinerary
+     * Create an Itinerary
+     * Creates a new itinerary
      * @param requestBody
-     * @returns DTOItineraryRead OK
+     * @returns DTOItineraryRead When a itinerary is created
      * @throws ApiError
      */
     itineraryCreate(requestBody: DTOItineraryCreate): CancelablePromise<DTOItineraryRead>;
@@ -85,35 +89,35 @@ export declare class ItineraryService {
      * Get Itinerary
      * Get itinerary via ID
      * @param itineraryId Itinerary id
-     * @returns DTOItineraryRead OK
+     * @returns any OK
      * @throws ApiError
      */
-    itineraryGet(itineraryId: string): CancelablePromise<DTOItineraryRead>;
+    itineraryGet(itineraryId: string): CancelablePromise<any>;
     /**
-     * Update Itinerary
+     * Update Itinerary as New Revision
      * Updates an itinerary as a new revision
      * @param itineraryId Itinerary id
      * @param requestBody
-     * @returns DTOItineraryRead OK
+     * @returns DTOItineraryRead When a new revision is created successfully
      * @throws ApiError
      */
-    itineraryUpdate(itineraryId: string, requestBody: DTOItineraryUpdate): CancelablePromise<DTOItineraryRead>;
+    itineraryUpdateAsNewRevision(itineraryId: string, requestBody: DTOItineraryUpdate): CancelablePromise<DTOItineraryRead>;
     /**
-     * Delete Itinerary
-     * Delete itinerary via ID
+     * Delete Itinerary via ID
+     * Deletes a specific itinerary given its Id
      * @param itineraryId Itinerary id
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
-    itineraryDelete(itineraryId: string): CancelablePromise<any>;
+    itineraryDelete(itineraryId: string): CancelablePromise<void>;
     /**
      * Sync Itinerary
      * Sync an itinerary with swoop
      * @param itineraryId Itinerary id
-     * @returns DTOItineraryRead OK
+     * @returns DTOItineraryRead When an itinerary has been posted to pub/sub successfully
      * @throws ApiError
      */
-    sync(itineraryId: string): CancelablePromise<DTOItineraryRead>;
+    syncItinerary(itineraryId: string): CancelablePromise<DTOItineraryRead>;
     /**
      * List Regions
      * List all regions
@@ -124,8 +128,8 @@ export declare class ItineraryService {
      * @throws ApiError
      */
     regionList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
-        data: Array<DTORegionRead>;
-        pagination: Pagination;
+        data?: Array<DTORegionRead>;
+        pagination?: Pagination;
     }>;
     /**
      * Create Region

package/dist/api/generated/itinerary/services/ItineraryService.js

@@ -1,11 +1,35 @@
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class ItineraryService {
+    /**
+     * Audit a Copy to Clipboard
+     * Audits when a user copies something to their clipboard
+     * @param itineraryId Itinerary id
+     * @param content Base64 encoding of the copied content
+     * @returns void
+     * @throws ApiError
+     */
+    auditCopyClipboard(itineraryId, content) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/audit/copyClipboard/{itineraryId}',
+            path: {
+                'itineraryId': itineraryId,
+            },
+            query: {
+                'content': content,
+            },
+            errors: {
+                400: `When the content query b64 string is invalid`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+            },
+        });
+    }
     /**
      * Create a Snapshot
      * Creates a new snapshot. A snapshot is a reference to a specific itinerary revision group id.
      * @param requestBody
-     * @returns DTOSnapshotRead OK
+     * @returns DTOSnapshotRead When a snapshot is created
      * @throws ApiError
      */
     snapshotCreate(requestBody) {
@@ -14,19 +38,24 @@ export class ItineraryService {
             url: '/snapshots',
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when creating a snapshot entity`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
      * List Snapshots
      * List all available snapshots
-     * @param enquiryId Enquiry Id
      * @param page Pagination, starting at page 1
      * @param limit Number of items per page
      * @param sort List of fields to sort by
-     * @returns any OK
+     * @returns any The list of all snapshots given the parameters used
      * @throws ApiError
      */
-    snapshotList(enquiryId, page, limit, sort) {
+    snapshotList(page, limit, sort) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/snapshots',
@@ -34,13 +63,18 @@ export class ItineraryService {
                 'page': page,
                 'limit': limit,
                 'sort': sort,
-                'enquiryId': enquiryId,
+            },
+            errors: {
+                400: `If the filter options or query parameters contain invalid values`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when listing all related snapshots`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
             },
         });
     }
     /**
      * Get Snapshot va ID
-     * Returns the specific snapshot
+     * Returns the specific snapshot given its Id
      * @param snapshotId
      * @returns any OK
      * @throws ApiError
@@ -52,13 +86,18 @@ export class ItineraryService {
             path: {
                 'snapshotId': snapshotId,
             },
+            errors: {
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `If the snapshot does not exist`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
      * Delete Snapshot via ID
-     * Deletes a specific snapshot
+     * Deletes a specific snapshot given its Id
      * @param snapshotId
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
     snapshotDelete(snapshotId) {
@@ -68,13 +107,19 @@ export class ItineraryService {
             path: {
                 'snapshotId': snapshotId,
             },
+            errors: {
+                400: `When the snapshot doesn't exist in the first place, or when a before hook fails before deleting the item`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When the snapshot fails to delete due to an internal server error`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
      * Restore Snapshot
      * Creates a new itinerary revision given the content the snapshot refers to
      * @param snapshotId
-     * @returns any OK
+     * @returns any When a snapshot is restored as the latest version
      * @throws ApiError
      */
     snapshotRestore(snapshotId) {
@@ -84,6 +129,13 @@ export class ItineraryService {
             path: {
                 'snapshotId': snapshotId,
             },
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `If the snapshot or itinerary to restore to does not exist`,
+                500: `When the snapshot fails to restore due to an internal server error`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
@@ -94,7 +146,7 @@ export class ItineraryService {
      * @param search Search term
      * @param sort List of fields to sort by
      * @param enquiryId Filter itineraries via enquiryId
-     * @returns any OK
+     * @returns any The list of all itineraries given the parameters used
      * @throws ApiError
      */
     itineraryList(page, limit, search, sort, enquiryId) {
@@ -108,13 +160,19 @@ export class ItineraryService {
                 'sort': sort,
                 'enquiryId': enquiryId,
             },
+            errors: {
+                400: `If the filter options or query parameters contain invalid values`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when listing all related itineraries`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
-     * Create Itinerary
-     * Creates an itinerary
+     * Create an Itinerary
+     * Creates a new itinerary
      * @param requestBody
-     * @returns DTOItineraryRead OK
+     * @returns DTOItineraryRead When a itinerary is created
      * @throws ApiError
      */
     itineraryCreate(requestBody) {
@@ -123,13 +181,19 @@ export class ItineraryService {
             url: '/itineraries',
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when creating a itinerary entity`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
      * Get Itinerary
      * Get itinerary via ID
      * @param itineraryId Itinerary id
-     * @returns DTOItineraryRead OK
+     * @returns any OK
      * @throws ApiError
      */
     itineraryGet(itineraryId) {
@@ -139,17 +203,22 @@ export class ItineraryService {
             path: {
                 'itineraryId': itineraryId,
             },
+            errors: {
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `If the itinerary does not exist`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
-     * Update Itinerary
+     * Update Itinerary as New Revision
      * Updates an itinerary as a new revision
      * @param itineraryId Itinerary id
      * @param requestBody
-     * @returns DTOItineraryRead OK
+     * @returns DTOItineraryRead When a new revision is created successfully
      * @throws ApiError
      */
-    itineraryUpdate(itineraryId, requestBody) {
+    itineraryUpdateAsNewRevision(itineraryId, requestBody) {
         return __request(OpenAPI, {
             method: 'PATCH',
             url: '/itineraries/{itineraryId}',
@@ -158,13 +227,20 @@ export class ItineraryService {
             },
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the itinerary id to create a new revision from is not found`,
+                500: `When an internal server error occurs updating an itinerary as a new revision`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
-     * Delete Itinerary
-     * Delete itinerary via ID
+     * Delete Itinerary via ID
+     * Deletes a specific itinerary given its Id
      * @param itineraryId Itinerary id
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
     itineraryDelete(itineraryId) {
@@ -174,22 +250,35 @@ export class ItineraryService {
             path: {
                 'itineraryId': itineraryId,
             },
+            errors: {
+                400: `When the itinerary doesn't exist in the first place, or when a before hook fails before deleting the item`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When the itinerary fails to delete due to an internal server error`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
      * Sync Itinerary
      * Sync an itinerary with swoop
      * @param itineraryId Itinerary id
-     * @returns DTOItineraryRead OK
+     * @returns DTOItineraryRead When an itinerary has been posted to pub/sub successfully
      * @throws ApiError
      */
-    sync(itineraryId) {
+    syncItinerary(itineraryId) {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/sync/{itineraryId}',
             path: {
                 'itineraryId': itineraryId,
             },
+            errors: {
+                400: `When the itinerary to sync does not exist`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `Related entity not found`,
+                500: `When an internal server error occurs whilst syncing`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
@@ -210,6 +299,12 @@ export class ItineraryService {
                 'limit': limit,
                 'sort': sort,
             },
+            errors: {
+                400: `If the filter options or query parameters contain invalid values`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when listing all related regions`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
     /**
@@ -225,6 +320,12 @@ export class ItineraryService {
             url: '/regions',
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when creating a region entity`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
         });
     }
 }

package/dist/api/generated/itinerary/services/RegionService.d.ts

@@ -0,0 +1,27 @@
+import type { DTORegionCreate } from '../models/DTORegionCreate';
+import type { DTORegionRead } from '../models/DTORegionRead';
+import type { Pagination } from '../models/Pagination';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class RegionService {
+    /**
+     * List Regions
+     * List all regions
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any OK
+     * @throws ApiError
+     */
+    static regionList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTORegionRead>;
+        pagination?: Pagination;
+    }>;
+    /**
+     * Create Region
+     * Create a region
+     * @param requestBody
+     * @returns DTORegionRead OK
+     * @throws ApiError
+     */
+    static regionCreate(requestBody?: DTORegionCreate): CancelablePromise<DTORegionRead>;
+}

package/dist/api/generated/itinerary/services/RegionService.js

@@ -0,0 +1,51 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class RegionService {
+    /**
+     * List Regions
+     * List all regions
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any OK
+     * @throws ApiError
+     */
+    static regionList(page, limit, sort) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/regions',
+            query: {
+                'page': page,
+                'limit': limit,
+                'sort': sort,
+            },
+            errors: {
+                400: `If the filter options or query parameters contain invalid values`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when listing all related regions`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
+        });
+    }
+    /**
+     * Create Region
+     * Create a region
+     * @param requestBody
+     * @returns DTORegionRead OK
+     * @throws ApiError
+     */
+    static regionCreate(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/regions',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                500: `When an internal server error occurs when creating a region entity`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
+        });
+    }
+}

package/dist/api/generated/itinerary/services/SnapshotService.d.ts

@@ -0,0 +1,51 @@
+import type { DTOSnapshotCreate } from '../models/DTOSnapshotCreate';
+import type { DTOSnapshotRead } from '../models/DTOSnapshotRead';
+import type { Pagination } from '../models/Pagination';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class SnapshotService {
+    /**
+     * Create a Snapshot
+     * Creates a new snapshot. A snapshot is a reference to a specific itinerary revision group id.
+     * @param requestBody
+     * @returns DTOSnapshotRead When a snapshot is created
+     * @throws ApiError
+     */
+    static snapshotCreate(requestBody: DTOSnapshotCreate): CancelablePromise<DTOSnapshotRead>;
+    /**
+     * List Snapshots
+     * List all available snapshots
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any The list of all snapshots given the parameters used
+     * @throws ApiError
+     */
+    static snapshotList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTOSnapshotRead>;
+        pagination?: Pagination;
+    }>;
+    /**
+     * Get Snapshot va ID
+     * Returns the specific snapshot given its Id
+     * @param snapshotId
+     * @returns any OK
+     * @throws ApiError
+     */
+    static snapshotGet(snapshotId: string): CancelablePromise<any>;
+    /**
+     * Delete Snapshot via ID
+     * Deletes a specific snapshot given its Id
+     * @param snapshotId
+     * @returns void
+     * @throws ApiError
+     */
+    static snapshotDelete(snapshotId: string): CancelablePromise<void>;
+    /**
+     * Restore Snapshot
+     * Creates a new itinerary revision given the content the snapshot refers to
+     * @param snapshotId
+     * @returns any When a snapshot is restored as the latest version
+     * @throws ApiError
+     */
+    static snapshotRestore(snapshotId: string): CancelablePromise<any>;
+}