@fenixalliance/abs-api-client 1.0.3 → 1.0.6

package/clients/accountingService/services/BudgetsService.ts

@@ -2,6 +2,10 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { BudgetAccountEntryCreateDto } from '../models/BudgetAccountEntryCreateDto';
+import type { BudgetAccountEntryDtoEnvelope } from '../models/BudgetAccountEntryDtoEnvelope';
+import type { BudgetAccountEntryDtoListEnvelope } from '../models/BudgetAccountEntryDtoListEnvelope';
+import type { BudgetAccountEntryUpdateDto } from '../models/BudgetAccountEntryUpdateDto';
 import type { BudgetCreateDto } from '../models/BudgetCreateDto';
 import type { BudgetDtoEnvelope } from '../models/BudgetDtoEnvelope';
 import type { BudgetDtoListEnvelope } from '../models/BudgetDtoListEnvelope';
@@ -164,4 +168,176 @@ export class BudgetsService {
             },
         });
     }
+    /**
+     * @param tenantId
+     * @param budgetId
+     * @param xApiVersion
+     * @returns BudgetAccountEntryDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceBudgetsAccountEntries(
+        tenantId: string,
+        budgetId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BudgetAccountEntryDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Budgets/{budgetId}/AccountEntries',
+            path: {
+                'budgetId': budgetId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param budgetId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2AccountingServiceBudgetsAccountEntries(
+        tenantId: string,
+        budgetId: string,
+        requestBody: BudgetAccountEntryCreateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/AccountingService/Budgets/{budgetId}/AccountEntries',
+            path: {
+                'budgetId': budgetId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param budgetId
+     * @param budgetAccountEntryId
+     * @param xApiVersion
+     * @returns BudgetAccountEntryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceBudgetsAccountEntries1(
+        tenantId: string,
+        budgetId: string,
+        budgetAccountEntryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BudgetAccountEntryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Budgets/{budgetId}/AccountEntries/{budgetAccountEntryId}',
+            path: {
+                'budgetId': budgetId,
+                'budgetAccountEntryId': budgetAccountEntryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param budgetId
+     * @param budgetAccountEntryId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2AccountingServiceBudgetsAccountEntries(
+        tenantId: string,
+        budgetId: string,
+        budgetAccountEntryId: string,
+        requestBody: BudgetAccountEntryUpdateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/AccountingService/Budgets/{budgetId}/AccountEntries/{budgetAccountEntryId}',
+            path: {
+                'budgetId': budgetId,
+                'budgetAccountEntryId': budgetAccountEntryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param budgetId
+     * @param budgetAccountEntryId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2AccountingServiceBudgetsAccountEntries(
+        tenantId: string,
+        budgetId: string,
+        budgetAccountEntryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/AccountingService/Budgets/{budgetId}/AccountEntries/{budgetAccountEntryId}',
+            path: {
+                'budgetId': budgetId,
+                'budgetAccountEntryId': budgetAccountEntryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
 }

package/clients/accountingService/services/CommissionsService.ts

@@ -0,0 +1,364 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CommissionCreateDto } from '../models/CommissionCreateDto';
+import type { CommissionDto } from '../models/CommissionDto';
+import type { CommissionDtoListEnvelope } from '../models/CommissionDtoListEnvelope';
+import type { CommissionUpdateDto } from '../models/CommissionUpdateDto';
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { PaymentCommissionCreateDto } from '../models/PaymentCommissionCreateDto';
+import type { PaymentCommissionDto } from '../models/PaymentCommissionDto';
+import type { PaymentCommissionDtoListEnvelope } from '../models/PaymentCommissionDtoListEnvelope';
+import type { PaymentCommissionUpdateDto } from '../models/PaymentCommissionUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class CommissionsService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns CommissionDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceCommissionsCommissions(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<CommissionDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Commissions/Commissions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns CommissionDto Created
+     * @throws ApiError
+     */
+    public static postApiV2AccountingServiceCommissionsCommissions(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: CommissionCreateDto,
+    ): CancelablePromise<CommissionDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/AccountingService/Commissions/Commissions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceCommissionsCommissionsCount(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Commissions/Commissions/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param commissionId
+     * @param xApiVersion
+     * @returns CommissionDto OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceCommissionsCommissions1(
+        tenantId: string,
+        commissionId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<CommissionDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Commissions/Commissions/{commissionId}',
+            path: {
+                'commissionId': commissionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param commissionId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns CommissionDto OK
+     * @throws ApiError
+     */
+    public static putApiV2AccountingServiceCommissionsCommissions(
+        tenantId: string,
+        commissionId: string,
+        xApiVersion?: string,
+        requestBody?: CommissionUpdateDto,
+    ): CancelablePromise<CommissionDto> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/AccountingService/Commissions/Commissions/{commissionId}',
+            path: {
+                'commissionId': commissionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param commissionId
+     * @param xApiVersion
+     * @returns CommissionDto OK
+     * @throws ApiError
+     */
+    public static deleteApiV2AccountingServiceCommissionsCommissions(
+        tenantId: string,
+        commissionId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<CommissionDto> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/AccountingService/Commissions/Commissions/{commissionId}',
+            path: {
+                'commissionId': commissionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns PaymentCommissionDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceCommissionsPaymentCommissions(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<PaymentCommissionDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Commissions/PaymentCommissions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns PaymentCommissionDto Created
+     * @throws ApiError
+     */
+    public static postApiV2AccountingServiceCommissionsPaymentCommissions(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: PaymentCommissionCreateDto,
+    ): CancelablePromise<PaymentCommissionDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/AccountingService/Commissions/PaymentCommissions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceCommissionsPaymentCommissionsCount(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Commissions/PaymentCommissions/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param paymentcommissionId
+     * @param xApiVersion
+     * @returns PaymentCommissionDto OK
+     * @throws ApiError
+     */
+    public static getApiV2AccountingServiceCommissionsPaymentCommissions1(
+        tenantId: string,
+        paymentcommissionId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<PaymentCommissionDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/AccountingService/Commissions/PaymentCommissions/{paymentcommissionId}',
+            path: {
+                'paymentcommissionId': paymentcommissionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param paymentcommissionId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns PaymentCommissionDto OK
+     * @throws ApiError
+     */
+    public static putApiV2AccountingServiceCommissionsPaymentCommissions(
+        tenantId: string,
+        paymentcommissionId: string,
+        xApiVersion?: string,
+        requestBody?: PaymentCommissionUpdateDto,
+    ): CancelablePromise<PaymentCommissionDto> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/AccountingService/Commissions/PaymentCommissions/{paymentcommissionId}',
+            path: {
+                'paymentcommissionId': paymentcommissionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param paymentcommissionId
+     * @param xApiVersion
+     * @returns PaymentCommissionDto OK
+     * @throws ApiError
+     */
+    public static deleteApiV2AccountingServiceCommissionsPaymentCommissions(
+        tenantId: string,
+        paymentcommissionId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<PaymentCommissionDto> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/AccountingService/Commissions/PaymentCommissions/{paymentcommissionId}',
+            path: {
+                'paymentcommissionId': paymentcommissionId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}