swoop-common 2.1.78 → 2.1.80

package/dist/api/generated/core/index.d.ts

@@ -97,4 +97,5 @@ export type { ValidationSchemas } from './models/ValidationSchemas';
 export type { VersionPathParam } from './models/VersionPathParam';
 export { ComponentService } from './services/ComponentService';
 export { CoreService } from './services/CoreService';
+export { SwooperService } from './services/SwooperService';
 export { TemplateService } from './services/TemplateService';

package/dist/api/generated/core/index.js

@@ -15,4 +15,5 @@ export { OrgId } from './models/OrgId';
 export { UrgencyCTA } from './models/UrgencyCTA';
 export { ComponentService } from './services/ComponentService';
 export { CoreService } from './services/CoreService';
+export { SwooperService } from './services/SwooperService';
 export { TemplateService } from './services/TemplateService';

package/dist/api/generated/core/services/CoreService.d.ts

@@ -3,10 +3,14 @@ import type { ComponentState } from '../models/ComponentState';
 import type { DTOComponentCreate } from '../models/DTOComponentCreate';
 import type { DTOComponentRead } from '../models/DTOComponentRead';
 import type { DTOComponentUpdate } from '../models/DTOComponentUpdate';
+import type { DTOSwooperCreate } from '../models/DTOSwooperCreate';
+import type { DTOSwooperRead } from '../models/DTOSwooperRead';
+import type { DTOSwooperUpdate } from '../models/DTOSwooperUpdate';
 import type { DTOTemplateCreate } from '../models/DTOTemplateCreate';
 import { DTOTemplateRead } from '../models/DTOTemplateRead';
 import type { DTOTemplateUpdate } from '../models/DTOTemplateUpdate';
 import type { Pagination } from '../models/Pagination';
+import type { SwooperId } from '../models/SwooperId';
 import type { TemplateId } from '../models/TemplateId';
 import { CancelablePromise } from '../core/CancelablePromise';
 export declare class CoreService {
@@ -35,13 +39,13 @@ export declare class CoreService {
      */
     templateCreate(requestBody: DTOTemplateCreate): CancelablePromise<DTOTemplateRead>;
     /**
-     * Get Itinerary
-     * Get itinerary via ID
+     * Get Template
+     * Get Template via ID
      * @param templateId Id of a template
      * @returns any OK
      * @throws ApiError
      */
-    itineraryGet(templateId: TemplateId): CancelablePromise<any>;
+    templateGet(templateId: TemplateId): CancelablePromise<any>;
     /**
      * Update Template as New Revision
      * Updates an template as a new revision
@@ -126,6 +130,47 @@ export declare class CoreService {
      * @throws ApiError
      */
     componentStateUpdate(componentId: ComponentId, state: ComponentState): CancelablePromise<any>;
+    /**
+     * List Swoopers
+     * List all swoopers
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param order Order the sort query parameter values either by ascending or descending order
+     * @param sort List of fields to sort by, this requires the order query param
+     * @param search The search strings to apply to the on query parameter values
+     * @param on The fields to apply the search to, the list follows the order and length of the search values in the search query
+     * @returns any OK
+     * @throws ApiError
+     */
+    swooperList(page?: number, limit?: number, order?: 'asc' | 'desc', sort?: any[], search?: Array<string>, on?: Array<string>): CancelablePromise<{
+        data?: Array<DTOSwooperRead>;
+        pagination?: Pagination;
+    }>;
+    /**
+     * Create Swooper
+     * Create a Swooper
+     * @param requestBody
+     * @returns DTOSwooperRead OK
+     * @throws ApiError
+     */
+    swooperCreate(requestBody?: DTOSwooperCreate): CancelablePromise<DTOSwooperRead>;
+    /**
+     * Get Swooper
+     * Get Swooper via ID
+     * @param swooperId Swooper Id
+     * @returns any The corresponding Swooper that matches their Swooper id
+     * @throws ApiError
+     */
+    swooperGet(swooperId: SwooperId): CancelablePromise<any>;
+    /**
+     * Update Swooper
+     * Update Swooper via ID
+     * @param swooperId Swooper Id
+     * @param requestBody
+     * @returns any The corresponding Swooper that matches their Swooper id
+     * @throws ApiError
+     */
+    swooperUpdate(swooperId: SwooperId, requestBody: DTOSwooperUpdate): CancelablePromise<any>;
     /**
      * Resolve template hierarchy
      * @returns Array<DTOTemplateRead> OK

package/dist/api/generated/core/services/CoreService.js

@@ -66,13 +66,13 @@ export class CoreService {
         });
     }
     /**
-     * Get Itinerary
-     * Get itinerary via ID
+     * Get Template
+     * Get Template via ID
      * @param templateId Id of a template
      * @returns any OK
      * @throws ApiError
      */
-    itineraryGet(templateId) {
+    templateGet(templateId) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/templates/{templateId}',
@@ -82,7 +82,7 @@ export class CoreService {
             errors: {
                 401: `Unauthorized - Missing or invalid Authorization header`,
                 403: `Forbidden - The client is authenticated but not authorized to access this resource`,
-                404: `If the itinerary does not exist`,
+                404: `If the Template does not exist`,
             },
         });
     }
@@ -309,6 +309,108 @@ export class CoreService {
             },
         });
     }
+    /**
+     * List Swoopers
+     * List all swoopers
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param order Order the sort query parameter values either by ascending or descending order
+     * @param sort List of fields to sort by, this requires the order query param
+     * @param search The search strings to apply to the on query parameter values
+     * @param on The fields to apply the search to, the list follows the order and length of the search values in the search query
+     * @returns any OK
+     * @throws ApiError
+     */
+    swooperList(page, limit, order, sort, search, on) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/swooper',
+            query: {
+                'page': page,
+                'limit': limit,
+                'order': order,
+                'sort': sort,
+                'search': search,
+                'on': on,
+            },
+            errors: {
+                400: `If the filter options or query parameters contain invalid values`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the Swooper is not found`,
+                500: `When an internal server error occurs when listing all related swoopers`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
+        });
+    }
+    /**
+     * Create Swooper
+     * Create a Swooper
+     * @param requestBody
+     * @returns DTOSwooperRead OK
+     * @throws ApiError
+     */
+    swooperCreate(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/swooper',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the Swooper is not found`,
+                500: `When an internal server error occurs when creating a swooper entity`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
+        });
+    }
+    /**
+     * Get Swooper
+     * Get Swooper via ID
+     * @param swooperId Swooper Id
+     * @returns any The corresponding Swooper that matches their Swooper id
+     * @throws ApiError
+     */
+    swooperGet(swooperId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/swooper/{swooperId}',
+            path: {
+                'swooperId': swooperId,
+            },
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the Swooper is not found`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
+        });
+    }
+    /**
+     * Update Swooper
+     * Update Swooper via ID
+     * @param swooperId Swooper Id
+     * @param requestBody
+     * @returns any The corresponding Swooper that matches their Swooper id
+     * @throws ApiError
+     */
+    swooperUpdate(swooperId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/swooper/{swooperId}',
+            path: {
+                'swooperId': swooperId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the Swooper is not found`,
+                503: `Service Unavailable - The server is temporarily unable to handle the request`,
+            },
+        });
+    }
     /**
      * Resolve template hierarchy
      * @returns Array<DTOTemplateRead> OK

package/dist/api/generated/{itinerary → core}/services/SwooperService.js

@@ -28,6 +28,7 @@ export class SwooperService {
             errors: {
                 400: `If the filter options or query parameters contain invalid values`,
                 401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the Swooper is not found`,
                 500: `When an internal server error occurs when listing all related swoopers`,
                 503: `Service Unavailable - The server is temporarily unable to handle the request`,
             },
@@ -49,6 +50,7 @@ export class SwooperService {
             errors: {
                 400: `If the payload is malformed`,
                 401: `Unauthorized - Missing or invalid Authorization header`,
+                404: `When the Swooper is not found`,
                 500: `When an internal server error occurs when creating a swooper entity`,
                 503: `Service Unavailable - The server is temporarily unable to handle the request`,
             },
@@ -71,7 +73,7 @@ export class SwooperService {
             errors: {
                 400: `If the payload is malformed`,
                 401: `Unauthorized - Missing or invalid Authorization header`,
-                404: `If the Swooper does not exist as it does not match the Swooper id`,
+                404: `When the Swooper is not found`,
                 503: `Service Unavailable - The server is temporarily unable to handle the request`,
             },
         });
@@ -96,7 +98,7 @@ export class SwooperService {
             errors: {
                 400: `If the payload is malformed`,
                 401: `Unauthorized - Missing or invalid Authorization header`,
-                404: `If the Swooper does not exist as it does not match the Swooper id`,
+                404: `When the Swooper is not found`,
                 503: `Service Unavailable - The server is temporarily unable to handle the request`,
             },
         });

package/dist/api/generated/core/services/TemplateService.d.ts

@@ -30,13 +30,13 @@ export declare class TemplateService {
      */
     static templateCreate(requestBody: DTOTemplateCreate): CancelablePromise<DTOTemplateRead>;
     /**
-     * Get Itinerary
-     * Get itinerary via ID
+     * Get Template
+     * Get Template via ID
      * @param templateId Id of a template
      * @returns any OK
      * @throws ApiError
      */
-    static itineraryGet(templateId: TemplateId): CancelablePromise<any>;
+    static templateGet(templateId: TemplateId): CancelablePromise<any>;
     /**
      * Update Template as New Revision
      * Updates an template as a new revision

package/dist/api/generated/core/services/TemplateService.js

@@ -55,13 +55,13 @@ export class TemplateService {
         });
     }
     /**
-     * Get Itinerary
-     * Get itinerary via ID
+     * Get Template
+     * Get Template via ID
      * @param templateId Id of a template
      * @returns any OK
      * @throws ApiError
      */
-    static itineraryGet(templateId) {
+    static templateGet(templateId) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/templates/{templateId}',
@@ -71,7 +71,7 @@ export class TemplateService {
             errors: {
                 401: `Unauthorized - Missing or invalid Authorization header`,
                 403: `Forbidden - The client is authenticated but not authorized to access this resource`,
-                404: `If the itinerary does not exist`,
+                404: `If the Template does not exist`,
             },
         });
     }

package/dist/api/generated/itinerary/index.d.ts

@@ -99,4 +99,3 @@ export { AuditService } from './services/AuditService';
 export { ItineraryService } from './services/ItineraryService';
 export { RegionService } from './services/RegionService';
 export { SnapshotService } from './services/SnapshotService';
-export { SwooperService } from './services/SwooperService';

package/dist/api/generated/itinerary/index.js

@@ -17,4 +17,3 @@ export { AuditService } from './services/AuditService';
 export { ItineraryService } from './services/ItineraryService';
 export { RegionService } from './services/RegionService';
 export { SnapshotService } from './services/SnapshotService';
-export { SwooperService } from './services/SwooperService';

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

@@ -7,14 +7,10 @@ import type { DTORegionCreate } from '../models/DTORegionCreate';
 import type { DTORegionRead } from '../models/DTORegionRead';
 import type { DTOSnapshotCreate } from '../models/DTOSnapshotCreate';
 import type { DTOSnapshotRead } from '../models/DTOSnapshotRead';
-import type { DTOSwooperCreate } from '../models/DTOSwooperCreate';
-import type { DTOSwooperRead } from '../models/DTOSwooperRead';
-import type { DTOSwooperUpdate } from '../models/DTOSwooperUpdate';
 import type { EnquiryId } from '../models/EnquiryId';
 import type { ItineraryId } from '../models/ItineraryId';
 import type { Pagination } from '../models/Pagination';
 import type { SnapshotId } from '../models/SnapshotId';
-import type { SwooperId } from '../models/SwooperId';
 import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class ItineraryService {
     /**
@@ -181,45 +177,4 @@ export declare class ItineraryService {
      * @throws ApiError
      */
     regionCreate(requestBody?: DTORegionCreate): CancelablePromise<DTORegionRead>;
-    /**
-     * List Swoopers
-     * List all swoopers
-     * @param page Pagination, starting at page 1
-     * @param limit Number of items per page
-     * @param order Order the sort query parameter values either by ascending or descending order
-     * @param sort List of fields to sort by, this requires the order query param
-     * @param search The search strings to apply to the on query parameter values
-     * @param on The fields to apply the search to, the list follows the order and length of the search values in the search query
-     * @returns any OK
-     * @throws ApiError
-     */
-    swooperList(page?: number, limit?: number, order?: 'asc' | 'desc', sort?: any[], search?: Array<string>, on?: Array<string>): CancelablePromise<{
-        data?: Array<DTOSwooperRead>;
-        pagination?: Pagination;
-    }>;
-    /**
-     * Create Swooper
-     * Create a Swooper
-     * @param requestBody
-     * @returns DTOSwooperRead OK
-     * @throws ApiError
-     */
-    swooperCreate(requestBody?: DTOSwooperCreate): CancelablePromise<DTOSwooperRead>;
-    /**
-     * Get Swooper
-     * Get Swooper via ID
-     * @param swooperId Swooper Id
-     * @returns any The corresponding Swooper that matches their Swooper id
-     * @throws ApiError
-     */
-    swooperGet(swooperId: SwooperId): CancelablePromise<any>;
-    /**
-     * Update Swooper
-     * Update Swooper via ID
-     * @param swooperId Swooper Id
-     * @param requestBody
-     * @returns any The corresponding Swooper that matches their Swooper id
-     * @throws ApiError
-     */
-    swooperUpdate(swooperId: SwooperId, requestBody: DTOSwooperUpdate): CancelablePromise<any>;
 }

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

@@ -379,104 +379,4 @@ export class ItineraryService {
             },
         });
     }
-    /**
-     * List Swoopers
-     * List all swoopers
-     * @param page Pagination, starting at page 1
-     * @param limit Number of items per page
-     * @param order Order the sort query parameter values either by ascending or descending order
-     * @param sort List of fields to sort by, this requires the order query param
-     * @param search The search strings to apply to the on query parameter values
-     * @param on The fields to apply the search to, the list follows the order and length of the search values in the search query
-     * @returns any OK
-     * @throws ApiError
-     */
-    swooperList(page, limit, order, sort, search, on) {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/swooper',
-            query: {
-                'page': page,
-                'limit': limit,
-                'order': order,
-                'sort': sort,
-                'search': search,
-                'on': on,
-            },
-            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 swoopers`,
-                503: `Service Unavailable - The server is temporarily unable to handle the request`,
-            },
-        });
-    }
-    /**
-     * Create Swooper
-     * Create a Swooper
-     * @param requestBody
-     * @returns DTOSwooperRead OK
-     * @throws ApiError
-     */
-    swooperCreate(requestBody) {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/swooper',
-            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 swooper entity`,
-                503: `Service Unavailable - The server is temporarily unable to handle the request`,
-            },
-        });
-    }
-    /**
-     * Get Swooper
-     * Get Swooper via ID
-     * @param swooperId Swooper Id
-     * @returns any The corresponding Swooper that matches their Swooper id
-     * @throws ApiError
-     */
-    swooperGet(swooperId) {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/swooper/{swooperId}',
-            path: {
-                'swooperId': swooperId,
-            },
-            errors: {
-                400: `If the payload is malformed`,
-                401: `Unauthorized - Missing or invalid Authorization header`,
-                404: `If the Swooper does not exist as it does not match the Swooper id`,
-                503: `Service Unavailable - The server is temporarily unable to handle the request`,
-            },
-        });
-    }
-    /**
-     * Update Swooper
-     * Update Swooper via ID
-     * @param swooperId Swooper Id
-     * @param requestBody
-     * @returns any The corresponding Swooper that matches their Swooper id
-     * @throws ApiError
-     */
-    swooperUpdate(swooperId, requestBody) {
-        return __request(OpenAPI, {
-            method: 'PATCH',
-            url: '/swooper/{swooperId}',
-            path: {
-                'swooperId': swooperId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `If the payload is malformed`,
-                401: `Unauthorized - Missing or invalid Authorization header`,
-                404: `If the Swooper does not exist as it does not match the Swooper id`,
-                503: `Service Unavailable - The server is temporarily unable to handle the request`,
-            },
-        });
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "swoop-common",
-    "version": "2.1.78",
+    "version": "2.1.80",
     "main": "dist/api/index.js",
     "types": "dist/api/index.d.ts",
     "exports": {