@fenixalliance/abs-api-client 1.0.1 → 1.0.3

package/clients/cartService/services/CompareService.ts

@@ -6,37 +6,45 @@ import type { AddProductToCompareRequest } from '../models/AddProductToCompareRe
 import type { ItemCartRecordDto } from '../models/ItemCartRecordDto';
 import type { ItemToCompareCartRecordDto } from '../models/ItemToCompareCartRecordDto';
 import type { ItemToCompareCartRecordDtoEnvelope } from '../models/ItemToCompareCartRecordDtoEnvelope';
-import type { ItemToCompareCartRecordDtoIReadOnlyListEnvelope } from '../models/ItemToCompareCartRecordDtoIReadOnlyListEnvelope';
+import type { ItemToCompareCartRecordDtoListEnvelope } from '../models/ItemToCompareCartRecordDtoListEnvelope';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class CompareService {
     /**
      * @param cartId
-     * @returns ItemToCompareCartRecordDtoIReadOnlyListEnvelope Success
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceCompare(
         cartId: string,
-    ): CancelablePromise<ItemToCompareCartRecordDtoIReadOnlyListEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<ItemToCompareCartRecordDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Compare/{cartId}',
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
+                404: `Not Found`,
             },
         });
     }
     /**
      * @param recordId
-     * @returns ItemToCompareCartRecordDtoEnvelope Success
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceCompareDetails(
         recordId: string,
+        xApiVersion?: string,
     ): CancelablePromise<ItemToCompareCartRecordDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -44,36 +52,46 @@ export class CompareService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
-                401: `Unauthorized`,
+                404: `Not Found`,
             },
         });
     }
     /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns ItemCartRecordDto Success
+     * @returns ItemCartRecordDto OK
      * @throws ApiError
      */
     public static postApiV2CartServiceCompare(
+        xApiVersion?: string,
         requestBody?: AddProductToCompareRequest,
     ): CancelablePromise<ItemCartRecordDto> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/Compare',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                401: `Unauthorized`,
+                404: `Not Found`,
             },
         });
     }
     /**
      * @param recordId
-     * @returns ItemToCompareCartRecordDto Success
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDto OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceCompare(
         recordId: string,
+        xApiVersion?: string,
     ): CancelablePromise<ItemToCompareCartRecordDto> {
         return __request(OpenAPI, {
             method: 'DELETE',
@@ -81,8 +99,11 @@ export class CompareService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
-                401: `Unauthorized`,
+                404: `Not Found`,
             },
         });
     }

package/clients/cartService/services/RecordsService.ts

@@ -3,12 +3,10 @@
 /* tslint:disable */
 /* eslint-disable */
 import type { BooleanEnvelope } from '../models/BooleanEnvelope';
-import type { Envelope } from '../models/Envelope';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
 import type { ItemCartRecordCreateDto } from '../models/ItemCartRecordCreateDto';
-import type { ItemCartRecordDto } from '../models/ItemCartRecordDto';
-import type { ItemCartRecordDtoEnvelope } from '../models/ItemCartRecordDtoEnvelope';
+import type { ItemCartRecordDtoListEnvelope } from '../models/ItemCartRecordDtoListEnvelope';
 import type { ItemCartRecordUpdateDto } from '../models/ItemCartRecordUpdateDto';
-import type { ProductCartRecordDto } from '../models/ProductCartRecordDto';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
@@ -17,54 +15,74 @@ export class RecordsService {
      * @param cartId
      * @param itemId
      * @param quantity
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceRecordsAddItem(
         cartId?: string,
         itemId?: string,
         quantity?: number,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/Records/AddItem',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'cartId': cartId,
                 'itemId': itemId,
                 'quantity': quantity,
             },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
         });
     }
     /**
      * @param cartId
-     * @returns ProductCartRecordDto Success
+     * @param xApiVersion
+     * @returns ItemCartRecordDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceRecords(
         cartId: string,
-    ): CancelablePromise<Array<ProductCartRecordDto>> {
+        xApiVersion?: string,
+    ): CancelablePromise<ItemCartRecordDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Records/{cartID}',
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
+                404: `Not Found`,
             },
         });
     }
     /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns ItemCartRecordDto Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceRecords(
+        xApiVersion?: string,
         requestBody?: ItemCartRecordCreateDto,
-    ): CancelablePromise<ItemCartRecordDto> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/Records',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -76,16 +94,21 @@ export class RecordsService {
     /**
      * @param cartId
      * @param productId
-     * @returns Envelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceRecords(
         cartId?: string,
         productId?: string,
-    ): CancelablePromise<Envelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/CartService/Records',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'cartId': cartId,
                 'productId': productId,
@@ -99,16 +122,21 @@ export class RecordsService {
     /**
      * @param itemId
      * @param cartId
-     * @returns BooleanEnvelope Success
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceRecordsIsInCart(
         itemId: string,
         cartId: string,
+        xApiVersion?: string,
     ): CancelablePromise<BooleanEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Records/IsInCart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'itemID': itemId,
                 'cartID': cartId,
@@ -121,15 +149,20 @@ export class RecordsService {
     }
     /**
      * @param cartId
-     * @returns BooleanEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceRecordsClearCart(
         cartId: string,
-    ): CancelablePromise<BooleanEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/Records/ClearCart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'cartID': cartId,
             },
@@ -141,18 +174,23 @@ export class RecordsService {
     }
     /**
      * @param recordId
-     * @returns ItemCartRecordDtoEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceRecordsDetails(
         recordId: string,
-    ): CancelablePromise<ItemCartRecordDtoEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/Records/{recordId}/Details',
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 404: `Not Found`,
@@ -161,20 +199,25 @@ export class RecordsService {
     }
     /**
      * @param recordId
+     * @param xApiVersion
      * @param requestBody
-     * @returns ItemCartRecordDto Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2CartServiceRecords(
         recordId: string,
+        xApiVersion?: string,
         requestBody?: ItemCartRecordUpdateDto,
-    ): CancelablePromise<ItemCartRecordDto> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'PUT',
             url: '/api/v2/CartService/Records/{recordId}',
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -185,18 +228,83 @@ export class RecordsService {
     }
     /**
      * @param recordId
-     * @returns Envelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceRecords1(
         recordId: string,
-    ): CancelablePromise<Envelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/CartService/Records/{recordId}',
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @param quantity
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceRecordsIncrease(
+        recordId: string,
+        quantity: number = 1,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Records/{recordId}/Increase',
+            path: {
+                'recordId': recordId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'quantity': quantity,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @param quantity
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceRecordsDecrease(
+        recordId: string,
+        quantity: number = 1,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Records/{recordId}/Decrease',
+            path: {
+                'recordId': recordId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'quantity': quantity,
+            },
             errors: {
                 401: `Unauthorized`,
                 404: `Not Found`,

package/clients/cartService/services/WishListsService.ts

@@ -2,137 +2,241 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { BooleanEnvelope } from '../models/BooleanEnvelope';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
 import type { NewWishListRequest } from '../models/NewWishListRequest';
 import type { ProductToWishListRequest } from '../models/ProductToWishListRequest';
-import type { WishListDtoEnvelope } from '../models/WishListDtoEnvelope';
-import type { WishListDtoIReadOnlyListEnvelope } from '../models/WishListDtoIReadOnlyListEnvelope';
-import type { WishListItemRecordDtoIReadOnlyListEnvelope } from '../models/WishListItemRecordDtoIReadOnlyListEnvelope';
+import type { WishListDto } from '../models/WishListDto';
+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 {
     /**
+     * @param cartId
+     * @param productId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceWishListsContains(
+        cartId?: string,
+        productId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/WishLists/Contains',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'cartId': cartId,
+                'productId': productId,
+            },
+        });
+    }
+    /**
+     * @param wishListId
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceWishListsExists(
+        wishListId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/WishLists/Exists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'wishListId': wishListId,
+            },
+        });
+    }
+    /**
+     * @param wishListId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static headApiV2CartServiceWishListsExists(
+        wishListId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'HEAD',
+            url: '/api/v2/CartService/WishLists/Exists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'wishListId': wishListId,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceWishLists(
+        xApiVersion?: string,
         requestBody?: NewWishListRequest,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/WishLists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
         });
     }
     /**
      * @param wishListId
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2CartServiceWishLists(
         wishListId: string,
+        xApiVersion?: string,
         requestBody?: WishListUpdateDto,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'PUT',
             url: '/api/v2/CartService/WishLists/{wishListId}',
             path: {
                 'wishListId': wishListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
         });
     }
     /**
      * @param wishListId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceWishLists(
         wishListId: string,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/CartService/WishLists/{wishListId}',
             path: {
-                'wishListID': wishListId,
+                'wishListId': wishListId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
         });
     }
     /**
      * @param cartId
-     * @returns WishListDtoIReadOnlyListEnvelope Success
+     * @param xApiVersion
+     * @returns WishListDto OK
      * @throws ApiError
      */
     public static getApiV2CartServiceWishLists(
         cartId: string,
-    ): CancelablePromise<WishListDtoIReadOnlyListEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<Array<WishListDto>> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/WishLists/{cartId}',
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
      * @param wishListId
-     * @returns WishListItemRecordDtoIReadOnlyListEnvelope Success
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
      * @throws ApiError
      */
     public static getApiV2CartServiceWishListsRecords(
         wishListId: string,
-    ): CancelablePromise<WishListItemRecordDtoIReadOnlyListEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<Array<WishListItemRecordDto>> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/WishLists/{wishListId}/Records',
             path: {
                 'wishListId': wishListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
      * @param wishListId
-     * @returns WishListDtoEnvelope Success
+     * @param xApiVersion
+     * @returns WishListDto OK
      * @throws ApiError
      */
     public static getApiV2CartServiceWishListsDetails(
         wishListId: string,
-    ): CancelablePromise<WishListDtoEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<WishListDto> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/CartService/WishLists/{wishListId}/Details',
             path: {
                 'wishListId': wishListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns any Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceWishListsRecords(
+        xApiVersion?: string,
         requestBody?: ProductToWishListRequest,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/WishLists/Records',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
         });
     }
     /**
      * @param recordId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceWishListsRecords(
         recordId: string,
+        xApiVersion?: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'DELETE',
@@ -140,6 +244,9 @@ export class WishListsService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
 }