@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/catalogService/services/ProductsService.ts

@@ -1,1706 +0,0 @@
-/* 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 { ItemQuestionDtoEnvelope } from '../models/ItemQuestionDtoEnvelope';
-import type { ItemQuestionDtoListEnvelope } from '../models/ItemQuestionDtoListEnvelope';
-import type { ItemQuestionRecordCreateDto } from '../models/ItemQuestionRecordCreateDto';
-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 { ItemReviewRecordCreateDto } from '../models/ItemReviewRecordCreateDto';
-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 tenantId
-     * @param pageNumber
-     * @param pageSize
-     * @returns StockItemDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceProductsByBusiness(
-        tenantId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<StockItemDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/Products/ByBusiness/{tenantId}',
-            path: {
-                'tenantId': tenantId,
-            },
-            query: {
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param tenantId
-     * @returns StockItemDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceProductsByBusinessCount(
-        tenantId: string,
-    ): CancelablePromise<StockItemDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/Products/ByBusiness/{tenantId}/Count',
-            path: {
-                'tenantId': tenantId,
-            },
-            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 tenantId
-     * @param requestBody
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static postApiV2CatalogServiceProductsCreate(
-        tenantId: string,
-        requestBody?: StockItemCreateDto,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/Products/Create',
-            query: {
-                'tenantId': tenantId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param tenantId
-     * @param stockItemId
-     * @param requestBody
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static putApiV2CatalogServiceProductsUpdate(
-        tenantId: string,
-        stockItemId: string,
-        requestBody?: StockItemUpdateDto,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/api/v2/CatalogService/Products/Update/{stockItemId}',
-            path: {
-                'stockItemId': stockItemId,
-            },
-            query: {
-                'tenantId': tenantId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @param tenantId
-     * @param stockItemId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static deleteApiV2CatalogServiceProductsDelete(
-        tenantId: string,
-        stockItemId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/api/v2/CatalogService/Products/Delete/{stockItemId}',
-            path: {
-                'stockItemId': stockItemId,
-            },
-            query: {
-                'tenantId': tenantId,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * Get all images related to a specific stock item
-     * @param stockItemId The stock item ID to get images for
-     * @param pageNumber
-     * @param pageSize
-     * @returns ItemImageDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2CatalogServiceProductsImages(
-        stockItemId: string,
-        pageNumber?: number,
-        pageSize?: number,
-    ): CancelablePromise<ItemImageDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/CatalogService/Products/{stockItemId}/Images',
-            path: {
-                'stockItemId': stockItemId,
-            },
-            query: {
-                'pageNumber': pageNumber,
-                'pageSize': pageSize,
-            },
-            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 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 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 requestBody
-     * @returns ItemReviewDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static postApiV2CatalogServiceProductsReviews(
-        stockItemId: string,
-        requestBody?: ItemReviewRecordCreateDto,
-    ): CancelablePromise<ItemReviewDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/Products/{stockItemId}/Reviews',
-            path: {
-                'stockItemId': stockItemId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            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 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 requestBody
-     * @returns ItemQuestionDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static postApiV2CatalogServiceProductsQuestions(
-        stockItemId: string,
-        requestBody?: ItemQuestionRecordCreateDto,
-    ): CancelablePromise<ItemQuestionDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/Products/{stockItemId}/Questions',
-            path: {
-                'stockItemId': stockItemId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            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 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 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 fileName
-     * @param itemAttachmentId
-     * @param isFolder
-     * @param title
-     * @param abstract
-     * @param author
-     * @param keyWords
-     * @param notes
-     * @param validResponse
-     * @param parentFileUploadId
-     * @param iD
-     * @param timestamp
-     * @param requestBody
-     * @returns ItemAttachmentDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static postApiV2CatalogServiceProductsAttachments(
-        stockItemId: string,
-        fileName: string,
-        itemAttachmentId: string,
-        isFolder?: boolean,
-        title?: string,
-        abstract?: string,
-        author?: string,
-        keyWords?: string,
-        notes?: string,
-        validResponse?: boolean,
-        parentFileUploadId?: string,
-        iD?: string,
-        timestamp?: string,
-        requestBody?: {
-            file?: Blob;
-        },
-    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CatalogService/Products/{stockItemId}/Attachments/{itemAttachmentId}',
-            path: {
-                'stockItemId': stockItemId,
-                'itemAttachmentId': itemAttachmentId,
-            },
-            query: {
-                'isFolder': isFolder,
-                'fileName': fileName,
-                'title': title,
-                'abstract': abstract,
-                'author': author,
-                'keyWords': keyWords,
-                'notes': notes,
-                'validResponse': validResponse,
-                'parentFileUploadID': parentFileUploadId,
-                'iD': iD,
-                'timestamp': timestamp,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            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 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`,
-            },
-        });
-    }
-}