@fenixalliance/abs-api-client 1.0.10 → 1.0.11

package/clients/cartService/services/WishListsService.js

@@ -4,6 +4,327 @@ exports.WishListsService = void 0;
 const OpenAPI_1 = require("../core/OpenAPI");
 const request_1 = require("../core/request");
 class WishListsService {
+    /**
+     * Get all wishlists in a cart
+     * Get all wishlists in a cart
+     * @param cartId
+     * @param xApiVersion
+     * @returns WishListDto OK
+     * @throws ApiError
+     */
+    static getWishListAsync(cartId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Carts/{cartId}/WishLists',
+            path: {
+                'cartId': cartId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * Create a new wish list
+     * Create a new wish list
+     * @param cartId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    static createWishListAsync(cartId, xApiVersion, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Assesses if an Item is already in any of the cart's wishlists
+     * Assesses if an Item is already in any of the cart's wishlists
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    static isItemInWishLists(cartId, itemId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Assesses if a WishList exists
+     * Assesses if a WishList exists
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    static wishListExistsAsync(cartId, wishListId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Assesses if a WishList exists
+     * Assesses if a WishList exists but does not return the content
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    static wishListExistsHeadAsync(cartId, wishListId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'HEAD',
+            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`,
+            },
+        });
+    }
+    /**
+     * Update a wish list
+     * Update a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    static updateItemToWishList(cartId, wishListId, xApiVersion, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Get a wish list by ID
+     * Get a wish list by ID
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns WishListDtoEnvelope OK
+     * @throws ApiError
+     */
+    static getCartWishListDetailsAsync(cartId, wishListId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Delete a wish list
+     * Delete a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    static deleteWishList(cartId, wishListId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Get all records in a wish list
+     * Get all records in a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
+     * @throws ApiError
+     */
+    static getCartWishListItemsAsync(cartId, wishListId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Add a record to a wish list
+     * Add a record to a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    static addItemToWishList(cartId, wishListId, xApiVersion, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.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`,
+            },
+        });
+    }
+    /**
+     * Get a record in a wish list
+     * Get a record in a wish list
+     * @param cartId
+     * @param wishListId
+     * @param recordId
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
+     * @throws ApiError
+     */
+    static getCartWishListItemAsync(cartId, wishListId, recordId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * Remove a record from a wish list
+     * Remove a record from a wish list
+     * @param cartId
+     * @param wishListId
+     * @param recordId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    static deleteWishListRecord(cartId, wishListId, recordId, xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.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 productId

package/clients/cartService/services/WishListsService.ts

@@ -7,12 +7,385 @@ import type { EmptyEnvelope } from '../models/EmptyEnvelope';
 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 WishListsService {
+    /**
+     * Get all wishlists in a cart
+     * Get all wishlists in a cart
+     * @param cartId
+     * @param xApiVersion
+     * @returns WishListDto OK
+     * @throws ApiError
+     */
+    public static getWishListAsync(
+        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`,
+            },
+        });
+    }
+    /**
+     * Create a new wish list
+     * Create a new wish list
+     * @param cartId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static createWishListAsync(
+        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`,
+            },
+        });
+    }
+    /**
+     * Assesses if an Item is already in any of the cart's wishlists
+     * Assesses if an Item is already in any of the cart's wishlists
+     * @param cartId
+     * @param itemId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static isItemInWishLists(
+        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`,
+            },
+        });
+    }
+    /**
+     * Assesses if a WishList exists
+     * Assesses if a WishList exists
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static wishListExistsAsync(
+        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`,
+            },
+        });
+    }
+    /**
+     * Assesses if a WishList exists
+     * Assesses if a WishList exists but does not return the content
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static wishListExistsHeadAsync(
+        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,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * Update a wish list
+     * Update a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static updateItemToWishList(
+        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`,
+            },
+        });
+    }
+    /**
+     * Get a wish list by ID
+     * Get a wish list by ID
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns WishListDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getCartWishListDetailsAsync(
+        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`,
+            },
+        });
+    }
+    /**
+     * Delete a wish list
+     * Delete a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteWishList(
+        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`,
+            },
+        });
+    }
+    /**
+     * Get all records in a wish list
+     * Get all records in a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
+     * @throws ApiError
+     */
+    public static getCartWishListItemsAsync(
+        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`,
+            },
+        });
+    }
+    /**
+     * Add a record to a wish list
+     * Add a record to a wish list
+     * @param cartId
+     * @param wishListId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static addItemToWishList(
+        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`,
+            },
+        });
+    }
+    /**
+     * Get a record in a wish list
+     * Get a record in a wish list
+     * @param cartId
+     * @param wishListId
+     * @param recordId
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
+     * @throws ApiError
+     */
+    public static getCartWishListItemAsync(
+        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,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * Remove a record from a wish list
+     * Remove a record from a wish list
+     * @param cartId
+     * @param wishListId
+     * @param recordId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteWishListRecord(
+        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 productId