@fenixalliance/abs-api-client 1.0.2 → 1.0.3

package/clients/cartService/services/CompareService.ts

@@ -13,11 +13,13 @@ import { request as __request } from '../core/request';
 export class CompareService {
     /**
      * @param cartId
-     * @returns ItemToCompareCartRecordDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns ItemToCompareCartRecordDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceCompare(
         cartId: string,
+        xApiVersion?: string,
     ): CancelablePromise<ItemToCompareCartRecordDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -25,6 +27,9 @@ export class CompareService {
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 404: `Not Found`,
@@ -33,11 +38,13 @@ export class CompareService {
     }
     /**
      * @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',
@@ -45,22 +52,30 @@ export class CompareService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 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: {
@@ -70,11 +85,13 @@ export class CompareService {
     }
     /**
      * @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',
@@ -82,6 +99,9 @@ export class CompareService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 404: `Not Found`,
             },

package/clients/cartService/services/RecordsService.ts

@@ -15,17 +15,22 @@ export class RecordsService {
      * @param cartId
      * @param itemId
      * @param quantity
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceRecordsAddItem(
         cartId?: string,
         itemId?: string,
         quantity?: number,
+        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,
@@ -39,11 +44,13 @@ export class RecordsService {
     }
     /**
      * @param cartId
-     * @returns ItemCartRecordDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns ItemCartRecordDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceRecords(
         cartId: string,
+        xApiVersion?: string,
     ): CancelablePromise<ItemCartRecordDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -51,6 +58,9 @@ export class RecordsService {
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 404: `Not Found`,
@@ -58,16 +68,21 @@ export class RecordsService {
         });
     }
     /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceRecords(
+        xApiVersion?: string,
         requestBody?: ItemCartRecordCreateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/Records',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -79,16 +94,21 @@ export class RecordsService {
     /**
      * @param cartId
      * @param productId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceRecords(
         cartId?: string,
         productId?: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/CartService/Records',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'cartId': cartId,
                 'productId': productId,
@@ -102,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,
@@ -124,15 +149,20 @@ export class RecordsService {
     }
     /**
      * @param cartId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceRecordsClearCart(
         cartId: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/CartService/Records/ClearCart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'cartID': cartId,
             },
@@ -144,11 +174,13 @@ export class RecordsService {
     }
     /**
      * @param recordId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2CartServiceRecordsDetails(
         recordId: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -156,6 +188,9 @@ export class RecordsService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 404: `Not Found`,
@@ -164,12 +199,14 @@ export class RecordsService {
     }
     /**
      * @param recordId
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2CartServiceRecords(
         recordId: string,
+        xApiVersion?: string,
         requestBody?: ItemCartRecordUpdateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
@@ -178,6 +215,9 @@ export class RecordsService {
             path: {
                 'recordId': recordId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -188,11 +228,13 @@ export class RecordsService {
     }
     /**
      * @param recordId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceRecords1(
         recordId: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
@@ -200,6 +242,69 @@ export class RecordsService {
             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,6 +2,7 @@
 /* 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';
@@ -13,28 +14,101 @@ 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 EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceWishLists(
+        xApiVersion?: string,
         requestBody?: NewWishListRequest,
     ): 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 EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2CartServiceWishLists(
         wishListId: string,
+        xApiVersion?: string,
         requestBody?: WishListUpdateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
@@ -43,33 +117,43 @@ export class WishListsService {
             path: {
                 'wishListId': wishListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
         });
     }
     /**
      * @param wishListId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2CartServiceWishLists(
         wishListId: string,
+        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 WishListDto Success
+     * @param xApiVersion
+     * @returns WishListDto OK
      * @throws ApiError
      */
     public static getApiV2CartServiceWishLists(
         cartId: string,
+        xApiVersion?: string,
     ): CancelablePromise<Array<WishListDto>> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -77,15 +161,20 @@ export class WishListsService {
             path: {
                 'cartId': cartId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
      * @param wishListId
-     * @returns WishListItemRecordDto Success
+     * @param xApiVersion
+     * @returns WishListItemRecordDto OK
      * @throws ApiError
      */
     public static getApiV2CartServiceWishListsRecords(
         wishListId: string,
+        xApiVersion?: string,
     ): CancelablePromise<Array<WishListItemRecordDto>> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -93,15 +182,20 @@ export class WishListsService {
             path: {
                 'wishListId': wishListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
      * @param wishListId
-     * @returns WishListDto Success
+     * @param xApiVersion
+     * @returns WishListDto OK
      * @throws ApiError
      */
     public static getApiV2CartServiceWishListsDetails(
         wishListId: string,
+        xApiVersion?: string,
     ): CancelablePromise<WishListDto> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -109,30 +203,40 @@ export class WishListsService {
             path: {
                 'wishListId': wishListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2CartServiceWishListsRecords(
+        xApiVersion?: string,
         requestBody?: ProductToWishListRequest,
     ): 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,
+            },
         });
     }
 }

package/clients/catalogService/index.ts

@@ -7,8 +7,15 @@ export { CancelablePromise, CancelError } from './core/CancelablePromise';
 export { OpenAPI } from './core/OpenAPI';
 export type { OpenAPIConfig } from './core/OpenAPI';
 
+export type { CatalogItemCreateDto } from './models/CatalogItemCreateDto';
+export type { CatalogItemDto } from './models/CatalogItemDto';
+export type { CatalogItemDtoEnvelope } from './models/CatalogItemDtoEnvelope';
+export type { CatalogItemDtoListEnvelope } from './models/CatalogItemDtoListEnvelope';
+export type { CatalogItemUpdateDto } from './models/CatalogItemUpdateDto';
+export type { Currency } from './models/Currency';
 export type { EmptyEnvelope } from './models/EmptyEnvelope';
 export type { ErrorEnvelope } from './models/ErrorEnvelope';
+export type { Int32Envelope } from './models/Int32Envelope';
 export type { ItemAttachmentCreateDto } from './models/ItemAttachmentCreateDto';
 export type { ItemAttachmentDto } from './models/ItemAttachmentDto';
 export type { ItemAttachmentDtoEnvelope } from './models/ItemAttachmentDtoEnvelope';
@@ -77,26 +84,27 @@ export type { ItemTypeUpdateDto } from './models/ItemTypeUpdateDto';
 export type { ItemWarrantyPolicyDto } from './models/ItemWarrantyPolicyDto';
 export type { ItemWarrantyPolicyDtoEnvelope } from './models/ItemWarrantyPolicyDtoEnvelope';
 export type { ItemWarrantyPolicyDtoListEnvelope } from './models/ItemWarrantyPolicyDtoListEnvelope';
+export type { MerchantDto } from './models/MerchantDto';
+export type { MerchantDtoListEnvelope } from './models/MerchantDtoListEnvelope';
+export type { Money } from './models/Money';
+export type { MoneyEnvelope } from './models/MoneyEnvelope';
 export type { PricingRuleCreateDto } from './models/PricingRuleCreateDto';
 export type { PricingRuleDto } from './models/PricingRuleDto';
 export type { PricingRuleDtoEnvelope } from './models/PricingRuleDtoEnvelope';
 export type { PricingRuleDtoListEnvelope } from './models/PricingRuleDtoListEnvelope';
 export type { PricingRuleUpdateDto } from './models/PricingRuleUpdateDto';
-export type { StockItemCreateDto } from './models/StockItemCreateDto';
-export type { StockItemDto } from './models/StockItemDto';
-export type { StockItemDtoEnvelope } from './models/StockItemDtoEnvelope';
-export type { StockItemDtoListEnvelope } from './models/StockItemDtoListEnvelope';
-export type { StockItemUpdateDto } from './models/StockItemUpdateDto';
 
 export { ItemAttachmentsService } from './services/ItemAttachmentsService';
 export { ItemAttributesService } from './services/ItemAttributesService';
 export { ItemBrandsService } from './services/ItemBrandsService';
 export { ItemCategoriesService } from './services/ItemCategoriesService';
+export { ItemGoogleCategoriesService } from './services/ItemGoogleCategoriesService';
 export { ItemImagesService } from './services/ItemImagesService';
 export { ItemQuestionsService } from './services/ItemQuestionsService';
 export { ItemReviewsService } from './services/ItemReviewsService';
+export { ItemsService } from './services/ItemsService';
 export { ItemTagsService } from './services/ItemTagsService';
 export { ItemTypesService } from './services/ItemTypesService';
+export { MerchantsService } from './services/MerchantsService';
 export { PoliciesService } from './services/PoliciesService';
 export { PricingRulesService } from './services/PricingRulesService';
-export { ProductsService } from './services/ProductsService';