swoop-common 2.1.50 → 2.1.52

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

@@ -14,25 +14,35 @@ import { resolveTemplateHierarchy } from '../../../additions/templateHierarchyRe
 export class CoreService {
     /**
      * List Templates
-     * List all templates with pagination
+     * List all available templates
      * @param page Pagination, starting at page 1
-     * @returns any OK
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any The list of all templates given the parameters used
      * @throws ApiError
      */
-    templateList(page) {
+    templateList(page, limit, sort) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/templates',
             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`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `When an internal server error occurs when listing all related templates`,
             },
         });
     }
     /**
-     * Create Template
-     * Create a new template
+     * Create a Template
+     * Creates a new Template
      * @param requestBody
-     * @returns DTOTemplateRead OK
+     * @returns DTOTemplateRead When a template is created
      * @throws ApiError
      */
     templateCreate(requestBody) {
@@ -41,33 +51,44 @@ export class CoreService {
             url: '/templates',
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `When an internal server error occurs when creating a template entity`,
+            },
         });
     }
     /**
-     * Get Template
-     * Get a template via id
+     * Get Itinerary
+     * Get itinerary via ID
      * @param templateId Id of a template
-     * @returns DTOTemplateRead OK
+     * @returns any OK
      * @throws ApiError
      */
-    templateGet(templateId) {
+    itineraryGet(templateId) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/templates/{templateId}',
             path: {
                 'templateId': templateId,
             },
+            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`,
+            },
         });
     }
     /**
-     * Update Template
-     * Updates a template as a new revision
+     * Update Template as New Revision
+     * Updates an template as a new revision
      * @param templateId Id of a template
      * @param requestBody
-     * @returns DTOTemplateRead OK
+     * @returns DTOTemplateRead When a new revision is created successfully
      * @throws ApiError
      */
-    templateUpdate(templateId, requestBody) {
+    templateUpdateAsNewRevision(templateId, requestBody) {
         return __request(OpenAPI, {
             method: 'PATCH',
             url: '/templates/{templateId}',
@@ -76,13 +97,20 @@ export class CoreService {
             },
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `When the template id to create a new revision from is not found`,
+                500: `When an internal server error occurs updating a template as a new revision`,
+            },
         });
     }
     /**
-     * Delete Template
-     * Delete a template via id
+     * Delete Template via ID
+     * Deletes a specific template given its Id
      * @param templateId Id of a template
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
     templateDelete(templateId) {
@@ -92,31 +120,46 @@ export class CoreService {
             path: {
                 'templateId': templateId,
             },
+            errors: {
+                400: `When the template doesn't exist in the first place, or when a before hook fails before deleting the item`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `Not Found`,
+                500: `When the template fails to delete due to an internal server error`,
+            },
         });
     }
     /**
-     * List components
-     * List all components
+     * List Component
+     * List all available component
      * @param page Pagination, starting at page 1
      * @param limit Number of items per page
-     * @returns any OK
+     * @param sort List of fields to sort by
+     * @returns any The list of all component given the parameters used
      * @throws ApiError
      */
-    componentList(page, limit) {
+    componentList(page, limit, sort) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/components',
             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`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `When an internal server error occurs when listing all related component`,
             },
         });
     }
     /**
-     * Create Component
-     * Create a new component
+     * Create a Component
+     * Creates a new Component
      * @param requestBody
-     * @returns DTOComponentRead OK
+     * @returns DTOComponentRead When a component is created
      * @throws ApiError
      */
     componentCreate(requestBody) {
@@ -125,13 +168,19 @@ export class CoreService {
             url: '/components',
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `Internal Server Error`,
+            },
         });
     }
     /**
      * Get Component
-     * Get a component via id
+     * Get Component via ID
      * @param componentId Id of a component
-     * @returns DTOComponentRead OK
+     * @returns any OK
      * @throws ApiError
      */
     componentGet(componentId) {
@@ -141,32 +190,70 @@ export class CoreService {
             path: {
                 'componentId': componentId,
             },
+            errors: {
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `If the component does not exist`,
+            },
+        });
+    }
+    /**
+     * Update Component as New Revision
+     * Updates an component as a new revision
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns DTOComponentRead When a new component is created successfully
+     * @throws ApiError
+     */
+    componentUpdateAsNewRevision(componentId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/components/{componentId}',
+            path: {
+                'componentId': componentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `When the component id to create a new revision from is not found`,
+                500: `When an internal server error occurs updating a component as a new revision`,
+            },
         });
     }
     /**
      * Update Component
-     * Update a component as a new revision
+     * Updates an component
      * @param componentId Id of a component
      * @param requestBody
-     * @returns DTOComponentRead OK
+     * @returns DTOComponentRead When a component is updated successfully
      * @throws ApiError
      */
     componentUpdate(componentId, requestBody) {
         return __request(OpenAPI, {
-            method: 'PATCH',
+            method: 'PUT',
             url: '/components/{componentId}',
             path: {
                 'componentId': componentId,
             },
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `When the component id to update is not found`,
+                500: `When an internal server error occurs updating a component`,
+            },
         });
     }
     /**
-     * Delete Component
-     * Delete a component via id
+     * Delete Component via ID
+     * Deletes a specific component given its Id
      * @param componentId Id of a component
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
     componentDelete(componentId) {
@@ -176,6 +263,13 @@ export class CoreService {
             path: {
                 'componentId': componentId,
             },
+            errors: {
+                400: `When the component doesn't exist in the first place, or when a before hook fails before deleting the item`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `Not Found`,
+                500: `When the component fails to delete due to an internal server error`,
+            },
         });
     }
     /**
@@ -195,6 +289,11 @@ export class CoreService {
             },
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `Not Found`,
+            },
         });
     }
     /**

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

@@ -0,0 +1,53 @@
+import type { DTOTemplateCreate } from '../models/DTOTemplateCreate';
+import type { DTOTemplateRead } from '../models/DTOTemplateRead';
+import type { DTOTemplateUpdate } from '../models/DTOTemplateUpdate';
+import type { Pagination } from '../models/Pagination';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class TemplateService {
+    /**
+     * List Templates
+     * List all available templates
+     * @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 templates given the parameters used
+     * @throws ApiError
+     */
+    static templateList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTOTemplateRead>;
+        pagination?: Pagination;
+    }>;
+    /**
+     * Create a Template
+     * Creates a new Template
+     * @param requestBody
+     * @returns DTOTemplateRead When a template is created
+     * @throws ApiError
+     */
+    static templateCreate(requestBody: DTOTemplateCreate): CancelablePromise<DTOTemplateRead>;
+    /**
+     * Get Itinerary
+     * Get itinerary via ID
+     * @param templateId Id of a template
+     * @returns any OK
+     * @throws ApiError
+     */
+    static itineraryGet(templateId: string): CancelablePromise<any>;
+    /**
+     * Update Template as New Revision
+     * Updates an template as a new revision
+     * @param templateId Id of a template
+     * @param requestBody
+     * @returns DTOTemplateRead When a new revision is created successfully
+     * @throws ApiError
+     */
+    static templateUpdateAsNewRevision(templateId: string, requestBody: DTOTemplateUpdate): CancelablePromise<DTOTemplateRead>;
+    /**
+     * Delete Template via ID
+     * Deletes a specific template given its Id
+     * @param templateId Id of a template
+     * @returns void
+     * @throws ApiError
+     */
+    static templateDelete(templateId: string): CancelablePromise<void>;
+}

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

@@ -0,0 +1,121 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TemplateService {
+    /**
+     * List Templates
+     * List all available templates
+     * @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 templates given the parameters used
+     * @throws ApiError
+     */
+    static templateList(page, limit, sort) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/templates',
+            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`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `When an internal server error occurs when listing all related templates`,
+            },
+        });
+    }
+    /**
+     * Create a Template
+     * Creates a new Template
+     * @param requestBody
+     * @returns DTOTemplateRead When a template is created
+     * @throws ApiError
+     */
+    static templateCreate(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/templates',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `When an internal server error occurs when creating a template entity`,
+            },
+        });
+    }
+    /**
+     * Get Itinerary
+     * Get itinerary via ID
+     * @param templateId Id of a template
+     * @returns any OK
+     * @throws ApiError
+     */
+    static itineraryGet(templateId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/templates/{templateId}',
+            path: {
+                'templateId': templateId,
+            },
+            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`,
+            },
+        });
+    }
+    /**
+     * Update Template as New Revision
+     * Updates an template as a new revision
+     * @param templateId Id of a template
+     * @param requestBody
+     * @returns DTOTemplateRead When a new revision is created successfully
+     * @throws ApiError
+     */
+    static templateUpdateAsNewRevision(templateId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/templates/{templateId}',
+            path: {
+                'templateId': templateId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `When the template id to create a new revision from is not found`,
+                500: `When an internal server error occurs updating a template as a new revision`,
+            },
+        });
+    }
+    /**
+     * Delete Template via ID
+     * Deletes a specific template given its Id
+     * @param templateId Id of a template
+     * @returns void
+     * @throws ApiError
+     */
+    static templateDelete(templateId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/templates/{templateId}',
+            path: {
+                'templateId': templateId,
+            },
+            errors: {
+                400: `When the template doesn't exist in the first place, or when a before hook fails before deleting the item`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `Not Found`,
+                500: `When the template fails to delete due to an internal server error`,
+            },
+        });
+    }
+}

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

@@ -67,4 +67,7 @@ export type { sortParam } from './models/sortParam';
 export type { templateId } from './models/templateId';
 export type { UserComponentInstanceField } from './models/UserComponentInstanceField';
 export type { ValidationSchemas } from './models/ValidationSchemas';
+export { AuditService } from './services/AuditService';
 export { ItineraryService } from './services/ItineraryService';
+export { RegionService } from './services/RegionService';
+export { SnapshotService } from './services/SnapshotService';

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

@@ -11,4 +11,7 @@ export { Currency } from './models/Currency';
 export { Meals } from './models/Meals';
 export { regionParam } from './models/regionParam';
 export { regionRequired } from './models/regionRequired';
+export { AuditService } from './services/AuditService';
 export { ItineraryService } from './services/ItineraryService';
+export { RegionService } from './services/RegionService';
+export { SnapshotService } from './services/SnapshotService';

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

@@ -1,4 +1,5 @@
 export type DTOSnapshotCreate = {
     name: string;
     itineraryId: string;
+    enquiryId: string;
 };

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

@@ -4,4 +4,5 @@ export type DTOSnapshotEntity = {
     metadata: Metadata;
     name: string;
     itineraryId: string;
+    enquiryId: string;
 };

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

@@ -4,4 +4,5 @@ export type DTOSnapshotRead = {
     metadata: Metadata;
     name: string;
     itineraryId: string;
+    enquiryId: string;
 };

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

@@ -28,13 +28,14 @@ export declare class ItineraryService {
     /**
      * 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 The list of all snapshots given the parameters used
      * @throws ApiError
      */
-    snapshotList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+    snapshotList(enquiryId: string, page?: number, limit?: number, sort?: any[]): CancelablePromise<{
         data?: Array<DTOSnapshotRead>;
         pagination?: Pagination;
     }>;

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

@@ -49,13 +49,14 @@ export class ItineraryService {
     /**
      * 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 The list of all snapshots given the parameters used
      * @throws ApiError
      */
-    snapshotList(page, limit, sort) {
+    snapshotList(enquiryId, page, limit, sort) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/snapshots',
@@ -63,6 +64,7 @@ export class ItineraryService {
                 'page': page,
                 'limit': limit,
                 'sort': sort,
+                'enquiryId': enquiryId,
             },
             errors: {
                 400: `If the filter options or query parameters contain invalid values`,

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`,
+            },
+        });
+    }
+}