@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/catalogService/services/ItemCategoriesService.ts

@@ -10,19 +10,54 @@ import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class ItemCategoriesService {
+    /**
+     * @param itemCategoryId
+     * @param xApiVersion
+     * @returns ItemCategoryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemCategories(
+        itemCategoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemCategories/{itemCategoryId}',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param tenantId
+     * @param itemCategoryId
+     * @param xApiVersion
      * @param requestBody
-     * @returns ItemCategoryDtoEnvelope Created
+     * @returns any OK
      * @throws ApiError
      */
-    public static postApiV2CatalogServiceItemCategoriesCreate(
+    public static putApiV2CatalogServiceItemCategories(
         tenantId: string,
-        requestBody?: ItemCategoryCreateDto,
-    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        itemCategoryId: string,
+        xApiVersion?: string,
+        requestBody?: ItemCategoryUpdateDto,
+    ): CancelablePromise<any> {
         return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/ItemCategories/Create',
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemCategories/{itemCategoryId}',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -35,19 +70,29 @@ export class ItemCategoriesService {
         });
     }
     /**
+     * @param tenantId
      * @param itemCategoryId
-     * @returns ItemCategoryDtoEnvelope Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemCategoriesDetails(
+    public static deleteApiV2CatalogServiceItemCategories(
+        tenantId: string,
         itemCategoryId: string,
-    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<any> {
         return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/ItemCategories/Details/{itemCategoryId}',
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemCategories/{itemCategoryId}',
             path: {
                 'itemCategoryId': itemCategoryId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -58,17 +103,22 @@ export class ItemCategoriesService {
      * @param tenantId
      * @param pageNumber
      * @param pageSize
-     * @returns ItemCategoryDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns ItemCategoryDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemCategoriesList(
+    public static getApiV2CatalogServiceItemCategories1(
         tenantId: string,
         pageNumber?: number,
         pageSize?: number,
+        xApiVersion?: string,
     ): CancelablePromise<ItemCategoryDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemCategories/List',
+            url: '/api/v2/CatalogService/ItemCategories',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
                 'pageNumber': pageNumber,
@@ -82,21 +132,21 @@ export class ItemCategoriesService {
     }
     /**
      * @param tenantId
-     * @param itemCategoryId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns ItemCategoryDtoEnvelope Created
      * @throws ApiError
      */
-    public static putApiV2CatalogServiceItemCategoriesUpdate(
+    public static postApiV2CatalogServiceItemCategories(
         tenantId: string,
-        itemCategoryId: string,
-        requestBody?: ItemCategoryUpdateDto,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+        requestBody?: ItemCategoryCreateDto,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
         return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/api/v2/CatalogService/ItemCategories/Update/{itemCategoryId}',
-            path: {
-                'itemCategoryId': itemCategoryId,
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemCategories',
+            headers: {
+                'x-api-version': xApiVersion,
             },
             query: {
                 'tenantId': tenantId,
@@ -109,29 +159,4 @@ export class ItemCategoriesService {
             },
         });
     }
-    /**
-     * @param tenantId
-     * @param itemCategoryId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static deleteApiV2CatalogServiceItemCategoriesDelete(
-        tenantId: string,
-        itemCategoryId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemCategories/Delete/{itemCategoryId}',
-            path: {
-                'itemCategoryId': itemCategoryId,
-            },
-            query: {
-                'tenantId': tenantId,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
 }

package/clients/catalogService/services/ItemGoogleCategoriesService.ts

@@ -0,0 +1,182 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { ItemGoogleCategoryDtoEnvelope } from '../models/ItemGoogleCategoryDtoEnvelope';
+import type { ItemGoogleCategoryDtoListEnvelope } from '../models/ItemGoogleCategoryDtoListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemGoogleCategoriesService {
+    /**
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategories(
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategoriesCount(
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategoriesAll(
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/All',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategoriesPrimary(
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/Primary',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemCategoryId
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategories1(
+        itemCategoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/{itemCategoryId}',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemCategoryId
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategoriesChildren(
+        itemCategoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/{itemCategoryId}/Children',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemGoogleCategoriesTree(
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/tree',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns ItemGoogleCategoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemGoogleCategoriesTree(
+        xApiVersion?: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemGoogleCategories/tree',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemImagesService.ts

@@ -12,17 +12,22 @@ import { request as __request } from '../core/request';
 export class ItemImagesService {
     /**
      * @param tenantId
+     * @param xApiVersion
      * @param requestBody
      * @returns ItemImageDtoEnvelope Created
      * @throws ApiError
      */
-    public static postApiV2CatalogServiceItemImagesCreate(
+    public static postApiV2CatalogServiceItemImages(
         tenantId: string,
+        xApiVersion?: string,
         requestBody?: ItemImageCreateDto,
     ): CancelablePromise<ItemImageDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/CatalogService/ItemImages/Create',
+            url: '/api/v2/CatalogService/ItemImages',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -35,18 +40,29 @@ export class ItemImagesService {
         });
     }
     /**
-     * @param itemImageId
-     * @returns ItemImageDtoEnvelope Success
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns ItemImageDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemImagesDetails(
-        itemImageId: string,
-    ): CancelablePromise<ItemImageDtoEnvelope> {
+    public static getApiV2CatalogServiceItemImages(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemImageDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemImages/Details/{itemImageId}',
-            path: {
-                'itemImageId': itemImageId,
+            url: '/api/v2/CatalogService/ItemImages',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
             },
             errors: {
                 401: `Unauthorized`,
@@ -55,24 +71,23 @@ export class ItemImagesService {
         });
     }
     /**
-     * @param tenantId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemImageDtoListEnvelope Success
+     * @param itemImageId
+     * @param xApiVersion
+     * @returns ItemImageDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemImagesList(
-        tenantId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemImageDtoListEnvelope> {
+    public static getApiV2CatalogServiceItemImages1(
+        itemImageId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemImageDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemImages/List',
-            query: {
-                'tenantId': tenantId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
+            url: '/api/v2/CatalogService/ItemImages/{itemImageId}',
+            path: {
+                'itemImageId': itemImageId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             errors: {
                 401: `Unauthorized`,
@@ -83,21 +98,26 @@ export class ItemImagesService {
     /**
      * @param tenantId
      * @param itemImageId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns any OK
      * @throws ApiError
      */
-    public static putApiV2CatalogServiceItemImagesUpdate(
+    public static putApiV2CatalogServiceItemImages(
         tenantId: string,
         itemImageId: string,
+        xApiVersion?: string,
         requestBody?: ItemImageUpdateDto,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'PUT',
-            url: '/api/v2/CatalogService/ItemImages/Update/{itemImageId}',
+            url: '/api/v2/CatalogService/ItemImages/{itemImageId}',
             path: {
                 'itemImageId': itemImageId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -112,19 +132,24 @@ export class ItemImagesService {
     /**
      * @param tenantId
      * @param itemImageId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static deleteApiV2CatalogServiceItemImagesDelete(
+    public static deleteApiV2CatalogServiceItemImages(
         tenantId: string,
         itemImageId: string,
+        xApiVersion?: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemImages/Delete/{itemImageId}',
+            url: '/api/v2/CatalogService/ItemImages/{itemImageId}',
             path: {
                 'itemImageId': itemImageId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },

package/clients/catalogService/services/ItemQuestionsService.ts

@@ -12,17 +12,22 @@ import { request as __request } from '../core/request';
 export class ItemQuestionsService {
     /**
      * @param tenantId
+     * @param xApiVersion
      * @param requestBody
      * @returns ItemQuestionDtoEnvelope Created
      * @throws ApiError
      */
-    public static postApiV2CatalogServiceItemQuestionsCreate(
+    public static postApiV2CatalogServiceItemQuestions(
         tenantId: string,
+        xApiVersion?: string,
         requestBody?: ItemQuestionCreateDto,
     ): CancelablePromise<ItemQuestionDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/CatalogService/ItemQuestions/Create',
+            url: '/api/v2/CatalogService/ItemQuestions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -35,18 +40,29 @@ export class ItemQuestionsService {
         });
     }
     /**
-     * @param itemQuestionId
-     * @returns ItemQuestionDtoEnvelope Success
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns ItemQuestionDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemQuestionsDetails(
-        itemQuestionId: string,
-    ): CancelablePromise<ItemQuestionDtoEnvelope> {
+    public static getApiV2CatalogServiceItemQuestions(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemQuestionDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemQuestions/Details/{itemQuestionId}',
-            path: {
-                'itemQuestionId': itemQuestionId,
+            url: '/api/v2/CatalogService/ItemQuestions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
             },
             errors: {
                 401: `Unauthorized`,
@@ -55,24 +71,23 @@ export class ItemQuestionsService {
         });
     }
     /**
-     * @param tenantId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemQuestionDtoListEnvelope Success
+     * @param itemQuestionId
+     * @param xApiVersion
+     * @returns ItemQuestionDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CatalogServiceItemQuestionsList(
-        tenantId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemQuestionDtoListEnvelope> {
+    public static getApiV2CatalogServiceItemQuestions1(
+        itemQuestionId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemQuestionDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CatalogService/ItemQuestions/List',
-            query: {
-                'tenantId': tenantId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
+            url: '/api/v2/CatalogService/ItemQuestions/{itemQuestionId}',
+            path: {
+                'itemQuestionId': itemQuestionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             errors: {
                 401: `Unauthorized`,
@@ -83,19 +98,24 @@ export class ItemQuestionsService {
     /**
      * @param tenantId
      * @param itemQuestionId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static deleteApiV2CatalogServiceItemQuestionsDelete(
+    public static deleteApiV2CatalogServiceItemQuestions(
         tenantId: string,
         itemQuestionId: string,
+        xApiVersion?: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemQuestions/Delete/{itemQuestionId}',
+            url: '/api/v2/CatalogService/ItemQuestions/{itemQuestionId}',
             path: {
                 'itemQuestionId': itemQuestionId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -108,21 +128,26 @@ export class ItemQuestionsService {
     /**
      * @param tenantId
      * @param itemQuestionId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns any OK
      * @throws ApiError
      */
-    public static putApiV2CatalogServiceItemQuestionsUpdate(
+    public static putApiV2CatalogServiceItemQuestions(
         tenantId: string,
         itemQuestionId: string,
+        xApiVersion?: string,
         requestBody?: ItemQuestionUpdateDto,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'PUT',
-            url: '/api/v2/CatalogService/ItemQuestions/Update/{itemQuestionId}',
+            url: '/api/v2/CatalogService/ItemQuestions/{itemQuestionId}',
             path: {
                 'itemQuestionId': itemQuestionId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },