@fenixalliance/abs-api-client 1.0.2 → 1.0.3

package/clients/pricingService/models/ItemPriceDtoListEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { ItemPriceDto } from './ItemPriceDto';
 export type ItemPriceDtoListEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: Array<ItemPriceDto> | null;
 };
 

package/clients/pricingService/models/ItemPriceUpdateDto.ts

@@ -4,8 +4,9 @@
 /* eslint-disable */
 export type ItemPriceUpdateDto = {
     price?: number;
-    percent?: number;
+    itemId?: string | null;
     unitId?: string | null;
+    percent?: number;
     unitGroupId?: string | null;
     currencyId?: string | null;
     discountListId?: string | null;

package/clients/pricingService/models/Money.ts

@@ -4,7 +4,7 @@
 /* eslint-disable */
 import type { Currency } from './Currency';
 export type Money = {
-    readonly amount?: number;
+    amount?: number;
     currency?: Currency;
 };
 

package/clients/pricingService/models/MoneyEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { Money } from './Money';
 export type MoneyEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: Money;
 };
 

package/clients/pricingService/models/PriceListDtoEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { PriceListDto } from './PriceListDto';
 export type PriceListDtoEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: PriceListDto;
 };
 

package/clients/pricingService/models/PriceListDtoListEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { PriceListDto } from './PriceListDto';
 export type PriceListDtoListEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: Array<PriceListDto> | null;
 };
 

package/clients/pricingService/services/PriceListsService.ts

@@ -3,6 +3,7 @@
 /* tslint:disable */
 /* eslint-disable */
 import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
 import type { ItemPriceCreateDto } from '../models/ItemPriceCreateDto';
 import type { ItemPriceDtoEnvelope } from '../models/ItemPriceDtoEnvelope';
 import type { ItemPriceDtoListEnvelope } from '../models/ItemPriceDtoListEnvelope';
@@ -17,15 +18,20 @@ import { request as __request } from '../core/request';
 export class PriceListsService {
     /**
      * @param tenantId
-     * @returns PriceListDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns PriceListDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2PricingServicePriceLists(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<PriceListDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/PricingService/PriceLists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -36,17 +42,22 @@ export class PriceListsService {
     }
     /**
      * @param tenantId
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2PricingServicePriceLists(
         tenantId: string,
+        xApiVersion?: string,
         requestBody?: PriceListCreateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/PricingService/PriceLists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -57,15 +68,41 @@ export class PriceListsService {
             },
         });
     }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2PricingServicePriceListsCount(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/PricingService/PriceLists/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                404: `Not Found`,
+            },
+        });
+    }
     /**
      * @param tenantId
      * @param priceListId
-     * @returns PriceListDtoEnvelope Success
+     * @param xApiVersion
+     * @returns PriceListDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2PricingServicePriceLists1(
+    public static getPriceListAsync(
         tenantId: string,
         priceListId: string,
+        xApiVersion?: string,
     ): CancelablePromise<PriceListDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -73,6 +110,9 @@ export class PriceListsService {
             path: {
                 'priceListId': priceListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -84,13 +124,15 @@ export class PriceListsService {
     /**
      * @param tenantId
      * @param priceListId
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2PricingServicePriceLists(
         tenantId: string,
         priceListId: string,
+        xApiVersion?: string,
         requestBody?: PriceListUpdateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
@@ -99,6 +141,9 @@ export class PriceListsService {
             path: {
                 'priceListId': priceListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -112,12 +157,14 @@ export class PriceListsService {
     /**
      * @param tenantId
      * @param priceListId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2PricingServicePriceLists(
         tenantId: string,
         priceListId: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
@@ -125,6 +172,9 @@ export class PriceListsService {
             path: {
                 'priceListId': priceListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -137,13 +187,15 @@ export class PriceListsService {
      * @param tenantId
      * @param priceListId
      * @param itemId
-     * @returns ItemPriceDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns ItemPriceDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2PricingServicePriceListsPrices(
+    public static getPriceListPricesAsync(
         tenantId: string,
         priceListId: string,
         itemId?: string,
+        xApiVersion?: string,
     ): CancelablePromise<ItemPriceDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -151,6 +203,9 @@ export class PriceListsService {
             path: {
                 'priceListId': priceListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
                 'itemId': itemId,
@@ -163,13 +218,15 @@ export class PriceListsService {
     /**
      * @param tenantId
      * @param priceListId
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2PricingServicePriceListsPrices(
         tenantId: string,
         priceListId: string,
+        xApiVersion?: string,
         requestBody?: ItemPriceCreateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
@@ -178,6 +235,9 @@ export class PriceListsService {
             path: {
                 'priceListId': priceListId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -191,21 +251,26 @@ export class PriceListsService {
     /**
      * @param tenantId
      * @param priceListId
-     * @param priceListEntryId
-     * @returns ItemPriceDtoEnvelope Success
+     * @param priceId
+     * @param xApiVersion
+     * @returns ItemPriceDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2PricingServicePriceListsPrices1(
+    public static getPriceListPriceAsync(
         tenantId: string,
         priceListId: string,
-        priceListEntryId: string,
+        priceId: string,
+        xApiVersion?: string,
     ): CancelablePromise<ItemPriceDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/PricingService/PriceLists/{priceListId}/Prices/{priceListEntryId}',
+            url: '/api/v2/PricingService/PriceLists/{priceListId}/Prices/{priceId}',
             path: {
                 'priceListId': priceListId,
-                'priceListEntryId': priceListEntryId,
+                'priceId': priceId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             query: {
                 'tenantId': tenantId,
@@ -218,23 +283,28 @@ export class PriceListsService {
     /**
      * @param tenantId
      * @param priceListId
-     * @param priceListEntryId
+     * @param priceId
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static putApiV2PricingServicePriceListsPrices(
         tenantId: string,
         priceListId: string,
-        priceListEntryId: string,
+        priceId: string,
+        xApiVersion?: string,
         requestBody?: ItemPriceUpdateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'PUT',
-            url: '/api/v2/PricingService/PriceLists/{priceListId}/Prices/{priceListEntryId}',
+            url: '/api/v2/PricingService/PriceLists/{priceListId}/Prices/{priceId}',
             path: {
                 'priceListId': priceListId,
-                'priceListEntryId': priceListEntryId,
+                'priceId': priceId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             query: {
                 'tenantId': tenantId,
@@ -249,29 +319,30 @@ export class PriceListsService {
     /**
      * @param tenantId
      * @param priceListId
-     * @param priceListEntryId
-     * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @param priceId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2PricingServicePriceListsPrices(
         tenantId: string,
         priceListId: string,
-        priceListEntryId: string,
-        requestBody?: ItemPriceUpdateDto,
+        priceId: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/v2/PricingService/PriceLists/{priceListId}/Prices/{priceListEntryId}',
+            url: '/api/v2/PricingService/PriceLists/{priceListId}/Prices/{priceId}',
             path: {
                 'priceListId': priceListId,
-                'priceListEntryId': priceListEntryId,
+                'priceId': priceId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             query: {
                 'tenantId': tenantId,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 404: `Not Found`,
             },

package/clients/pricingService/services/PricesService.ts

@@ -10,12 +10,14 @@ export class PricesService {
     /**
      * @param productId
      * @param currencyId
-     * @returns MoneyEnvelope Success
+     * @param xApiVersion
+     * @returns MoneyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2PricingServicePricesFinalPrice(
         productId: string,
         currencyId: string = 'USD.USA',
+        xApiVersion?: string,
     ): CancelablePromise<MoneyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -23,6 +25,9 @@ export class PricesService {
             path: {
                 'productID': productId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'currencyId': currencyId,
             },
@@ -34,12 +39,14 @@ export class PricesService {
     /**
      * @param productId
      * @param currencyId
-     * @returns MoneyEnvelope Success
+     * @param xApiVersion
+     * @returns MoneyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2PricingServicePricesTotalTaxes(
         productId: string,
         currencyId: string = 'USD.USA',
+        xApiVersion?: string,
     ): CancelablePromise<MoneyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -47,6 +54,9 @@ export class PricesService {
             path: {
                 'productId': productId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'currencyId': currencyId,
             },
@@ -58,12 +68,14 @@ export class PricesService {
     /**
      * @param productId
      * @param currencyId
-     * @returns MoneyEnvelope Success
+     * @param xApiVersion
+     * @returns MoneyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2PricingServicePricesTotalSavings(
         productId: string,
         currencyId: string = 'USD.USA',
+        xApiVersion?: string,
     ): CancelablePromise<MoneyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -71,6 +83,9 @@ export class PricesService {
             path: {
                 'productID': productId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'currencyId': currencyId,
             },

package/clients/securityService/core/ApiError.ts

@@ -0,0 +1,25 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+
+export class ApiError extends Error {
+    public readonly url: string;
+    public readonly status: number;
+    public readonly statusText: string;
+    public readonly body: any;
+    public readonly request: ApiRequestOptions;
+
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
+        super(message);
+
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/clients/securityService/core/ApiRequestOptions.ts

@@ -0,0 +1,17 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/clients/securityService/core/ApiResult.ts

@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/clients/securityService/core/CancelablePromise.ts

@@ -0,0 +1,131 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export class CancelError extends Error {
+
+    constructor(message: string) {
+        super(message);
+        this.name = 'CancelError';
+    }
+
+    public get isCancelled(): boolean {
+        return true;
+    }
+}
+
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+
+    (cancelHandler: () => void): void;
+}
+
+export class CancelablePromise<T> implements Promise<T> {
+    #isResolved: boolean;
+    #isRejected: boolean;
+    #isCancelled: boolean;
+    readonly #cancelHandlers: (() => void)[];
+    readonly #promise: Promise<T>;
+    #resolve?: (value: T | PromiseLike<T>) => void;
+    #reject?: (reason?: any) => void;
+
+    constructor(
+        executor: (
+            resolve: (value: T | PromiseLike<T>) => void,
+            reject: (reason?: any) => void,
+            onCancel: OnCancel
+        ) => void
+    ) {
+        this.#isResolved = false;
+        this.#isRejected = false;
+        this.#isCancelled = false;
+        this.#cancelHandlers = [];
+        this.#promise = new Promise<T>((resolve, reject) => {
+            this.#resolve = resolve;
+            this.#reject = reject;
+
+            const onResolve = (value: T | PromiseLike<T>): void => {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                    return;
+                }
+                this.#isResolved = true;
+                if (this.#resolve) this.#resolve(value);
+            };
+
+            const onReject = (reason?: any): void => {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                    return;
+                }
+                this.#isRejected = true;
+                if (this.#reject) this.#reject(reason);
+            };
+
+            const onCancel = (cancelHandler: () => void): void => {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                    return;
+                }
+                this.#cancelHandlers.push(cancelHandler);
+            };
+
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: (): boolean => this.#isResolved,
+            });
+
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: (): boolean => this.#isRejected,
+            });
+
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: (): boolean => this.#isCancelled,
+            });
+
+            return executor(onResolve, onReject, onCancel as OnCancel);
+        });
+    }
+
+     get [Symbol.toStringTag]() {
+            return "Cancellable Promise";
+     }
+
+    public then<TResult1 = T, TResult2 = never>(
+        onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+        onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+    ): Promise<TResult1 | TResult2> {
+        return this.#promise.then(onFulfilled, onRejected);
+    }
+
+    public catch<TResult = never>(
+        onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
+    ): Promise<T | TResult> {
+        return this.#promise.catch(onRejected);
+    }
+
+    public finally(onFinally?: (() => void) | null): Promise<T> {
+        return this.#promise.finally(onFinally);
+    }
+
+    public cancel(): void {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+            return;
+        }
+        this.#isCancelled = true;
+        if (this.#cancelHandlers.length) {
+            try {
+                for (const cancelHandler of this.#cancelHandlers) {
+                    cancelHandler();
+                }
+            } catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        this.#cancelHandlers.length = 0;
+        if (this.#reject) this.#reject(new CancelError('Request aborted'));
+    }
+
+    public get isCancelled(): boolean {
+        return this.#isCancelled;
+    }
+}