@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/tenantService/services/TerritoriesService.ts

@@ -0,0 +1,192 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Operation } from '../models/Operation';
+import type { TenantTerritoryCreateDto } from '../models/TenantTerritoryCreateDto';
+import type { TenantTerritoryDtoEnvelope } from '../models/TenantTerritoryDtoEnvelope';
+import type { TenantTerritoryDtoListEnvelope } from '../models/TenantTerritoryDtoListEnvelope';
+import type { TenantTerritoryUpdateDto } from '../models/TenantTerritoryUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TerritoriesService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2Territories(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTerritoryCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Territories',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantTerritoryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Territories(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTerritoryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Territories',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTerritoryId
+     * @param xApiVersion
+     * @returns TenantTerritoryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Territories1(
+        tenantTerritoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTerritoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Territories/{tenantTerritoryId}',
+            path: {
+                'tenantTerritoryId': tenantTerritoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTerritoryId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Territories(
+        tenantId: string,
+        tenantTerritoryId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Territories/{tenantTerritoryId}',
+            path: {
+                'tenantTerritoryId': tenantTerritoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTerritoryId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Territories(
+        tenantId: string,
+        tenantTerritoryId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTerritoryUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Territories/{tenantTerritoryId}',
+            path: {
+                'tenantTerritoryId': tenantTerritoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTerritoryId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2Territories(
+        tenantId: string,
+        tenantTerritoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Territories/{tenantTerritoryId}',
+            path: {
+                'tenantTerritoryId': tenantTerritoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/TypesService.ts

@@ -0,0 +1,176 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Operation } from '../models/Operation';
+import type { TenantTypeCreateDto } from '../models/TenantTypeCreateDto';
+import type { TenantTypeDtoEnvelope } from '../models/TenantTypeDtoEnvelope';
+import type { TenantTypeDtoIReadOnlyCollectionEnvelope } from '../models/TenantTypeDtoIReadOnlyCollectionEnvelope';
+import type { TenantTypeUpdateDto } from '../models/TenantTypeUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TypesService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTypeDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2Types(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTypeCreateDto,
+    ): CancelablePromise<TenantTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Types',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantTypeDtoIReadOnlyCollectionEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Types(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTypeDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Types',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTypeId
+     * @param xApiVersion
+     * @returns TenantTypeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Types1(
+        tenantTypeId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Types/{tenantTypeId}',
+            path: {
+                'tenantTypeId': tenantTypeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTypeId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTypeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Types(
+        tenantTypeId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<TenantTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Types/{tenantTypeId}',
+            path: {
+                'tenantTypeId': tenantTypeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTypeId
+     * @param xApiVersion
+     * @returns TenantTypeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2Types(
+        tenantTypeId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Types/{tenantTypeId}',
+            path: {
+                'tenantTypeId': tenantTypeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTypeId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTypeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Types(
+        tenantTypeId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTypeUpdateDto,
+    ): CancelablePromise<TenantTypeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Types/{tenantTypeId}',
+            path: {
+                'tenantTypeId': tenantTypeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/UnitsService.ts

@@ -0,0 +1,190 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Operation } from '../models/Operation';
+import type { TenantUnitCreateDto } from '../models/TenantUnitCreateDto';
+import type { TenantUnitDtoEnvelope } from '../models/TenantUnitDtoEnvelope';
+import type { TenantUnitDtoListEnvelope } from '../models/TenantUnitDtoListEnvelope';
+import type { TenantUnitUpdateDto } from '../models/TenantUnitUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class UnitsService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2Units(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantUnitCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Units',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantUnitDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Units(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantUnitDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Units',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantUnitId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Units(
+        tenantId: string,
+        tenantUnitId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Units',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'tenantUnitId': tenantUnitId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantUnitId
+     * @param xApiVersion
+     * @returns TenantUnitDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Units1(
+        tenantUnitId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantUnitDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Units/{tenantUnitId}',
+            path: {
+                'tenantUnitId': tenantUnitId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantUnitId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Units(
+        tenantId: string,
+        tenantUnitId: string,
+        xApiVersion?: string,
+        requestBody?: TenantUnitUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Units/{tenantUnitId}',
+            path: {
+                'tenantUnitId': tenantUnitId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantUnitId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2Units(
+        tenantId: string,
+        tenantUnitId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Units/{tenantUnitId}',
+            path: {
+                'tenantUnitId': tenantUnitId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/walletsService/index.ts

@@ -7,14 +7,16 @@ export { CancelablePromise, CancelError } from './core/CancelablePromise';
 export { OpenAPI } from './core/OpenAPI';
 export type { OpenAPIConfig } from './core/OpenAPI';
 
+export type { Currency } from './models/Currency';
 export type { ErrorEnvelope } from './models/ErrorEnvelope';
-export type { InvoiceDto } from './models/InvoiceDto';
+export { InvoiceDto } from './models/InvoiceDto';
 export type { InvoiceDtoListEnvelope } from './models/InvoiceDtoListEnvelope';
 export type { LocationDto } from './models/LocationDto';
 export type { LocationDtoListEnvelope } from './models/LocationDtoListEnvelope';
-export type { OrderDto } from './models/OrderDto';
+export type { Money } from './models/Money';
+export { OrderDto } from './models/OrderDto';
 export type { OrderDtoListEnvelope } from './models/OrderDtoListEnvelope';
-export type { PaymentDto } from './models/PaymentDto';
+export { PaymentDto } from './models/PaymentDto';
 export type { PaymentDtoListEnvelope } from './models/PaymentDtoListEnvelope';
 export type { WalletDto } from './models/WalletDto';
 export type { WalletDtoEnvelope } from './models/WalletDtoEnvelope';

package/clients/walletsService/models/Currency.ts

@@ -0,0 +1,9 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type Currency = {
+    code?: string | null;
+    country?: string | null;
+};
+

package/clients/walletsService/models/ErrorEnvelope.ts

@@ -3,10 +3,10 @@
 /* tslint:disable */
 /* eslint-disable */
 export type ErrorEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
 };
 

package/clients/walletsService/models/InvoiceDto.ts

@@ -2,12 +2,101 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { Currency } from './Currency';
+import type { Money } from './Money';
 export type InvoiceDto = {
     id?: string | null;
     timestamp?: string | null;
-    orderID?: string | null;
-    businessID?: string | null;
+    closed?: boolean;
+    type?: string | null;
+    title?: string | null;
+    userId?: string | null;
+    tenantId?: string | null;
+    currencyId?: string | null;
+    description?: string | null;
+    priceListId?: string | null;
+    enrollmentId?: string | null;
+    individualId?: string | null;
+    organizationId?: string | null;
+    receiverTenantId?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    companyName?: string | null;
+    billingEmail?: string | null;
+    addressLine1?: string | null;
+    addressLine2?: string | null;
+    postalCode?: string | null;
+    countryId?: string | null;
+    stateId?: string | null;
+    cityId?: string | null;
+    customerNotes?: string | null;
     forexRate?: number;
+    total?: number;
+    totalTaxes?: number;
+    totalTaxBase?: number;
+    totalDiscounts?: number;
+    totalSurcharges?: number;
+    totalGlobalDiscounts?: number;
+    totalGlobalSurcharges?: number;
+    totalTaxesInUsd?: number;
     totalAmountInUsd?: number;
+    totalProfitInUsd?: number;
+    totalTaxBaseInUsd?: number;
+    totalDiscountsInUsd?: number;
+    totalSurchargesInUsd?: number;
+    totalDetailAmountInUsd?: number;
+    totalGlobalDiscountsInUsd?: number;
+    totalGlobalSurchargesInUsd?: number;
+    totalWithholdingTaxesInUsd?: number;
+    totalShippingCostInUsd?: number;
+    totalShippingTaxesInUsd?: number;
+    currency?: Currency;
+    totalInUsd?: Money;
+    totalTaxAmountInUsd?: Money;
+    totalTaxBaseAmountInUsd?: Money;
+    totalDiscountsAmountInUsd?: Money;
+    totalSurchargesAmountInUsd?: Money;
+    totalGlobalDiscountsAmountInUsd?: Money;
+    totalGlobalSurchargesAmountInUsd?: Money;
+    totalAmount?: Money;
+    totalTaxAmount?: Money;
+    totalTaxBaseAmount?: Money;
+    totalDiscountsAmount?: Money;
+    totalSurchargesAmount?: Money;
+    totalGlobalDiscountsAmount?: Money;
+    totalGlobalSurchargesAmount?: Money;
+    paid?: boolean;
+    number?: number;
+    notes?: string | null;
+    orderId?: string | null;
+    enumeration?: string | null;
+    paymentModeId?: string | null;
+    enumerationRangeId?: string | null;
+    emisorBillingProfileId?: string | null;
+    receiverBillingProfileId?: string | null;
+    emisorWalletAccountId?: string | null;
+    receiverWalletAccountId?: string | null;
+    paymentDue?: string | null;
+    invoiceType?: InvoiceDto.invoiceType;
+    documentType?: InvoiceDto.documentType;
+    invoiceStatus?: InvoiceDto.invoiceStatus;
 };
+export namespace InvoiceDto {
+    export enum invoiceType {
+        '_0' = 0,
+        '_1' = 1,
+    }
+    export enum documentType {
+        '_0' = 0,
+        '_1' = 1,
+        '_2' = 2,
+    }
+    export enum invoiceStatus {
+        '_0' = 0,
+        '_1' = 1,
+        '_2' = 2,
+        '_3' = 3,
+        '_4' = 4,
+    }
+}