@fenixalliance/abs-api-client 1.0.1 → 2.0.0

package/clients/catalogService/services/ItemImagesService.ts

@@ -1,127 +1,137 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { ItemImageDtoEnvelope } from '../models/ItemImageDtoEnvelope';
-import type { ItemImageDtoIReadOnlyCollectionEnvelope } from '../models/ItemImageDtoIReadOnlyCollectionEnvelope';
-import type { ItemImagesCreateDto } from '../models/ItemImagesCreateDto';
-import type { ItemImagesUpdateDto } from '../models/ItemImagesUpdateDto';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class ItemImagesService {
-    /**
-     * @param businessId
-     * @param requestBody
-     * @returns ItemImageDtoEnvelope Created
-     * @throws ApiError
-     */
-    public static postApiV2CatalogServiceItemImagesCreate(
-        businessId: string,
-        requestBody?: ItemImagesCreateDto,
-    ): CancelablePromise<ItemImageDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/ItemImages/Create',
-            query: {
-                'businessId': businessId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param itemImageId
-     * @returns ItemImageDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceItemImagesDetails(
-        itemImageId: string,
-    ): CancelablePromise<ItemImageDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/ItemImages/Details/{itemImageId}',
-            path: {
-                'itemImageId': itemImageId,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemImageDtoIReadOnlyCollectionEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceItemImagesList(
-        businessId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemImageDtoIReadOnlyCollectionEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/ItemImages/List',
-            query: {
-                'businessId': businessId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param itemImageId
-     * @param requestBody
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static putApiV2CatalogServiceItemImagesUpdate(
-        itemImageId: string,
-        requestBody?: ItemImagesUpdateDto,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/api/v2/CatalogService/ItemImages/Update/{itemImageId}',
-            path: {
-                'itemImageId': itemImageId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param itemImageId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static deleteApiV2CatalogServiceItemImagesDelete(
-        itemImageId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemImages/Delete/{itemImageId}',
-            path: {
-                'itemImageId': itemImageId,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemImageCreateDto } from '../models/ItemImageCreateDto';
+import type { ItemImageDtoEnvelope } from '../models/ItemImageDtoEnvelope';
+import type { ItemImageDtoListEnvelope } from '../models/ItemImageDtoListEnvelope';
+import type { ItemImageUpdateDto } from '../models/ItemImageUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemImagesService {
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns ItemImageDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemImagesCreate(
+        tenantId: string,
+        requestBody?: ItemImageCreateDto,
+    ): CancelablePromise<ItemImageDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemImages/Create',
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemImageId
+     * @returns ItemImageDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemImagesDetails(
+        itemImageId: string,
+    ): CancelablePromise<ItemImageDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemImages/Details/{itemImageId}',
+            path: {
+                'itemImageId': itemImageId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemImageDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemImagesList(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemImageDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemImages/List',
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param itemImageId
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemImagesUpdate(
+        tenantId: string,
+        itemImageId: string,
+        requestBody?: ItemImageUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemImages/Update/{itemImageId}',
+            path: {
+                'itemImageId': itemImageId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param itemImageId
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemImagesDelete(
+        tenantId: string,
+        itemImageId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemImages/Delete/{itemImageId}',
+            path: {
+                'itemImageId': itemImageId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemQuestionsService.ts

@@ -1,127 +1,137 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { ItemQuestionCreateDto } from '../models/ItemQuestionCreateDto';
-import type { ItemQuestionDtoEnvelope } from '../models/ItemQuestionDtoEnvelope';
-import type { ItemQuestionDtoIReadOnlyCollectionEnvelope } from '../models/ItemQuestionDtoIReadOnlyCollectionEnvelope';
-import type { ItemQuestionUpdateDto } from '../models/ItemQuestionUpdateDto';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class ItemQuestionsService {
-    /**
-     * @param businessId
-     * @param requestBody
-     * @returns ItemQuestionDtoEnvelope Created
-     * @throws ApiError
-     */
-    public static postApiV2CatalogServiceItemQuestionsCreate(
-        businessId: string,
-        requestBody?: ItemQuestionCreateDto,
-    ): CancelablePromise<ItemQuestionDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/ItemQuestions/Create',
-            query: {
-                'businessId': businessId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param itemQuestionId
-     * @returns ItemQuestionDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceItemQuestionsDetails(
-        itemQuestionId: string,
-    ): CancelablePromise<ItemQuestionDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/ItemQuestions/Details/{itemQuestionId}',
-            path: {
-                'itemQuestionId': itemQuestionId,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemQuestionDtoIReadOnlyCollectionEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceItemQuestionsList(
-        businessId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemQuestionDtoIReadOnlyCollectionEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/ItemQuestions/List',
-            query: {
-                'businessId': businessId,
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param itemQuestionId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static deleteApiV2CatalogServiceItemQuestionsDelete(
-        itemQuestionId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/api/v2/CatalogService/ItemQuestions/Delete/{itemQuestionId}',
-            path: {
-                'itemQuestionId': itemQuestionId,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param itemQuestionId
-     * @param requestBody
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static putApiV2CatalogServiceItemQuestionsUpdate(
-        itemQuestionId: string,
-        requestBody?: ItemQuestionUpdateDto,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/api/v2/CatalogService/ItemQuestions/Update/{itemQuestionId}',
-            path: {
-                'itemQuestionId': itemQuestionId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemQuestionCreateDto } from '../models/ItemQuestionCreateDto';
+import type { ItemQuestionDtoEnvelope } from '../models/ItemQuestionDtoEnvelope';
+import type { ItemQuestionDtoListEnvelope } from '../models/ItemQuestionDtoListEnvelope';
+import type { ItemQuestionUpdateDto } from '../models/ItemQuestionUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemQuestionsService {
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns ItemQuestionDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemQuestionsCreate(
+        tenantId: string,
+        requestBody?: ItemQuestionCreateDto,
+    ): CancelablePromise<ItemQuestionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemQuestions/Create',
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemQuestionId
+     * @returns ItemQuestionDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemQuestionsDetails(
+        itemQuestionId: string,
+    ): CancelablePromise<ItemQuestionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemQuestions/Details/{itemQuestionId}',
+            path: {
+                'itemQuestionId': itemQuestionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemQuestionDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemQuestionsList(
+        tenantId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemQuestionDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemQuestions/List',
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param itemQuestionId
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemQuestionsDelete(
+        tenantId: string,
+        itemQuestionId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemQuestions/Delete/{itemQuestionId}',
+            path: {
+                'itemQuestionId': itemQuestionId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param itemQuestionId
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemQuestionsUpdate(
+        tenantId: string,
+        itemQuestionId: string,
+        requestBody?: ItemQuestionUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemQuestions/Update/{itemQuestionId}',
+            path: {
+                'itemQuestionId': itemQuestionId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}