@fenixalliance/abs-api-client 1.0.0

package/clients/catalogService/services/ItemTypesService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemTypeCreateDto } from '../models/ItemTypeCreateDto';
+import type { ItemTypeDtoEnvelope } from '../models/ItemTypeDtoEnvelope';
+import type { ItemTypeDtoIReadOnlyCollectionEnvelope } from '../models/ItemTypeDtoIReadOnlyCollectionEnvelope';
+import type { ItemTypeUpdateDto } from '../models/ItemTypeUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemTypesService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemTypeDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemTypesCreate(
+        businessId: string,
+        requestBody?: ItemTypeCreateDto,
+    ): CancelablePromise<ItemTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemTypes/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemTypeId
+     * @returns ItemTypeDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemTypesDelete(
+        itemTypeId: string,
+    ): CancelablePromise<ItemTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemTypes/Delete/{itemTypeID}',
+            path: {
+                'itemTypeID': itemTypeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemTypeId
+     * @returns ItemTypeDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemTypesDetails(
+        itemTypeId: string,
+    ): CancelablePromise<ItemTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemTypes/Details/{itemTypeID}',
+            path: {
+                'itemTypeID': itemTypeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemTypeDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemTypesList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemTypeDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemTypes/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemTypeId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemTypesUpdate(
+        itemTypeId: string,
+        requestBody?: ItemTypeUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemTypes/Update/{itemTypeID}',
+            path: {
+                'itemTypeID': itemTypeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/PoliciesService.ts

@@ -0,0 +1,117 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemReturnPolicyDtoListEnvelope } from '../models/ItemReturnPolicyDtoListEnvelope';
+import type { ItemShippingPolicyDtoListEnvelope } from '../models/ItemShippingPolicyDtoListEnvelope';
+import type { ItemTaxPolicyDtoListEnvelope } from '../models/ItemTaxPolicyDtoListEnvelope';
+import type { ItemWarrantyPolicyDtoListEnvelope } from '../models/ItemWarrantyPolicyDtoListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PoliciesService {
+    /**
+     * @param itemId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemReturnPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePoliciesItemReturnPolicies(
+        itemId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemReturnPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Policies/ItemReturnPolicies',
+            query: {
+                'itemId': itemId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemTaxPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePoliciesItemTaxPolicies(
+        itemId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemTaxPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Policies/ItemTaxPolicies',
+            query: {
+                'itemId': itemId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemWarrantyPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePoliciesItemWarrantyPolicies(
+        itemId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemWarrantyPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Policies/ItemWarrantyPolicies',
+            query: {
+                'itemId': itemId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemShippingPolicyDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePoliciesItemShippingPolicies(
+        itemId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemShippingPolicyDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/Policies/ItemShippingPolicies',
+            query: {
+                'itemId': itemId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/PricingRulesService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { PricingRuleCreateDto } from '../models/PricingRuleCreateDto';
+import type { PricingRuleDtoEnvelope } from '../models/PricingRuleDtoEnvelope';
+import type { PricingRuleDtoIReadOnlyCollectionEnvelope } from '../models/PricingRuleDtoIReadOnlyCollectionEnvelope';
+import type { PricingRuleUpdateDto } from '../models/PricingRuleUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PricingRulesService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns PricingRuleDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServicePricingRulesCreate(
+        businessId: string,
+        requestBody?: PricingRuleCreateDto,
+    ): CancelablePromise<PricingRuleDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/PricingRules/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param pricingRuleId
+     * @returns PricingRuleDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePricingRulesDetails(
+        pricingRuleId: string,
+    ): CancelablePromise<PricingRuleDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/PricingRules/Details/{pricingRuleId}',
+            path: {
+                'pricingRuleId': pricingRuleId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns PricingRuleDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePricingRulesList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<PricingRuleDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/PricingRules/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param pricingRuleId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServicePricingRulesUpdate(
+        pricingRuleId: string,
+        requestBody?: PricingRuleUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/PricingRules/Update',
+            query: {
+                'pricingRuleId': pricingRuleId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param pricingRuleId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServicePricingRulesDelete(
+        pricingRuleId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/PricingRules/Delete/{pricingRuleId}',
+            path: {
+                'pricingRuleId': pricingRuleId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}