@fenixalliance/abs-api-client 1.0.0

package/clients/catalogService/services/ItemCategoriesService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemCategoryCreateDto } from '../models/ItemCategoryCreateDto';
+import type { ItemCategoryDtoEnvelope } from '../models/ItemCategoryDtoEnvelope';
+import type { ItemCategoryDtoIReadOnlyCollectionEnvelope } from '../models/ItemCategoryDtoIReadOnlyCollectionEnvelope';
+import type { ItemCategoryUpdateDto } from '../models/ItemCategoryUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemCategoriesService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemCategoryDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemCategoriesCreate(
+        businessId: string,
+        requestBody?: ItemCategoryCreateDto,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemCategories/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemCategoryId
+     * @returns ItemCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemCategoriesDetails(
+        itemCategoryId: string,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemCategories/Details/{itemCategoryId}',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemCategoryDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemCategoriesList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemCategoryDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemCategories/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemCategoryId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemCategoriesUpdate(
+        itemCategoryId: string,
+        requestBody?: ItemCategoryUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemCategories/Update/{itemCategoryId}',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemCategoryId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemCategoriesDelete(
+        itemCategoryId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemCategories/Delete/{itemCategoryId}',
+            path: {
+                'itemCategoryId': itemCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemImagesService.ts

@@ -0,0 +1,127 @@
+/* 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`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemQuestionsService.ts

@@ -0,0 +1,127 @@
+/* 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`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemReviewsService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemReviewCreateDto } from '../models/ItemReviewCreateDto';
+import type { ItemReviewDtoEnvelope } from '../models/ItemReviewDtoEnvelope';
+import type { ItemReviewDtoIReadOnlyCollectionEnvelope } from '../models/ItemReviewDtoIReadOnlyCollectionEnvelope';
+import type { ItemReviewUpdateDto } from '../models/ItemReviewUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemReviewsService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemReviewDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemReviewsCreate(
+        businessId: string,
+        requestBody?: ItemReviewCreateDto,
+    ): CancelablePromise<ItemReviewDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemReviews/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemReviewId
+     * @returns ItemReviewDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemReviewsDetails(
+        itemReviewId: string,
+    ): CancelablePromise<ItemReviewDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemReviews/Details/{itemReviewId}',
+            path: {
+                'itemReviewId': itemReviewId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemReviewDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemReviewsItemReviews(
+        itemId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemReviewDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemReviews/ItemReviews',
+            query: {
+                'itemId': itemId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemReviewId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemReviewsUpdate(
+        itemReviewId: string,
+        requestBody?: ItemReviewUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemReviews/Update/{itemReviewId}',
+            path: {
+                'itemReviewId': itemReviewId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemReviewId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemReviewsDelete(
+        itemReviewId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemReviews/Delete/{itemReviewId}',
+            path: {
+                'itemReviewId': itemReviewId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemTagsService.ts

@@ -0,0 +1,132 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemTagCreateDto } from '../models/ItemTagCreateDto';
+import type { ItemTagDtoEnvelope } from '../models/ItemTagDtoEnvelope';
+import type { ItemTagDtoIReadOnlyCollectionEnvelope } from '../models/ItemTagDtoIReadOnlyCollectionEnvelope';
+import type { ItemTagUpdateDto } from '../models/ItemTagUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemTagsService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemTagDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemTagsCreate(
+        businessId: string,
+        requestBody?: ItemTagCreateDto,
+    ): CancelablePromise<ItemTagDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemTags/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemTagId
+     * @returns ItemTagDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemTagsDetails(
+        itemTagId: string,
+    ): CancelablePromise<ItemTagDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemTags/Details/{itemTagId}',
+            path: {
+                'itemTagId': itemTagId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemTagDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemTagsList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemTagDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemTags/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemTagId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemTagsDelete(
+        itemTagId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemTags/Delete/{itemTagId}',
+            path: {
+                'itemTagId': itemTagId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param itemTagId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemTagsUpdate(
+        businessId: string,
+        itemTagId: string,
+        requestBody?: ItemTagUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemTags/Update/{itemTagId}',
+            path: {
+                'itemTagId': itemTagId,
+            },
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}