@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/cartService/services/CartsService.ts

@@ -2,29 +2,49 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { BooleanEnvelope } from '../models/BooleanEnvelope';
 import type { CartDtoEnvelope } from '../models/CartDtoEnvelope';
 import type { CartUpdateRequest } from '../models/CartUpdateRequest';
+import type { CountryDtoEnvelope } from '../models/CountryDtoEnvelope';
 import type { CountrySwitchRequest } from '../models/CountrySwitchRequest';
+import type { CurrencyDtoEnvelope } from '../models/CurrencyDtoEnvelope';
 import type { CurrencySwitchRequest } from '../models/CurrencySwitchRequest';
 import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { ItemCartRecordDto } from '../models/ItemCartRecordDto';
+import type { ItemCartRecordDtoListEnvelope } from '../models/ItemCartRecordDtoListEnvelope';
+import type { ItemCartRecordUpdateDto } from '../models/ItemCartRecordUpdateDto';
+import type { ItemToCompareCartRecordDto } from '../models/ItemToCompareCartRecordDto';
+import type { ItemToCompareCartRecordDtoEnvelope } from '../models/ItemToCompareCartRecordDtoEnvelope';
+import type { ItemToCompareCartRecordDtoListEnvelope } from '../models/ItemToCompareCartRecordDtoListEnvelope';
+import type { NewWishListRequest } from '../models/NewWishListRequest';
+import type { ProductToWishListRequest } from '../models/ProductToWishListRequest';
+import type { WishListDto } from '../models/WishListDto';
+import type { WishListDtoEnvelope } from '../models/WishListDtoEnvelope';
+import type { WishListItemRecordDto } from '../models/WishListItemRecordDto';
+import type { WishListUpdateDto } from '../models/WishListUpdateDto';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class CartsService {
     /**
      * @param cartId
-     * @returns CartDtoEnvelope Success
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceCarts(
         cartId: string,
+        xApiVersion?: string,
     ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/CartService/Carts/{cartID}',
+            url: '/api/v2/CartService/Carts/{cartId}',
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -33,12 +53,14 @@ export class CartsService {
     }
     /**
      * @param cartId
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2CartServiceCarts(
         cartId: string,
+        xApiVersion?: string,
         requestBody?: CartUpdateRequest,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
@@ -47,6 +69,92 @@ export class CartsService {
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsCurrency(
+        cartId: string,
+        xApiVersion?: string,
+        requestBody?: CurrencySwitchRequest,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Currency',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @returns CurrencyDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsCurrency(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<CurrencyDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Currency',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsCountry(
+        cartId: string,
+        xApiVersion?: string,
+        requestBody?: CountrySwitchRequest,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Country',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -56,13 +164,74 @@ export class CartsService {
         });
     }
     /**
-     * @returns CartDtoEnvelope Success
+     * @param cartId
+     * @param xApiVersion
+     * @returns CountryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsCountry(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<CountryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Country',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static submitCartAsync(
+        cartId: string,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Carts/{cartId}/Submit',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CartServiceCartsActingCart(): CancelablePromise<CartDtoEnvelope> {
+    public static getApiV2CartServiceCartsActingCart(
+        xApiVersion?: string,
+    ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Carts/ActingCart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -70,13 +239,19 @@ export class CartsService {
         });
     }
     /**
-     * @returns CartDtoEnvelope Success
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CartServiceCartsGuestCart(): CancelablePromise<CartDtoEnvelope> {
+    public static getApiV2CartServiceCartsGuestCart(
+        xApiVersion?: string,
+    ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Carts/GuestCart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -84,13 +259,19 @@ export class CartsService {
         });
     }
     /**
-     * @returns CartDtoEnvelope Success
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2CartServiceCartsUserCart(): CancelablePromise<CartDtoEnvelope> {
+    public static getApiV2CartServiceCartsUserCart(
+        xApiVersion?: string,
+    ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Carts/UserCart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
@@ -98,11 +279,13 @@ export class CartsService {
     }
     /**
      * @param tenantId
-     * @returns CartDtoEnvelope Success
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceCartsBusinessCart(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -110,6 +293,9 @@ export class CartsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -117,33 +303,894 @@ export class CartsService {
         });
     }
     /**
-     * @param requestBody
-     * @returns any Success
+     * @param cartId
+     * @param xApiVersion
+     * @returns ItemCartRecordDtoListEnvelope OK
      * @throws ApiError
      */
-    public static postApiV2CartServiceCartsSetCurrency(
-        requestBody?: CurrencySwitchRequest,
-    ): CancelablePromise<any> {
+    public static getApiV2CartServiceCartsItems(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemCartRecordDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Items',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCartsItems(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Carts/{cartId}/Items',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param quantity
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceCartsItems(
+        cartId: string,
+        itemId: string,
+        quantity: number = 1,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/CartService/Carts/SetCurrency',
+            url: '/api/v2/CartService/Carts/{cartId}/Items/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'quantity': quantity,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsItems(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+        requestBody?: ItemCartRecordUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Items/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCartsItems1(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Carts/{cartId}/Items/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsContains(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Contains/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsItemsIncrease(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+        requestBody?: ItemCartRecordUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Items/{itemId}/Increase',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
         });
     }
     /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
-    public static postApiV2CartServiceCartsSetCountry(
-        requestBody?: CountrySwitchRequest,
-    ): CancelablePromise<any> {
+    public static putApiV2CartServiceCartsItemsDecrease(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+        requestBody?: ItemCartRecordUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/CartService/Carts/SetCountry',
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Items/{itemId}/Decrease',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @returns ItemCartRecordDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsLines(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemCartRecordDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Lines',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param lineId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsLines1(
+        cartId: string,
+        lineId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Lines/{lineId}',
+            path: {
+                'cartId': cartId,
+                'lineId': lineId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param lineId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsLines(
+        cartId: string,
+        lineId: string,
+        xApiVersion?: string,
+        requestBody?: ItemCartRecordUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Lines/{lineId}',
+            path: {
+                'cartId': cartId,
+                'lineId': lineId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param lineId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCartsLines(
+        cartId: string,
+        lineId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Carts/{cartId}/Lines/{lineId}',
+            path: {
+                'cartId': cartId,
+                'lineId': lineId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param lineId
+     * @param quantity
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsLinesIncrease(
+        cartId: string,
+        lineId: string,
+        quantity: number = 1,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Lines/{lineId}/Increase',
+            path: {
+                'cartId': cartId,
+                'lineId': lineId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'quantity': quantity,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param lineId
+     * @param quantity
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsLinesDecrease(
+        cartId: string,
+        lineId: string,
+        quantity: number = 1,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/Lines/{lineId}/Decrease',
+            path: {
+                'cartId': cartId,
+                'lineId': lineId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'quantity': quantity,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @returns WishListDto OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsWishLists(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Array<WishListDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceCartsWishLists(
+        cartId: string,
+        xApiVersion?: string,
+        requestBody?: NewWishListRequest,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsWishListsContains(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/Contains/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsWishListsExists(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}/Exists',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static headApiV2CartServiceCartsWishListsExists(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'HEAD',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}/Exists',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceCartsWishLists(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+        requestBody?: WishListUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns WishListDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsWishLists1(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<WishListDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCartsWishLists(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsWishListsRecords(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Array<WishListItemRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}/Records',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceCartsWishListsRecords(
+        cartId: string,
+        wishListId: string,
+        xApiVersion?: string,
+        requestBody?: ProductToWishListRequest,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}/Records',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param recordId
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsWishListsRecords1(
+        cartId: string,
+        wishListId: string,
+        recordId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Array<WishListItemRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}/Records/{recordId}',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+                'recordId': recordId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param wishListId
+     * @param recordId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCartsWishListsRecords(
+        cartId: string,
+        wishListId: string,
+        recordId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists/{wishListId}/Records/{recordId}',
+            path: {
+                'cartId': cartId,
+                'wishListId': wishListId,
+                'recordId': recordId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsCompare(
+        cartId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemToCompareCartRecordDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Compare',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsCompare1(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemToCompareCartRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Compare/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns ItemCartRecordDto OK
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceCartsCompare(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemCartRecordDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Carts/{cartId}/Compare/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDto OK
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCartsCompare(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ItemToCompareCartRecordDto> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Carts/{cartId}/Compare/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCartsCompareContains(
+        cartId: string,
+        itemId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/Compare/Contains/{itemId}',
+            path: {
+                'cartId': cartId,
+                'itemId': itemId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
         });
     }
 }