@emilgroup/accounting-sdk-node 1.32.1-beta.27 → 1.32.1-beta.28

package/.openapi-generator/FILES

@@ -67,6 +67,8 @@ models/list-product-account-mappings-response-class.ts
 models/list-products-with-account-mappings-response-class.ts
 models/number-range-class.ts
 models/personal-account-class.ts
+models/post-financial-event-request-dto.ts
+models/post-financial-event-response-class.ts
 models/premium-item-account-mapping-class.ts
 models/product-account-mapping-class.ts
 models/product-account-mapping-detail-class.ts

package/README.md

@@ -17,11 +17,11 @@ Although this package can be used in both TypeScript and JavaScript, it is inten
 Navigate to the folder of your consuming project and run one of the following commands:
 
 ```
-npm install @emilgroup/accounting-sdk-node@1.32.1-beta.27 --save
+npm install @emilgroup/accounting-sdk-node@1.32.1-beta.28 --save
 ```
 or 
 ```
-yarn add @emilgroup/accounting-sdk-node@1.32.1-beta.27
+yarn add @emilgroup/accounting-sdk-node@1.32.1-beta.28
 ```
 
 And then you can import `FinancialAccountsApi`.

package/api/booking-entries-api.ts

@@ -28,6 +28,10 @@ import { CreateBookingEntryResponseClass } from '../models';
 import { GetBookingEntryResponseClass } from '../models';
 // @ts-ignore
 import { ListBookingEntriesResponseClass } from '../models';
+// @ts-ignore
+import { PostFinancialEventRequestDto } from '../models';
+// @ts-ignore
+import { PostFinancialEventResponseClass } from '../models';
 // URLSearchParams not necessarily used
 // @ts-ignore
 import { URL, URLSearchParams } from 'url';
@@ -208,6 +212,53 @@ export const BookingEntriesApiAxiosParamCreator = function (configuration?: Conf
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
 
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+         * @summary Create the booking entry from a source entity
+         * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto 
+         * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postFinancialEvent: async (postFinancialEventRequestDto: PostFinancialEventRequestDto, authorization?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'postFinancialEventRequestDto' is not null or undefined
+            assertParamExists('postFinancialEvent', 'postFinancialEventRequestDto', postFinancialEventRequestDto)
+            const localVarPath = `/accountingservice/v1/booking-entries/post-financial-event`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            let baseAccessToken;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+                baseAccessToken = configuration.accessToken;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+            if (authorization !== undefined && authorization !== null || baseAccessToken !== undefined && baseAccessToken !== null) {
+                localVarHeaderParameter['Authorization'] = String(authorization ? authorization : baseAccessToken);
+            }
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(postFinancialEventRequestDto, localVarRequestOptions, configuration)
+
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -266,6 +317,18 @@ export const BookingEntriesApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.listBookingEntries(authorization, pageSize, pageToken, filter, search, order, expand, filters, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+         * @summary Create the booking entry from a source entity
+         * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto 
+         * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async postFinancialEvent(postFinancialEventRequestDto: PostFinancialEventRequestDto, authorization?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostFinancialEventResponseClass>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.postFinancialEvent(postFinancialEventRequestDto, authorization, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
     }
 };
 
@@ -316,6 +379,17 @@ export const BookingEntriesApiFactory = function (configuration?: Configuration,
         listBookingEntries(authorization?: string, pageSize?: number, pageToken?: string, filter?: string, search?: string, order?: string, expand?: string, filters?: string, options?: any): AxiosPromise<ListBookingEntriesResponseClass> {
             return localVarFp.listBookingEntries(authorization, pageSize, pageToken, filter, search, order, expand, filters, options).then((request) => request(axios, basePath));
         },
+        /**
+         * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+         * @summary Create the booking entry from a source entity
+         * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto 
+         * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postFinancialEvent(postFinancialEventRequestDto: PostFinancialEventRequestDto, authorization?: string, options?: any): AxiosPromise<PostFinancialEventResponseClass> {
+            return localVarFp.postFinancialEvent(postFinancialEventRequestDto, authorization, options).then((request) => request(axios, basePath));
+        },
     };
 };
 
@@ -431,6 +505,27 @@ export interface BookingEntriesApiListBookingEntriesRequest {
     readonly filters?: string
 }
 
+/**
+ * Request parameters for postFinancialEvent operation in BookingEntriesApi.
+ * @export
+ * @interface BookingEntriesApiPostFinancialEventRequest
+ */
+export interface BookingEntriesApiPostFinancialEventRequest {
+    /**
+     * 
+     * @type {PostFinancialEventRequestDto}
+     * @memberof BookingEntriesApiPostFinancialEvent
+     */
+    readonly postFinancialEventRequestDto: PostFinancialEventRequestDto
+
+    /**
+     * Bearer Token: provided by the login endpoint under the name accessToken.
+     * @type {string}
+     * @memberof BookingEntriesApiPostFinancialEvent
+     */
+    readonly authorization?: string
+}
+
 /**
  * BookingEntriesApi - object-oriented interface
  * @export
@@ -473,4 +568,16 @@ export class BookingEntriesApi extends BaseAPI {
     public listBookingEntries(requestParameters: BookingEntriesApiListBookingEntriesRequest = {}, options?: AxiosRequestConfig) {
         return BookingEntriesApiFp(this.configuration).listBookingEntries(requestParameters.authorization, requestParameters.pageSize, requestParameters.pageToken, requestParameters.filter, requestParameters.search, requestParameters.order, requestParameters.expand, requestParameters.filters, options).then((request) => request(this.axios, this.basePath));
     }
+
+    /**
+     * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+     * @summary Create the booking entry from a source entity
+     * @param {BookingEntriesApiPostFinancialEventRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BookingEntriesApi
+     */
+    public postFinancialEvent(requestParameters: BookingEntriesApiPostFinancialEventRequest, options?: AxiosRequestConfig) {
+        return BookingEntriesApiFp(this.configuration).postFinancialEvent(requestParameters.postFinancialEventRequestDto, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+    }
 }

package/dist/api/booking-entries-api.d.ts

@@ -16,6 +16,8 @@ import { CreateBookingEntryRequestDto } from '../models';
 import { CreateBookingEntryResponseClass } from '../models';
 import { GetBookingEntryResponseClass } from '../models';
 import { ListBookingEntriesResponseClass } from '../models';
+import { PostFinancialEventRequestDto } from '../models';
+import { PostFinancialEventResponseClass } from '../models';
 /**
  * BookingEntriesApi - axios parameter creator
  * @export
@@ -55,6 +57,15 @@ export declare const BookingEntriesApiAxiosParamCreator: (configuration?: Config
      * @throws {RequiredError}
      */
     listBookingEntries: (authorization?: string, pageSize?: number, pageToken?: string, filter?: string, search?: string, order?: string, expand?: string, filters?: string, options?: AxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+     * @summary Create the booking entry from a source entity
+     * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto
+     * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postFinancialEvent: (postFinancialEventRequestDto: PostFinancialEventRequestDto, authorization?: string, options?: AxiosRequestConfig) => Promise<RequestArgs>;
 };
 /**
  * BookingEntriesApi - functional programming interface
@@ -95,6 +106,15 @@ export declare const BookingEntriesApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     listBookingEntries(authorization?: string, pageSize?: number, pageToken?: string, filter?: string, search?: string, order?: string, expand?: string, filters?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListBookingEntriesResponseClass>>;
+    /**
+     * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+     * @summary Create the booking entry from a source entity
+     * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto
+     * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postFinancialEvent(postFinancialEventRequestDto: PostFinancialEventRequestDto, authorization?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostFinancialEventResponseClass>>;
 };
 /**
  * BookingEntriesApi - factory interface
@@ -135,6 +155,15 @@ export declare const BookingEntriesApiFactory: (configuration?: Configuration, b
      * @throws {RequiredError}
      */
     listBookingEntries(authorization?: string, pageSize?: number, pageToken?: string, filter?: string, search?: string, order?: string, expand?: string, filters?: string, options?: any): AxiosPromise<ListBookingEntriesResponseClass>;
+    /**
+     * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+     * @summary Create the booking entry from a source entity
+     * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto
+     * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postFinancialEvent(postFinancialEventRequestDto: PostFinancialEventRequestDto, authorization?: string, options?: any): AxiosPromise<PostFinancialEventResponseClass>;
 };
 /**
  * Request parameters for createBookingEntry operation in BookingEntriesApi.
@@ -235,6 +264,25 @@ export interface BookingEntriesApiListBookingEntriesRequest {
      */
     readonly filters?: string;
 }
+/**
+ * Request parameters for postFinancialEvent operation in BookingEntriesApi.
+ * @export
+ * @interface BookingEntriesApiPostFinancialEventRequest
+ */
+export interface BookingEntriesApiPostFinancialEventRequest {
+    /**
+     *
+     * @type {PostFinancialEventRequestDto}
+     * @memberof BookingEntriesApiPostFinancialEvent
+     */
+    readonly postFinancialEventRequestDto: PostFinancialEventRequestDto;
+    /**
+     * Bearer Token: provided by the login endpoint under the name accessToken.
+     * @type {string}
+     * @memberof BookingEntriesApiPostFinancialEvent
+     */
+    readonly authorization?: string;
+}
 /**
  * BookingEntriesApi - object-oriented interface
  * @export
@@ -269,4 +317,13 @@ export declare class BookingEntriesApi extends BaseAPI {
      * @memberof BookingEntriesApi
      */
     listBookingEntries(requestParameters?: BookingEntriesApiListBookingEntriesRequest, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<ListBookingEntriesResponseClass, any, {}>>;
+    /**
+     * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+     * @summary Create the booking entry from a source entity
+     * @param {BookingEntriesApiPostFinancialEventRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BookingEntriesApi
+     */
+    postFinancialEvent(requestParameters: BookingEntriesApiPostFinancialEventRequest, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<PostFinancialEventResponseClass, any, {}>>;
 }

package/dist/api/booking-entries-api.js

@@ -271,6 +271,55 @@ var BookingEntriesApiAxiosParamCreator = function (configuration) {
                 });
             });
         },
+        /**
+         * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+         * @summary Create the booking entry from a source entity
+         * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto
+         * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postFinancialEvent: function (postFinancialEventRequestDto, authorization, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var localVarPath, localVarUrlObj, baseOptions, baseAccessToken, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            // verify required parameter 'postFinancialEventRequestDto' is not null or undefined
+                            (0, common_1.assertParamExists)('postFinancialEvent', 'postFinancialEventRequestDto', postFinancialEventRequestDto);
+                            localVarPath = "/accountingservice/v1/booking-entries/post-financial-event";
+                            localVarUrlObj = new url_1.URL(localVarPath, common_1.DUMMY_BASE_URL);
+                            if (configuration) {
+                                baseOptions = configuration.baseOptions;
+                                baseAccessToken = configuration.accessToken;
+                            }
+                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), options);
+                            localVarHeaderParameter = {};
+                            localVarQueryParameter = {};
+                            // authentication bearer required
+                            // http bearer authentication required
+                            return [4 /*yield*/, (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, configuration)];
+                        case 1:
+                            // authentication bearer required
+                            // http bearer authentication required
+                            _a.sent();
+                            if (authorization !== undefined && authorization !== null || baseAccessToken !== undefined && baseAccessToken !== null) {
+                                localVarHeaderParameter['Authorization'] = String(authorization ? authorization : baseAccessToken);
+                            }
+                            localVarHeaderParameter['Content-Type'] = 'application/json';
+                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), options.headers);
+                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(postFinancialEventRequestDto, localVarRequestOptions, configuration);
+                            return [2 /*return*/, {
+                                    url: (0, common_1.toPathString)(localVarUrlObj),
+                                    options: localVarRequestOptions,
+                                }];
+                    }
+                });
+            });
+        },
     };
 };
 exports.BookingEntriesApiAxiosParamCreator = BookingEntriesApiAxiosParamCreator;
@@ -351,6 +400,27 @@ var BookingEntriesApiFp = function (configuration) {
                 });
             });
         },
+        /**
+         * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+         * @summary Create the booking entry from a source entity
+         * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto
+         * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postFinancialEvent: function (postFinancialEventRequestDto, authorization, options) {
+            return __awaiter(this, void 0, void 0, function () {
+                var localVarAxiosArgs;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.postFinancialEvent(postFinancialEventRequestDto, authorization, options)];
+                        case 1:
+                            localVarAxiosArgs = _a.sent();
+                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
+                    }
+                });
+            });
+        },
     };
 };
 exports.BookingEntriesApiFp = BookingEntriesApiFp;
@@ -401,6 +471,17 @@ var BookingEntriesApiFactory = function (configuration, basePath, axios) {
         listBookingEntries: function (authorization, pageSize, pageToken, filter, search, order, expand, filters, options) {
             return localVarFp.listBookingEntries(authorization, pageSize, pageToken, filter, search, order, expand, filters, options).then(function (request) { return request(axios, basePath); });
         },
+        /**
+         * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+         * @summary Create the booking entry from a source entity
+         * @param {PostFinancialEventRequestDto} postFinancialEventRequestDto
+         * @param {string} [authorization] Bearer Token: provided by the login endpoint under the name accessToken.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postFinancialEvent: function (postFinancialEventRequestDto, authorization, options) {
+            return localVarFp.postFinancialEvent(postFinancialEventRequestDto, authorization, options).then(function (request) { return request(axios, basePath); });
+        },
     };
 };
 exports.BookingEntriesApiFactory = BookingEntriesApiFactory;
@@ -452,6 +533,18 @@ var BookingEntriesApi = /** @class */ (function (_super) {
         if (requestParameters === void 0) { requestParameters = {}; }
         return (0, exports.BookingEntriesApiFp)(this.configuration).listBookingEntries(requestParameters.authorization, requestParameters.pageSize, requestParameters.pageToken, requestParameters.filter, requestParameters.search, requestParameters.order, requestParameters.expand, requestParameters.filters, options).then(function (request) { return request(_this.axios, _this.basePath); });
     };
+    /**
+     * This endpoint posts the booking entry for an existing invoice, payment,     exceeding credit or credit allocation on demand. The entity is fetched from the service     that owns it and run through the same posting flow its domain event triggers, so the     call is idempotent: an entity that is already posted returns its existing booking entry.     When the flow deliberately posts nothing (subledger not active for the booking date,     non-positive amount) the call fails with a precondition error carrying the reason.  **Required Permissions**  \"accounting-management.entries.create\"
+     * @summary Create the booking entry from a source entity
+     * @param {BookingEntriesApiPostFinancialEventRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BookingEntriesApi
+     */
+    BookingEntriesApi.prototype.postFinancialEvent = function (requestParameters, options) {
+        var _this = this;
+        return (0, exports.BookingEntriesApiFp)(this.configuration).postFinancialEvent(requestParameters.postFinancialEventRequestDto, requestParameters.authorization, options).then(function (request) { return request(_this.axios, _this.basePath); });
+    };
     return BookingEntriesApi;
 }(base_1.BaseAPI));
 exports.BookingEntriesApi = BookingEntriesApi;

package/dist/models/index.d.ts

@@ -47,6 +47,8 @@ export * from './list-product-account-mappings-response-class';
 export * from './list-products-with-account-mappings-response-class';
 export * from './number-range-class';
 export * from './personal-account-class';
+export * from './post-financial-event-request-dto';
+export * from './post-financial-event-response-class';
 export * from './premium-item-account-mapping-class';
 export * from './product-account-mapping-class';
 export * from './product-account-mapping-detail-class';

package/dist/models/index.js

@@ -63,6 +63,8 @@ __exportStar(require("./list-product-account-mappings-response-class"), exports)
 __exportStar(require("./list-products-with-account-mappings-response-class"), exports);
 __exportStar(require("./number-range-class"), exports);
 __exportStar(require("./personal-account-class"), exports);
+__exportStar(require("./post-financial-event-request-dto"), exports);
+__exportStar(require("./post-financial-event-response-class"), exports);
 __exportStar(require("./premium-item-account-mapping-class"), exports);
 __exportStar(require("./product-account-mapping-class"), exports);
 __exportStar(require("./product-account-mapping-detail-class"), exports);

package/dist/models/post-financial-event-request-dto.d.ts

@@ -0,0 +1,43 @@
+/**
+ * EMIL AccountingService
+ * The EMIL AccountingService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface PostFinancialEventRequestDto
+ */
+export interface PostFinancialEventRequestDto {
+    /**
+     * The kind of source entity to post a booking entry for. Each kind is posted     through the same flow its domain event goes through.
+     * @type {string}
+     * @memberof PostFinancialEventRequestDto
+     */
+    'sourceEntityType': PostFinancialEventRequestDtoSourceEntityTypeEnum;
+    /**
+     * The code of the source entity in the service that owns it, such as an invoice,     payment, exceeding credit or credit allocation code.
+     * @type {string}
+     * @memberof PostFinancialEventRequestDto
+     */
+    'sourceEntityCode': string;
+    /**
+     * The partner whose personal account the entry posts to. Required for an exceeding     credit, which does not name its partner itself. Optional for a payment or credit allocation,     where it must match the entity\'s own partner. Not accepted for an invoice, whose partner is     derived from the policy.
+     * @type {string}
+     * @memberof PostFinancialEventRequestDto
+     */
+    'partnerCode'?: string;
+}
+export declare const PostFinancialEventRequestDtoSourceEntityTypeEnum: {
+    readonly Invoice: "invoice";
+    readonly Payment: "payment";
+    readonly Credit: "credit";
+    readonly CreditAllocation: "credit_allocation";
+};
+export type PostFinancialEventRequestDtoSourceEntityTypeEnum = typeof PostFinancialEventRequestDtoSourceEntityTypeEnum[keyof typeof PostFinancialEventRequestDtoSourceEntityTypeEnum];

package/dist/models/post-financial-event-request-dto.js

@@ -0,0 +1,22 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * EMIL AccountingService
+ * The EMIL AccountingService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostFinancialEventRequestDtoSourceEntityTypeEnum = void 0;
+exports.PostFinancialEventRequestDtoSourceEntityTypeEnum = {
+    Invoice: 'invoice',
+    Payment: 'payment',
+    Credit: 'credit',
+    CreditAllocation: 'credit_allocation'
+};

package/dist/models/post-financial-event-response-class.d.ts

@@ -0,0 +1,25 @@
+/**
+ * EMIL AccountingService
+ * The EMIL AccountingService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { BookingEntryClass } from './booking-entry-class';
+/**
+ *
+ * @export
+ * @interface PostFinancialEventResponseClass
+ */
+export interface PostFinancialEventResponseClass {
+    /**
+     * Every booking entry the posting wrote, in posting order. A payment settlement that releases premium tax writes a second entry.
+     * @type {Array<BookingEntryClass>}
+     * @memberof PostFinancialEventResponseClass
+     */
+    'bookingEntries': Array<BookingEntryClass>;
+}

package/dist/models/post-financial-event-response-class.js

@@ -0,0 +1,15 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * EMIL AccountingService
+ * The EMIL AccountingService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/models/index.ts

@@ -47,6 +47,8 @@ export * from './list-product-account-mappings-response-class';
 export * from './list-products-with-account-mappings-response-class';
 export * from './number-range-class';
 export * from './personal-account-class';
+export * from './post-financial-event-request-dto';
+export * from './post-financial-event-response-class';
 export * from './premium-item-account-mapping-class';
 export * from './product-account-mapping-class';
 export * from './product-account-mapping-detail-class';

package/models/post-financial-event-request-dto.ts

@@ -0,0 +1,52 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * EMIL AccountingService
+ * The EMIL AccountingService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+
+/**
+ * 
+ * @export
+ * @interface PostFinancialEventRequestDto
+ */
+export interface PostFinancialEventRequestDto {
+    /**
+     * The kind of source entity to post a booking entry for. Each kind is posted     through the same flow its domain event goes through.
+     * @type {string}
+     * @memberof PostFinancialEventRequestDto
+     */
+    'sourceEntityType': PostFinancialEventRequestDtoSourceEntityTypeEnum;
+    /**
+     * The code of the source entity in the service that owns it, such as an invoice,     payment, exceeding credit or credit allocation code.
+     * @type {string}
+     * @memberof PostFinancialEventRequestDto
+     */
+    'sourceEntityCode': string;
+    /**
+     * The partner whose personal account the entry posts to. Required for an exceeding     credit, which does not name its partner itself. Optional for a payment or credit allocation,     where it must match the entity\'s own partner. Not accepted for an invoice, whose partner is     derived from the policy.
+     * @type {string}
+     * @memberof PostFinancialEventRequestDto
+     */
+    'partnerCode'?: string;
+}
+
+export const PostFinancialEventRequestDtoSourceEntityTypeEnum = {
+    Invoice: 'invoice',
+    Payment: 'payment',
+    Credit: 'credit',
+    CreditAllocation: 'credit_allocation'
+} as const;
+
+export type PostFinancialEventRequestDtoSourceEntityTypeEnum = typeof PostFinancialEventRequestDtoSourceEntityTypeEnum[keyof typeof PostFinancialEventRequestDtoSourceEntityTypeEnum];
+
+

package/models/post-financial-event-response-class.ts

@@ -0,0 +1,31 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * EMIL AccountingService
+ * The EMIL AccountingService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import { BookingEntryClass } from './booking-entry-class';
+
+/**
+ * 
+ * @export
+ * @interface PostFinancialEventResponseClass
+ */
+export interface PostFinancialEventResponseClass {
+    /**
+     * Every booking entry the posting wrote, in posting order. A payment settlement that releases premium tax writes a second entry.
+     * @type {Array<BookingEntryClass>}
+     * @memberof PostFinancialEventResponseClass
+     */
+    'bookingEntries': Array<BookingEntryClass>;
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emilgroup/accounting-sdk-node",
-  "version": "1.32.1-beta.27",
+  "version": "1.32.1-beta.28",
   "description": "OpenAPI client for @emilgroup/accounting-sdk-node",
   "author": "OpenAPI-Generator Contributors",
   "keywords": [