@fenixalliance/abs-api-client 1.0.1 → 1.0.3

package/clients/catalogService/services/ItemAttachmentsService.ts

@@ -2,29 +2,35 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
 import type { ItemAttachmentCreateDto } from '../models/ItemAttachmentCreateDto';
 import type { ItemAttachmentDtoEnvelope } from '../models/ItemAttachmentDtoEnvelope';
-import type { ItemAttachmentDtoIReadOnlyCollectionEnvelope } from '../models/ItemAttachmentDtoIReadOnlyCollectionEnvelope';
+import type { ItemAttachmentDtoListEnvelope } from '../models/ItemAttachmentDtoListEnvelope';
 import type { ItemAttachmentUpdateDto } from '../models/ItemAttachmentUpdateDto';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class ItemAttachmentsService {
     /**
-     * @param businessId
+     * @param tenantId
+     * @param xApiVersion
      * @param requestBody
      * @returns ItemAttachmentDtoEnvelope Created
      * @throws ApiError
      */
-    public static postApiV2CatalogServiceItemAttachmentsCreate(
-        businessId: string,
+    public static postApiV2CatalogServiceItemAttachments(
+        tenantId: string,
+        xApiVersion?: string,
         requestBody?: ItemAttachmentCreateDto,
     ): CancelablePromise<ItemAttachmentDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/CatalogService/ItemAttachments/Create',
+            url: '/api/v2/CatalogService/ItemAttachments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -35,18 +41,29 @@ export class ItemAttachmentsService {
         });
     }
     /**
-     * @param itemAttachmentId
-     * @returns ItemAttachmentDtoEnvelope Success
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns ItemAttachmentDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemAttachmentsDetails(
-        itemAttachmentId: string,
-    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
+    public static getApiV2CatalogServiceItemAttachments(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemAttachmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemAttachments/Details/{itemAttachmentId}',
-            path: {
-                'itemAttachmentId': itemAttachmentId,
+            url: '/api/v2/CatalogService/ItemAttachments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
             },
             errors: {
                 401: `Unauthorized`,
@@ -55,24 +72,23 @@ export class ItemAttachmentsService {
         });
     }
     /**
-     * @param businessId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemAttachmentDtoIReadOnlyCollectionEnvelope Success
+     * @param itemAttachmentId
+     * @param xApiVersion
+     * @returns ItemAttachmentDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemAttachmentsList(
-        businessId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemAttachmentDtoIReadOnlyCollectionEnvelope> {
+    public static getApiV2CatalogServiceItemAttachments1(
+        itemAttachmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemAttachments/List',
-            query: {
-                'businessId': businessId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
+            url: '/api/v2/CatalogService/ItemAttachments/{itemAttachmentId}',
+            path: {
+                'itemAttachmentId': itemAttachmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             errors: {
                 401: `Unauthorized`,
@@ -81,19 +97,29 @@ export class ItemAttachmentsService {
         });
     }
     /**
+     * @param tenantId
      * @param itemAttachmentId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
-    public static deleteApiV2CatalogServiceItemAttachmentsDelete(
+    public static deleteApiV2CatalogServiceItemAttachments(
+        tenantId: string,
         itemAttachmentId: string,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemAttachments/Delete/{itemAttachmentId}',
+            url: '/api/v2/CatalogService/ItemAttachments/{itemAttachmentId}',
             path: {
                 'itemAttachmentId': itemAttachmentId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -101,21 +127,31 @@ export class ItemAttachmentsService {
         });
     }
     /**
+     * @param tenantId
      * @param itemAttachmentId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
-    public static putApiV2CatalogServiceItemAttachmentsUpdate(
+    public static putApiV2CatalogServiceItemAttachments(
+        tenantId: string,
         itemAttachmentId: string,
+        xApiVersion?: string,
         requestBody?: ItemAttachmentUpdateDto,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'PUT',
-            url: '/api/v2/CatalogService/ItemAttachments/Update/{itemAttachmentId}',
+            url: '/api/v2/CatalogService/ItemAttachments/{itemAttachmentId}',
             path: {
                 'itemAttachmentId': itemAttachmentId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {

package/clients/catalogService/services/ItemAttributesService.ts

@@ -4,27 +4,32 @@
 /* eslint-disable */
 import type { ItemAttributeCreateDto } from '../models/ItemAttributeCreateDto';
 import type { ItemAttributeDtoEnvelope } from '../models/ItemAttributeDtoEnvelope';
-import type { ItemAttributeDtoIReadOnlyCollectionEnvelope } from '../models/ItemAttributeDtoIReadOnlyCollectionEnvelope';
+import type { ItemAttributeDtoListEnvelope } from '../models/ItemAttributeDtoListEnvelope';
 import type { ItemAttributeUpdateDto } from '../models/ItemAttributeUpdateDto';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class ItemAttributesService {
     /**
-     * @param businessId
+     * @param tenantId
+     * @param xApiVersion
      * @param requestBody
      * @returns ItemAttributeDtoEnvelope Created
      * @throws ApiError
      */
-    public static postApiV2CatalogServiceItemAttributesCreate(
-        businessId: string,
+    public static postApiV2CatalogServiceItemAttributes(
+        tenantId: string,
+        xApiVersion?: string,
         requestBody?: ItemAttributeCreateDto,
     ): CancelablePromise<ItemAttributeDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/CatalogService/ItemAttributes/Create',
+            url: '/api/v2/CatalogService/ItemAttributes',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -35,18 +40,29 @@ export class ItemAttributesService {
         });
     }
     /**
-     * @param itemAttributeId
-     * @returns ItemAttributeDtoEnvelope Success
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns ItemAttributeDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemAttributesDetails(
-        itemAttributeId: string,
-    ): CancelablePromise<ItemAttributeDtoEnvelope> {
+    public static getApiV2CatalogServiceItemAttributes(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemAttributeDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemAttributes/Details/{itemAttributeId}',
-            path: {
-                'itemAttributeId': itemAttributeId,
+            url: '/api/v2/CatalogService/ItemAttributes',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
             },
             errors: {
                 401: `Unauthorized`,
@@ -55,24 +71,23 @@ export class ItemAttributesService {
         });
     }
     /**
-     * @param businessId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemAttributeDtoIReadOnlyCollectionEnvelope Success
+     * @param itemAttributeId
+     * @param xApiVersion
+     * @returns ItemAttributeDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemAttributesList(
-        businessId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemAttributeDtoIReadOnlyCollectionEnvelope> {
+    public static getApiV2CatalogServiceItemAttributes1(
+        itemAttributeId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemAttributeDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemAttributes/List',
-            query: {
-                'businessId': businessId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
+            url: '/api/v2/CatalogService/ItemAttributes/{itemAttributeId}',
+            path: {
+                'itemAttributeId': itemAttributeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             errors: {
                 401: `Unauthorized`,
@@ -81,21 +96,31 @@ export class ItemAttributesService {
         });
     }
     /**
+     * @param tenantId
      * @param itemAttributeId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns any OK
      * @throws ApiError
      */
-    public static putApiV2CatalogServiceItemAttributesUpdate(
+    public static putApiV2CatalogServiceItemAttributes(
+        tenantId: string,
         itemAttributeId: string,
+        xApiVersion?: string,
         requestBody?: ItemAttributeUpdateDto,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'PUT',
-            url: '/api/v2/CatalogService/ItemAttributes/Update/{itemAttributeId}',
+            url: '/api/v2/CatalogService/ItemAttributes/{itemAttributeId}',
             path: {
                 'itemAttributeId': itemAttributeId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -105,19 +130,29 @@ export class ItemAttributesService {
         });
     }
     /**
+     * @param tenantId
      * @param itemAttributeId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static deleteApiV2CatalogServiceItemAttributesDelete(
+    public static deleteApiV2CatalogServiceItemAttributes(
+        tenantId: string,
         itemAttributeId: string,
+        xApiVersion?: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemAttributes/Delete/{itemAttributeId}',
+            url: '/api/v2/CatalogService/ItemAttributes/{itemAttributeId}',
             path: {
                 'itemAttributeId': itemAttributeId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,

package/clients/catalogService/services/ItemBrandsService.ts

@@ -4,27 +4,32 @@
 /* eslint-disable */
 import type { ItemBrandCreateDto } from '../models/ItemBrandCreateDto';
 import type { ItemBrandDtoEnvelope } from '../models/ItemBrandDtoEnvelope';
-import type { ItemBrandDtoIReadOnlyCollectionEnvelope } from '../models/ItemBrandDtoIReadOnlyCollectionEnvelope';
+import type { ItemBrandDtoListEnvelope } from '../models/ItemBrandDtoListEnvelope';
 import type { ItemBrandUpdateDto } from '../models/ItemBrandUpdateDto';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class ItemBrandsService {
     /**
-     * @param businessId
+     * @param tenantId
+     * @param xApiVersion
      * @param requestBody
      * @returns ItemBrandDtoEnvelope Created
      * @throws ApiError
      */
-    public static postApiV2CatalogServiceItemBrandsCreate(
-        businessId: string,
+    public static postApiV2CatalogServiceItemBrands(
+        tenantId: string,
+        xApiVersion?: string,
         requestBody?: ItemBrandCreateDto,
     ): CancelablePromise<ItemBrandDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/CatalogService/ItemBrands/Create',
+            url: '/api/v2/CatalogService/ItemBrands',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -35,18 +40,29 @@ export class ItemBrandsService {
         });
     }
     /**
-     * @param itemBrandId
-     * @returns ItemBrandDtoEnvelope Success
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns ItemBrandDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemBrandsDetails(
-        itemBrandId: string,
-    ): CancelablePromise<ItemBrandDtoEnvelope> {
+    public static getApiV2CatalogServiceItemBrands(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemBrandDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemBrands/Details/{itemBrandId}',
-            path: {
-                'itemBrandId': itemBrandId,
+            url: '/api/v2/CatalogService/ItemBrands',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
             },
             errors: {
                 401: `Unauthorized`,
@@ -55,24 +71,23 @@ export class ItemBrandsService {
         });
     }
     /**
-     * @param businessId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemBrandDtoIReadOnlyCollectionEnvelope Success
+     * @param itemBrandId
+     * @param xApiVersion
+     * @returns ItemBrandDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemBrandsList(
-        businessId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemBrandDtoIReadOnlyCollectionEnvelope> {
+    public static getApiV2CatalogServiceItemBrands1(
+        itemBrandId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemBrands/List',
-            query: {
-                'businessId': businessId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
+            url: '/api/v2/CatalogService/ItemBrands/{itemBrandId}',
+            path: {
+                'itemBrandId': itemBrandId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             errors: {
                 401: `Unauthorized`,
@@ -81,21 +96,31 @@ export class ItemBrandsService {
         });
     }
     /**
+     * @param tenantId
      * @param itemBrandId
+     * @param xApiVersion
      * @param requestBody
-     * @returns ItemBrandDtoEnvelope Success
+     * @returns ItemBrandDtoEnvelope OK
      * @throws ApiError
      */
-    public static putApiV2CatalogServiceItemBrandsUpdate(
+    public static putApiV2CatalogServiceItemBrands(
+        tenantId: string,
         itemBrandId: string,
+        xApiVersion?: string,
         requestBody?: ItemBrandUpdateDto,
     ): CancelablePromise<ItemBrandDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'PUT',
-            url: '/api/v2/CatalogService/ItemBrands/Update/{itemBrandId}',
+            url: '/api/v2/CatalogService/ItemBrands/{itemBrandId}',
             path: {
                 'itemBrandId': itemBrandId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -105,19 +130,29 @@ export class ItemBrandsService {
         });
     }
     /**
+     * @param tenantId
      * @param itemBrandId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static deleteApiV2CatalogServiceItemBrandsDelete(
+    public static deleteApiV2CatalogServiceItemBrands(
+        tenantId: string,
         itemBrandId: string,
+        xApiVersion?: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemBrands/Delete/{itemBrandId}',
+            url: '/api/v2/CatalogService/ItemBrands/{itemBrandId}',
             path: {
                 'itemBrandId': itemBrandId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,