@fenixalliance/abs-api-client 1.0.0

package/clients/catalogService/services/ProductsService.ts

@@ -0,0 +1,1743 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemAttachmentDtoEnvelope } from '../models/ItemAttachmentDtoEnvelope';
+import type { ItemAttachmentDtoListEnvelope } from '../models/ItemAttachmentDtoListEnvelope';
+import type { ItemAttributeOptionDtoEnvelope } from '../models/ItemAttributeOptionDtoEnvelope';
+import type { ItemAttributeOptionDtoListEnvelope } from '../models/ItemAttributeOptionDtoListEnvelope';
+import type { ItemBrandDtoEnvelope } from '../models/ItemBrandDtoEnvelope';
+import type { ItemBrandDtoListEnvelope } from '../models/ItemBrandDtoListEnvelope';
+import type { ItemCategoryDtoEnvelope } from '../models/ItemCategoryDtoEnvelope';
+import type { ItemCategoryDtoListEnvelope } from '../models/ItemCategoryDtoListEnvelope';
+import type { ItemGoogleCategoryDtoEnvelope } from '../models/ItemGoogleCategoryDtoEnvelope';
+import type { ItemGoogleCategoryDtoListEnvelope } from '../models/ItemGoogleCategoryDtoListEnvelope';
+import type { ItemImageDtoEnvelope } from '../models/ItemImageDtoEnvelope';
+import type { ItemImageDtoListEnvelope } from '../models/ItemImageDtoListEnvelope';
+import type { ItemPricePolicyDtoEnvelope } from '../models/ItemPricePolicyDtoEnvelope';
+import type { ItemPricePolicyDtoListEnvelope } from '../models/ItemPricePolicyDtoListEnvelope';
+import type { ItemQuestionDtoEnvelope } from '../models/ItemQuestionDtoEnvelope';
+import type { ItemQuestionDtoListEnvelope } from '../models/ItemQuestionDtoListEnvelope';
+import type { ItemRefundPolicyDtoEnvelope } from '../models/ItemRefundPolicyDtoEnvelope';
+import type { ItemRefundPolicyDtoListEnvelope } from '../models/ItemRefundPolicyDtoListEnvelope';
+import type { ItemReturnPolicyDtoEnvelope } from '../models/ItemReturnPolicyDtoEnvelope';
+import type { ItemReturnPolicyDtoListEnvelope } from '../models/ItemReturnPolicyDtoListEnvelope';
+import type { ItemReviewDtoEnvelope } from '../models/ItemReviewDtoEnvelope';
+import type { ItemReviewDtoListEnvelope } from '../models/ItemReviewDtoListEnvelope';
+import type { ItemShippingPolicyDtoEnvelope } from '../models/ItemShippingPolicyDtoEnvelope';
+import type { ItemShippingPolicyDtoListEnvelope } from '../models/ItemShippingPolicyDtoListEnvelope';
+import type { ItemTagDtoEnvelope } from '../models/ItemTagDtoEnvelope';
+import type { ItemTagDtoListEnvelope } from '../models/ItemTagDtoListEnvelope';
+import type { ItemTaxPolicyDtoEnvelope } from '../models/ItemTaxPolicyDtoEnvelope';
+import type { ItemTaxPolicyDtoListEnvelope } from '../models/ItemTaxPolicyDtoListEnvelope';
+import type { ItemTypeDtoEnvelope } from '../models/ItemTypeDtoEnvelope';
+import type { ItemTypeDtoListEnvelope } from '../models/ItemTypeDtoListEnvelope';
+import type { ItemWarrantyPolicyDtoEnvelope } from '../models/ItemWarrantyPolicyDtoEnvelope';
+import type { ItemWarrantyPolicyDtoListEnvelope } from '../models/ItemWarrantyPolicyDtoListEnvelope';
+import type { PricingRuleDtoEnvelope } from '../models/PricingRuleDtoEnvelope';
+import type { PricingRuleDtoListEnvelope } from '../models/PricingRuleDtoListEnvelope';
+import type { StockItemCreateDto } from '../models/StockItemCreateDto';
+import type { StockItemDtoEnvelope } from '../models/StockItemDtoEnvelope';
+import type { StockItemDtoListEnvelope } from '../models/StockItemDtoListEnvelope';
+import type { StockItemUpdateDto } from '../models/StockItemUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ProductsService {
+    /**
+     * @param pageNumber
+     * @param pageSize
+     * @returns StockItemDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProducts(
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<StockItemDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products',
+            query: {
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @returns StockItemDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsCount(): CancelablePromise<StockItemDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/Count',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns StockItemDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsByBusiness(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<StockItemDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/ByBusiness/{businessId}',
+            path: {
+                'businessId': businessId,
+            },
+            query: {
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns StockItemDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsByBusinessCount(
+        businessId: string,
+    ): CancelablePromise<StockItemDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/ByBusiness/{businessId}/Count',
+            path: {
+                'businessId': businessId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns StockItemDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsDetails(
+        stockItemId: string,
+    ): CancelablePromise<StockItemDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Details',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsCreate(
+        businessId: string,
+        requestBody?: StockItemCreateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param stockItemId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceProductsUpdate(
+        businessId: string,
+        stockItemId: string,
+        requestBody?: StockItemUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/Products/Update/{stockItemId}',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param stockItemId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsDelete(
+        businessId: string,
+        stockItemId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/Delete/{stockItemId}',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            query: {
+                'businessId': businessId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemImageDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsImages(
+        stockItemId: string,
+    ): CancelablePromise<ItemImageDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Images',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemImageId
+     * @returns ItemImageDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsImages1(
+        stockItemId: string,
+        itemImageId: string,
+    ): CancelablePromise<ItemImageDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Images/{itemImageId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemImageId': itemImageId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemImageId
+     * @returns ItemImageDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsImages(
+        stockItemId: string,
+        itemImageId: string,
+    ): CancelablePromise<ItemImageDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Images/{itemImageId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemImageId': itemImageId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemImageId
+     * @returns ItemImageDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsImages(
+        stockItemId: string,
+        itemImageId: string,
+    ): CancelablePromise<ItemImageDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Images/{itemImageId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemImageId': itemImageId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemBrandDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsBrands(
+        stockItemId: string,
+    ): CancelablePromise<ItemBrandDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Brands',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemBrandId
+     * @returns ItemBrandDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsBrands1(
+        stockItemId: string,
+        itemBrandId: string,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Brands/{itemBrandId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemBrandId': itemBrandId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemBrandId
+     * @returns ItemBrandDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsBrands(
+        stockItemId: string,
+        itemBrandId: string,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Brands/{itemBrandId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemBrandId': itemBrandId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemBrandId
+     * @returns ItemBrandDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsBrands(
+        stockItemId: string,
+        itemBrandId: string,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Brands/{itemBrandId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemBrandId': itemBrandId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemTypeDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsTypes(
+        stockItemId: string,
+    ): CancelablePromise<ItemTypeDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Types',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTypeId
+     * @returns ItemTypeDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsTypes1(
+        stockItemId: string,
+        itemTypeId: string,
+    ): CancelablePromise<ItemTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Types/{itemTypeId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTypeId': itemTypeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTypeId
+     * @returns ItemTypeDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsTypes(
+        stockItemId: string,
+        itemTypeId: string,
+    ): CancelablePromise<ItemTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Types/{itemTypeId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTypeId': itemTypeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTypeId
+     * @returns ItemTypeDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsTypes(
+        stockItemId: string,
+        itemTypeId: string,
+    ): CancelablePromise<ItemTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Types/{itemTypeId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTypeId': itemTypeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemTagDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsTags(
+        stockItemId: string,
+    ): CancelablePromise<ItemTagDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Tags',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTagId
+     * @returns ItemTagDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsTags1(
+        stockItemId: string,
+        itemTagId: string,
+    ): CancelablePromise<ItemTagDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Tags/{itemTagId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTagId': itemTagId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTagId
+     * @returns ItemTagDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsTags(
+        stockItemId: string,
+        itemTagId: string,
+    ): CancelablePromise<ItemTagDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Tags/{itemTagId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTagId': itemTagId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTagId
+     * @returns ItemTagDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsTags(
+        stockItemId: string,
+        itemTagId: string,
+    ): CancelablePromise<ItemTagDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Tags/{itemTagId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTagId': itemTagId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemReviewDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsReviews(
+        stockItemId: string,
+    ): CancelablePromise<ItemReviewDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Reviews',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemReviewId
+     * @returns ItemReviewDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsReviews1(
+        stockItemId: string,
+        itemReviewId: string,
+    ): CancelablePromise<ItemReviewDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Reviews/{itemReviewId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemReviewId': itemReviewId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemReviewId
+     * @returns ItemReviewDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsReviews(
+        stockItemId: string,
+        itemReviewId: string,
+    ): CancelablePromise<ItemReviewDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Reviews/{itemReviewId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemReviewId': itemReviewId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemReviewId
+     * @returns ItemReviewDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsReviews(
+        stockItemId: string,
+        itemReviewId: string,
+    ): CancelablePromise<ItemReviewDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Reviews/{itemReviewId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemReviewId': itemReviewId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemQuestionDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsQuestions(
+        stockItemId: string,
+    ): CancelablePromise<ItemQuestionDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Questions',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemQuestionId
+     * @returns ItemQuestionDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsQuestions1(
+        stockItemId: string,
+        itemQuestionId: string,
+    ): CancelablePromise<ItemQuestionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Questions/{itemQuestionId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemQuestionId': itemQuestionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemQuestionId
+     * @returns ItemQuestionDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsQuestions(
+        stockItemId: string,
+        itemQuestionId: string,
+    ): CancelablePromise<ItemQuestionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Questions/{itemQuestionId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemQuestionId': itemQuestionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemQuestionId
+     * @returns ItemQuestionDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsQuestions(
+        stockItemId: string,
+        itemQuestionId: string,
+    ): CancelablePromise<ItemQuestionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Questions/{itemQuestionId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemQuestionId': itemQuestionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemCategoryDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsCategories(
+        stockItemId: string,
+    ): CancelablePromise<ItemCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Categories',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemCategoryId
+     * @returns ItemCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsCategories1(
+        stockItemId: string,
+        itemCategoryId: string,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Categories/{itemCategoryId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemCategoryId': itemCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemCategoryId
+     * @returns ItemCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsCategories(
+        stockItemId: string,
+        itemCategoryId: string,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Categories/{itemCategoryId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemCategoryId': itemCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemCategoryId
+     * @returns ItemCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsCategories(
+        stockItemId: string,
+        itemCategoryId: string,
+    ): CancelablePromise<ItemCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Categories/{itemCategoryId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemCategoryId': itemCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemAttachmentDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsAttachments(
+        stockItemId: string,
+    ): CancelablePromise<ItemAttachmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Attachments',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemAttachmentId
+     * @returns ItemAttachmentDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsAttachments1(
+        stockItemId: string,
+        itemAttachmentId: string,
+    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Attachments/{itemAttachmentId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemAttachmentId': itemAttachmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemAttachmentId
+     * @returns ItemAttachmentDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsAttachments(
+        stockItemId: string,
+        itemAttachmentId: string,
+    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Attachments/{itemAttachmentId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemAttachmentId': itemAttachmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemAttachmentId
+     * @returns ItemAttachmentDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsAttachments(
+        stockItemId: string,
+        itemAttachmentId: string,
+    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/Attachments/{itemAttachmentId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemAttachmentId': itemAttachmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemGoogleCategoryDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsGoogleCategories(
+        stockItemId: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/GoogleCategories',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemGoogleCategoryId
+     * @returns ItemGoogleCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsGoogleCategories1(
+        stockItemId: string,
+        itemGoogleCategoryId: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/GoogleCategories/{itemGoogleCategoryId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemGoogleCategoryId': itemGoogleCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemGoogleCategoryId
+     * @returns ItemGoogleCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsGoogleCategories(
+        stockItemId: string,
+        itemGoogleCategoryId: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/GoogleCategories/{itemGoogleCategoryId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemGoogleCategoryId': itemGoogleCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemGoogleCategoryId
+     * @returns ItemGoogleCategoryDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsGoogleCategories(
+        stockItemId: string,
+        itemGoogleCategoryId: string,
+    ): CancelablePromise<ItemGoogleCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/GoogleCategories/{itemGoogleCategoryId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemGoogleCategoryId': itemGoogleCategoryId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemAttributeOptionDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsAttributeOptions(
+        stockItemId: string,
+    ): CancelablePromise<ItemAttributeOptionDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/AttributeOptions',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemAttributeOptionId
+     * @returns ItemAttributeOptionDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsAttributeOptions1(
+        stockItemId: string,
+        itemAttributeOptionId: string,
+    ): CancelablePromise<ItemAttributeOptionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/AttributeOptions/{itemAttributeOptionId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemAttributeOptionId': itemAttributeOptionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemAttributeOptionId
+     * @returns ItemAttributeOptionDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsAttributeOptions(
+        stockItemId: string,
+        itemAttributeOptionId: string,
+    ): CancelablePromise<ItemAttributeOptionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/AttributeOptions/{itemAttributeOptionId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemAttributeOptionId': itemAttributeOptionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemAttributeOptionId
+     * @returns ItemAttributeOptionDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsAttributeOptions(
+        stockItemId: string,
+        itemAttributeOptionId: string,
+    ): CancelablePromise<ItemAttributeOptionDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/AttributeOptions/{itemAttributeOptionId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemAttributeOptionId': itemAttributeOptionId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemTaxPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsTaxPolicies(
+        stockItemId: string,
+    ): CancelablePromise<ItemTaxPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/TaxPolicies',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTaxPolicyId
+     * @returns ItemTaxPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsTaxPolicies1(
+        stockItemId: string,
+        itemTaxPolicyId: string,
+    ): CancelablePromise<ItemTaxPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/TaxPolicies/{itemTaxPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTaxPolicyId': itemTaxPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTaxPolicyId
+     * @returns ItemTaxPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsTaxPolicies(
+        stockItemId: string,
+        itemTaxPolicyId: string,
+    ): CancelablePromise<ItemTaxPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/TaxPolicies/{itemTaxPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTaxPolicyId': itemTaxPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemTaxPolicyId
+     * @returns ItemTaxPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsTaxPolicies(
+        stockItemId: string,
+        itemTaxPolicyId: string,
+    ): CancelablePromise<ItemTaxPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/TaxPolicies/{itemTaxPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemTaxPolicyId': itemTaxPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns PricingRuleDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsPriceRules(
+        stockItemId: string,
+    ): CancelablePromise<PricingRuleDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PriceRules',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemPriceRuleId
+     * @returns PricingRuleDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsPriceRules1(
+        stockItemId: string,
+        itemPriceRuleId: string,
+    ): CancelablePromise<PricingRuleDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PriceRules/{itemPriceRuleId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemPriceRuleId': itemPriceRuleId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemPriceRuleId
+     * @returns PricingRuleDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsPriceRules(
+        stockItemId: string,
+        itemPriceRuleId: string,
+    ): CancelablePromise<PricingRuleDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PriceRules/{itemPriceRuleId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemPriceRuleId': itemPriceRuleId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemPriceRuleId
+     * @returns PricingRuleDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsPriceRules(
+        stockItemId: string,
+        itemPriceRuleId: string,
+    ): CancelablePromise<PricingRuleDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PriceRules/{itemPriceRuleId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemPriceRuleId': itemPriceRuleId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemPricePolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsPricePolicies(
+        stockItemId: string,
+    ): CancelablePromise<ItemPricePolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PricePolicies',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemPricePolicyId
+     * @returns ItemPricePolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsPricePolicies1(
+        stockItemId: string,
+        itemPricePolicyId: string,
+    ): CancelablePromise<ItemPricePolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PricePolicies/{itemPricePolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemPricePolicyId': itemPricePolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemPricePolicyId
+     * @returns ItemPricePolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsPricePolicies(
+        stockItemId: string,
+        itemPricePolicyId: string,
+    ): CancelablePromise<ItemPricePolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PricePolicies/{itemPricePolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemPricePolicyId': itemPricePolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemPricePolicyId
+     * @returns ItemPricePolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsPricePolicies(
+        stockItemId: string,
+        itemPricePolicyId: string,
+    ): CancelablePromise<ItemPricePolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/PricePolicies/{itemPricePolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemPricePolicyId': itemPricePolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemWarrantyPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsWarrantyPolicies(
+        stockItemId: string,
+    ): CancelablePromise<ItemWarrantyPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/WarrantyPolicies',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemWarrantyPolicyId
+     * @returns ItemWarrantyPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsWarrantyPolicies1(
+        stockItemId: string,
+        itemWarrantyPolicyId: string,
+    ): CancelablePromise<ItemWarrantyPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/WarrantyPolicies/{itemWarrantyPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemWarrantyPolicyId': itemWarrantyPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemWarrantyPolicyId
+     * @returns ItemWarrantyPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsWarrantyPolicies(
+        stockItemId: string,
+        itemWarrantyPolicyId: string,
+    ): CancelablePromise<ItemWarrantyPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/WarrantyPolicies/{itemWarrantyPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemWarrantyPolicyId': itemWarrantyPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemWarrantyPolicyId
+     * @returns ItemWarrantyPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsWarrantyPolicies(
+        stockItemId: string,
+        itemWarrantyPolicyId: string,
+    ): CancelablePromise<ItemWarrantyPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/WarrantyPolicies/{itemWarrantyPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemWarrantyPolicyId': itemWarrantyPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemReturnPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsReturnPolicies(
+        stockItemId: string,
+    ): CancelablePromise<ItemReturnPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ReturnPolicies',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemReturnPolicyId
+     * @returns ItemReturnPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsReturnPolicies1(
+        stockItemId: string,
+        itemReturnPolicyId: string,
+    ): CancelablePromise<ItemReturnPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ReturnPolicies/{itemReturnPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemReturnPolicyId': itemReturnPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemReturnPolicyId
+     * @returns ItemReturnPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsReturnPolicies(
+        stockItemId: string,
+        itemReturnPolicyId: string,
+    ): CancelablePromise<ItemReturnPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ReturnPolicies/{itemReturnPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemReturnPolicyId': itemReturnPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemReturnPolicyId
+     * @returns ItemReturnPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsReturnPolicies(
+        stockItemId: string,
+        itemReturnPolicyId: string,
+    ): CancelablePromise<ItemReturnPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ReturnPolicies/{itemReturnPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemReturnPolicyId': itemReturnPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemRefundPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsRefundPolicies(
+        stockItemId: string,
+    ): CancelablePromise<ItemRefundPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/RefundPolicies',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemRefundPolicyId
+     * @returns ItemRefundPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsRefundPolicies1(
+        stockItemId: string,
+        itemRefundPolicyId: string,
+    ): CancelablePromise<ItemRefundPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/RefundPolicies/{itemRefundPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemRefundPolicyId': itemRefundPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemRefundPolicyId
+     * @returns ItemRefundPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsRefundPolicies(
+        stockItemId: string,
+        itemRefundPolicyId: string,
+    ): CancelablePromise<ItemRefundPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/RefundPolicies/{itemRefundPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemRefundPolicyId': itemRefundPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemRefundPolicyId
+     * @returns ItemRefundPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsRefundPolicies(
+        stockItemId: string,
+        itemRefundPolicyId: string,
+    ): CancelablePromise<ItemRefundPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/RefundPolicies/{itemRefundPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemRefundPolicyId': itemRefundPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @returns ItemShippingPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsShippingPolicies(
+        stockItemId: string,
+    ): CancelablePromise<ItemShippingPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ShippingPolicies',
+            path: {
+                'stockItemId': stockItemId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemShippingPolicyId
+     * @returns ItemShippingPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceProductsShippingPolicies1(
+        stockItemId: string,
+        itemShippingPolicyId: string,
+    ): CancelablePromise<ItemShippingPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ShippingPolicies/{itemShippingPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemShippingPolicyId': itemShippingPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemShippingPolicyId
+     * @returns ItemShippingPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceProductsShippingPolicies(
+        stockItemId: string,
+        itemShippingPolicyId: string,
+    ): CancelablePromise<ItemShippingPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ShippingPolicies/{itemShippingPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemShippingPolicyId': itemShippingPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param stockItemId
+     * @param itemShippingPolicyId
+     * @returns ItemShippingPolicyDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceProductsShippingPolicies(
+        stockItemId: string,
+        itemShippingPolicyId: string,
+    ): CancelablePromise<ItemShippingPolicyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/Products/{stockItemId}/ShippingPolicies/{itemShippingPolicyId}',
+            path: {
+                'stockItemId': stockItemId,
+                'itemShippingPolicyId': itemShippingPolicyId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}