moneybirdjs 1.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 vanBrusselGames
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# moneybirdjs
+ A wrapper for the Moneybird API

package/dist/client/Client.d.ts

@@ -0,0 +1,8 @@
+import { Administration } from "../struct";
+import { RESTManager } from "../rest/RESTManager";
+/** */
+export declare class Client {
+    rest: RESTManager;
+    constructor(apiToken: string);
+    getAdministrations(): Promise<Administration[]>;
+}

package/dist/client/Client.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const struct_1 = require("../struct");
+const RESTManager_1 = require("../rest/RESTManager");
+// noinspection JSUnusedGlobalSymbols
+/** */
+class Client {
+    constructor(apiToken) {
+        this.rest = new RESTManager_1.RESTManager(apiToken);
+    }
+    async getAdministrations() {
+        const { data } = await this.rest.getAdministrations();
+        return data.map((entry) => new struct_1.Administration(this, entry));
+    }
+}
+exports.Client = Client;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './client/Client';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/Client"), exports);

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import mod from "./index.js";
+
+export default mod;
+export const Client = mod.Client;

package/dist/rest/RESTManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import { RequestHandler } from "./RequestHandler";
+import { AddAttachmentOptions, AddContactOptions, AddLedgerAccountOptions, AddNoteOptions, APIAdministration, APIContact, APIContactPerson, APICustomField, APIDocument, APIDocumentStyle, APIFinancialMutation, APILedgerAccount, APINote, APISalesInvoice, APITaxRate, ContactPersonOptions, ContactSearchOptions, Document, DocumentAddOptions, DocumentEntityType, DocumentSearchOptions, DocumentUpdateOptions, EntityType, Filter, FinancialMutationLinkBookingOptions, FinancialMutationUnlinkBookingOptions, SendSalesInvoiceOptions, TaxRateSearchOptions, UpdateContactOptions, UpdateLedgerAccountOptions } from "../types";
+import { Administration, Contact, ContactPerson, FinancialMutation, SalesInvoice } from "../struct";
+import { LedgerAccount } from "../struct";
+export declare class RESTManager {
+    requestHandler: RequestHandler;
+    constructor(apiToken: string);
+    getAdministrations(): Promise<import("../types").Response<APIAdministration[]>>;
+    addAttachment(doc: Document, options: AddAttachmentOptions): Promise<import("../types").Response<void>>;
+    deleteAttachment(doc: Document, attachmentId: string): Promise<import("../types").Response<void>>;
+    downloadAttachment(doc: Document, attachmentId: string): Promise<import("../types").Response<Buffer>>;
+    synchronize(administration: Administration, entityType: EntityType, filter?: Filter): Promise<import("../types").Response<{
+        id: string;
+        version: number;
+    }[]>>;
+    listContactsByIds(administration: Administration, ids: Array<string>): Promise<import("../types").Response<APIContact[]>>;
+    getContacts(administration: Administration, urlOptions: ContactSearchOptions): Promise<import("../types").Response<APIContact[]>>;
+    getContact(administration: Administration, id: string): Promise<import("../types").Response<APIContact>>;
+    getContactByCustomerId(administration: Administration, customerId: string): Promise<import("../types").Response<APIContact>>;
+    addContact(administration: Administration, options: AddContactOptions): Promise<import("../types").Response<APIContact>>;
+    updateContact(contact: Contact, options: UpdateContactOptions): Promise<import("../types").Response<APIContact>>;
+    deleteContact(administration: Administration, contactId: string): Promise<import("../types").Response<void>>;
+    getContactPerson(contact: Contact, contactPersonId: string): Promise<import("../types").Response<APIContactPerson>>;
+    addContactPerson(contact: Contact, options: ContactPersonOptions): Promise<import("../types").Response<APIContactPerson>>;
+    updateContactPerson(contactPerson: ContactPerson, options: ContactPersonOptions): Promise<import("../types").Response<APIContactPerson>>;
+    deleteContactPerson(contact: Contact, contactPersonId: string): Promise<import("../types").Response<void>>;
+    getCustomFields(administration: Administration): Promise<import("../types").Response<APICustomField[]>>;
+    getDocumentStyles(administration: Administration): Promise<import("../types").Response<APIDocumentStyle[]>>;
+    listDocumentsByIds<T extends APIDocument>(administration: Administration, documentType: DocumentEntityType, ids: Array<string>): Promise<import("../types").Response<T[]>>;
+    getDocuments<T extends APIDocument>(administration: Administration, documentType: DocumentEntityType, urlOptions: DocumentSearchOptions): Promise<import("../types").Response<T[]>>;
+    getDocument<T extends APIDocument>(administration: Administration, documentType: DocumentEntityType, id: string): Promise<import("../types").Response<T>>;
+    addDocument<T extends APIDocument>(administration: Administration, documentType: DocumentEntityType, options: DocumentAddOptions): Promise<import("../types").Response<T>>;
+    updateDocument<T extends APIDocument>(document: Document, options: DocumentUpdateOptions, query?: string): Promise<import("../types").Response<T>>;
+    deleteDocument(administration: Administration, documentType: DocumentEntityType, documentId: string, refresh_journal_entries?: boolean): Promise<import("../types").Response<void>>;
+    addNote(entity: Contact | Document, options: AddNoteOptions): Promise<import("../types").Response<APINote>>;
+    deleteNote(entity: Contact | Document, noteId: string): Promise<import("../types").Response<void>>;
+    getFinancialMutations(administration: Administration, filter: Filter): Promise<import("../types").Response<APIFinancialMutation[]>>;
+    listFinancialMutationsByIds(administration: Administration, ids: Array<string>): Promise<import("../types").Response<APIFinancialMutation[]>>;
+    getFinancialMutation(administration: Administration, id: string): Promise<import("../types").Response<APIFinancialMutation>>;
+    financialMutationLinkBooking(financialMutation: FinancialMutation, options: FinancialMutationLinkBookingOptions): Promise<import("../types").Response<void>>;
+    financialMutationUnlinkBooking(financialMutation: FinancialMutation, options: FinancialMutationUnlinkBookingOptions): Promise<import("../types").Response<void>>;
+    getTaxRates(administration: Administration, filter: TaxRateSearchOptions): Promise<import("../types").Response<APITaxRate[]>>;
+    getLedgerAccounts(administration: Administration): Promise<import("../types").Response<APILedgerAccount[]>>;
+    getLedgerAccount(administration: Administration, id: string): Promise<import("../types").Response<APILedgerAccount>>;
+    addLedgerAccount(administration: Administration, options: AddLedgerAccountOptions, rgs_code: string): Promise<import("../types").Response<APILedgerAccount>>;
+    updateLedgerAccount(ledgerAccount: LedgerAccount, options: UpdateLedgerAccountOptions, rgs_code: string): Promise<import("../types").Response<APILedgerAccount>>;
+    deleteLedgerAccount(administration: Administration, ledgerAccountId: string): Promise<import("../types").Response<void>>;
+    getSalesInvoiceByInvoiceId(administration: Administration, salesInvoiceId: string): Promise<import("../types").Response<APISalesInvoice>>;
+    getSalesInvoiceByReference(administration: Administration, salesInvoiceReference: string): Promise<import("../types").Response<APISalesInvoice>>;
+    sendInvoice(invoice: SalesInvoice, options: SendSalesInvoiceOptions): Promise<import("../types").Response<APISalesInvoice>>;
+    registerPaymentCreditInvoice(invoice: SalesInvoice): Promise<import("../types").Response<APISalesInvoice>>;
+    duplicateToCreditInvoice(invoice: SalesInvoice): Promise<import("../types").Response<APISalesInvoice>>;
+}

package/dist/rest/RESTManager.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESTManager = void 0;
+const RequestHandler_1 = require("./RequestHandler");
+const Util_1 = require("../util/Util");
+const form_data_1 = __importDefault(require("form-data"));
+class RESTManager {
+    constructor(apiToken) {
+        this.requestHandler = new RequestHandler_1.RequestHandler(apiToken);
+    }
+    getAdministrations() {
+        return this.requestHandler.request('administrations', { method: "GET", body: "{}" });
+    }
+    addAttachment(doc, options) {
+        const form = new form_data_1.default();
+        form.append('file', options.attachmentBuffer, { filename: options.attachmentName ?? 'attachment' });
+        const docPath = Util_1.Util.entityRestUrl(Util_1.Util.entityToEntityType(doc));
+        const att = docPath === 'external_sales_invoices' ? 'attachment' : 'attachments';
+        return this.requestHandler.request(`${doc.administration_id}/${docPath}/${doc.id}/${att}`, {
+            method: "POST",
+            body: form.getBuffer(),
+            additionalHeaders: form.getHeaders()
+        });
+    }
+    deleteAttachment(doc, attachmentId) {
+        const docPath = Util_1.Util.entityRestUrl(Util_1.Util.entityToEntityType(doc));
+        return this.requestHandler.request(`${doc.administration_id}/${docPath}/${doc.id}/attachments/${attachmentId}`, {
+            method: "DELETE",
+            body: "{}"
+        });
+    }
+    downloadAttachment(doc, attachmentId) {
+        const docPath = Util_1.Util.entityRestUrl(Util_1.Util.entityToEntityType(doc));
+        return this.requestHandler.request(`${doc.administration_id}/${docPath}/${doc.id}/attachments/${attachmentId}/download`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    synchronize(administration, entityType, filter) {
+        const entityPath = Util_1.Util.entityRestUrl(entityType);
+        const query = filter === undefined ? '' : Util_1.Util.queryString({ filter: filter });
+        return this.requestHandler.request(`${administration.id}/${entityPath}/synchronization${query}`, { method: "GET", body: "{}" });
+    }
+    listContactsByIds(administration, ids) {
+        return this.requestHandler.request(`${administration.id}/contacts/synchronization`, {
+            method: "POST",
+            body: JSON.stringify({ ids: ids })
+        });
+    }
+    getContacts(administration, urlOptions) {
+        const query = Util_1.Util.queryString(urlOptions);
+        return this.requestHandler.request(`${administration.id}/contacts${query}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getContact(administration, id) {
+        return this.requestHandler.request(`${administration.id}/contacts/${id}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getContactByCustomerId(administration, customerId) {
+        return this.requestHandler.request(`${administration.id}/contacts/customer_id/${customerId}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    addContact(administration, options) {
+        return this.requestHandler.request(`${administration.id}/contacts`, {
+            method: "POST",
+            body: JSON.stringify({ contact: options })
+        });
+    }
+    updateContact(contact, options) {
+        return this.requestHandler.request(`${contact.administration_id}/contacts/${contact.id}`, {
+            method: "PATCH",
+            body: JSON.stringify({ contact: options })
+        });
+    }
+    deleteContact(administration, contactId) {
+        return this.requestHandler.request(`${administration.id}/contacts/${contactId}`, {
+            method: "DELETE",
+            body: "{}"
+        });
+    }
+    getContactPerson(contact, contactPersonId) {
+        return this.requestHandler.request(`${contact.administration_id}/contacts/${contact.id}/contact_people/${contactPersonId}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    addContactPerson(contact, options) {
+        return this.requestHandler.request(`${contact.administration_id}/contacts/${contact.id}/contact_people`, {
+            method: "POST",
+            body: JSON.stringify({ contact_person: options })
+        });
+    }
+    updateContactPerson(contactPerson, options) {
+        return this.requestHandler.request(`${contactPerson.administration_id}/contacts/${contactPerson.contact.id}/contact_people/${contactPerson.id}`, {
+            method: "PATCH",
+            body: JSON.stringify({ contact_person: options })
+        });
+    }
+    deleteContactPerson(contact, contactPersonId) {
+        return this.requestHandler.request(`${contact.administration.id}/contacts/${contact.id}/contact_people/${contactPersonId}`, {
+            method: "DELETE",
+            body: "{}"
+        });
+    }
+    getCustomFields(administration) {
+        return this.requestHandler.request(`${administration.id}/custom_fields`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getDocumentStyles(administration) {
+        return this.requestHandler.request(`${administration.id}/document_styles`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    //#region Document
+    listDocumentsByIds(administration, documentType, ids) {
+        const documentPath = Util_1.Util.entityRestUrl(documentType);
+        return this.requestHandler.request(`${administration.id}/${documentPath}/synchronization`, {
+            method: "POST",
+            body: JSON.stringify({ ids: ids })
+        });
+    }
+    getDocuments(administration, documentType, urlOptions) {
+        const documentPath = Util_1.Util.entityRestUrl(documentType);
+        const query = Util_1.Util.queryString(urlOptions);
+        return this.requestHandler.request(`${administration.id}/${documentPath}${query}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getDocument(administration, documentType, id) {
+        const documentPath = Util_1.Util.entityRestUrl(documentType);
+        return this.requestHandler.request(`${administration.id}/${documentPath}/${id}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    addDocument(administration, documentType, options) {
+        const documentPath = Util_1.Util.entityRestUrl(documentType);
+        let body = Util_1.Util.entityRequestBody(documentType, options);
+        return this.requestHandler.request(`${administration.id}/${documentPath}`, {
+            method: "POST",
+            body: JSON.stringify(body)
+        });
+    }
+    updateDocument(document, options, query = "") {
+        const docType = Util_1.Util.entityToEntityType(document);
+        const documentPath = Util_1.Util.entityRestUrl(docType);
+        let body = Util_1.Util.entityRequestBody(docType, options);
+        return this.requestHandler.request(`${document.administration_id}/${documentPath}/${document.id}${query}`, {
+            method: "PATCH",
+            body: JSON.stringify(body)
+        });
+    }
+    deleteDocument(administration, documentType, documentId, refresh_journal_entries) {
+        const query = refresh_journal_entries ? `?refresh_journal_entries=true` : "";
+        const documentPath = Util_1.Util.entityRestUrl(documentType);
+        return this.requestHandler.request(`${administration.id}/${documentPath}/${documentId}${query}`, {
+            method: "DELETE",
+            body: "{}"
+        });
+    }
+    //#endregion Document
+    //todo: Payments
+    /*
+    public addPayment(entity: PurchaseInvoice | Receipt, options: AddPaymentOptions) {
+        const entityPath = Util.documentRestUrl(doc)
+        return this.requestHandler.request<APIPayment>(`${entity.administration_id}/${entityPath}/${entity.id}/payments`, {
+            method: "POST",
+            body: JSON.stringify({payment: options})
+        })
+    }
+
+    public deletePayment(entity: PurchaseInvoice | Receipt, paymentId: string) {
+        const entityPath = Util.documentRestUrl(doc)
+        return this.requestHandler.request<void>(`${entity.administration_id}/${entityPath}/${entity.id}/payments/${paymentId}`, {
+            method: "DELETE",
+            body: "{}"
+        })
+    }
+    */
+    addNote(entity, options) {
+        const entityPath = Util_1.Util.entityRestUrl(Util_1.Util.entityToEntityType(entity));
+        return this.requestHandler.request(`${entity.administration_id}/${entityPath}/${entity.id}/notes`, {
+            method: "POST",
+            body: JSON.stringify({ note: options })
+        });
+    }
+    deleteNote(entity, noteId) {
+        const entityPath = Util_1.Util.entityRestUrl(Util_1.Util.entityToEntityType(entity));
+        return this.requestHandler.request(`${entity.administration_id}/${entityPath}/${entity.id}/notes/${noteId}`, {
+            method: "DELETE",
+            body: "{}"
+        });
+    }
+    getFinancialMutations(administration, filter) {
+        const query = Util_1.Util.queryString({ filter: filter });
+        return this.requestHandler.request(`${administration.id}/financial_mutations${query}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    listFinancialMutationsByIds(administration, ids) {
+        return this.requestHandler.request(`${administration.id}/financial_mutations/synchronization`, {
+            method: "POST",
+            body: JSON.stringify({ ids: ids })
+        });
+    }
+    getFinancialMutation(administration, id) {
+        return this.requestHandler.request(`${administration.id}/financial_mutations/${id}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    financialMutationLinkBooking(financialMutation, options) {
+        return this.requestHandler.request(`${financialMutation.administration_id}/financial_mutations/${financialMutation.id}/link_booking`, {
+            method: "PATCH",
+            body: JSON.stringify(options)
+        });
+    }
+    financialMutationUnlinkBooking(financialMutation, options) {
+        return this.requestHandler.request(`${financialMutation.administration_id}/financial_mutations/${financialMutation.id}/unlink_booking`, {
+            method: "DELETE",
+            body: JSON.stringify(options)
+        });
+    }
+    getTaxRates(administration, filter) {
+        const query = Util_1.Util.queryString({ filter: filter });
+        return this.requestHandler.request(`${administration.id}/tax_rates${query}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getLedgerAccounts(administration) {
+        return this.requestHandler.request(`${administration.id}/ledger_accounts`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getLedgerAccount(administration, id) {
+        return this.requestHandler.request(`${administration.id}/ledger_accounts/${id}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    addLedgerAccount(administration, options, rgs_code) {
+        return this.requestHandler.request(`${administration.id}/ledger_accounts`, {
+            method: "POST",
+            body: JSON.stringify({ ledger_account: options, rgs_code: rgs_code })
+        });
+    }
+    updateLedgerAccount(ledgerAccount, options, rgs_code) {
+        return this.requestHandler.request(`${ledgerAccount.administration_id}/ledger_accounts/${ledgerAccount.id}`, {
+            method: "PATCH",
+            body: JSON.stringify({ ledger_account: options, rgs_code: rgs_code })
+        });
+    }
+    deleteLedgerAccount(administration, ledgerAccountId) {
+        return this.requestHandler.request(`${administration.id}/ledger_accounts/${ledgerAccountId}`, {
+            method: "DELETE",
+            body: "{}"
+        });
+    }
+    getSalesInvoiceByInvoiceId(administration, salesInvoiceId) {
+        return this.requestHandler.request(`${administration.id}/sales_invoices/find_by_invoice_id/${salesInvoiceId}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    getSalesInvoiceByReference(administration, salesInvoiceReference) {
+        return this.requestHandler.request(`${administration.id}/sales_invoices/find_by_reference/${salesInvoiceReference}`, {
+            method: "GET",
+            body: "{}"
+        });
+    }
+    sendInvoice(invoice, options) {
+        return this.requestHandler.request(`${invoice.administration_id}/sales_invoices/${invoice.id}/send_invoice`, {
+            method: "PATCH",
+            body: JSON.stringify({ sales_invoice_sending: options })
+        });
+    }
+    registerPaymentCreditInvoice(invoice) {
+        return this.requestHandler.request(`${invoice.administration_id}/sales_invoices/${invoice.id}/register_payment_creditinvoice`, {
+            method: "PATCH",
+            body: "{}"
+        });
+    }
+    duplicateToCreditInvoice(invoice) {
+        return this.requestHandler.request(`${invoice.administration_id}/sales_invoices/${invoice.id}/duplicate_creditinvoice`, {
+            method: "PATCH",
+            body: "{}"
+        });
+    }
+}
+exports.RESTManager = RESTManager;

package/dist/rest/RequestHandler.d.ts

@@ -0,0 +1,9 @@
+import { RequestOptions, Response } from "../types";
+export declare class RequestHandler {
+    #private;
+    rejectIfNotValid: boolean;
+    rateLimit: number;
+    constructor(apiToken: string);
+    request<T>(path: string, options: RequestOptions): Promise<Response<T>>;
+    private exec;
+}

package/dist/rest/RequestHandler.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RequestHandler_apiToken;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandler = void 0;
+const Constants = __importStar(require("../util/Constants"));
+class RequestHandler {
+    constructor(apiToken) {
+        this.rejectIfNotValid = true;
+        this.rateLimit = 10;
+        _RequestHandler_apiToken.set(this, void 0);
+        __classPrivateFieldSet(this, _RequestHandler_apiToken, apiToken, "f");
+    }
+    async request(path, options) {
+        return this.exec(path, options);
+    }
+    async exec(path, options, retries = 0) {
+        try {
+            let contentType = 'application/json';
+            if (options.additionalHeaders?.["content-type"]) {
+                contentType = options.additionalHeaders["content-type"];
+                delete options.additionalHeaders["content-type"];
+            }
+            const headers = {
+                'Authorization': `Bearer ${__classPrivateFieldGet(this, _RequestHandler_apiToken, "f")}`,
+                'Content-Type': contentType,
+                ...options.additionalHeaders
+            };
+            const res = await fetch(`${Constants.APIBaseURL}${path}`, {
+                method: options.method, headers: headers,
+                body: options.method !== 'GET' ? options.body : undefined
+            });
+            if (res.status >= 500 && retries < this.rateLimit) {
+                return this.exec(path, options, ++retries);
+            }
+            if (res.status === 429) {
+                const retryAfter = parseInt(res.headers.get('Retry-After'));
+                const rateLimitRemaining = parseInt(res.headers.get('RateLimit-Remaining'));
+                //const rateLimitLimit = parseInt(res.headers.get('RateLimit-Limit')!)
+                const rateLimitReset = parseInt(res.headers.get('RateLimit-Reset'));
+                const timeoutMS = (1 + (rateLimitRemaining < 10 ? rateLimitReset : retryAfter)) * 1000 - Date.now();
+                await new Promise((resolve) => {
+                    setTimeout(resolve, timeoutMS);
+                });
+                return this.exec(path, options, ++retries);
+            }
+            if (res.status === 204)
+                return {
+                    data: {},
+                    status: 204,
+                    maxAge: 0,
+                    path,
+                    ok: true
+                };
+            let data = null;
+            if (res.body != null) {
+                data = res.body;
+                const chunks = [];
+                const reader = data.getReader();
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (value !== undefined)
+                        chunks.push(value);
+                    if (done)
+                        break;
+                }
+                const buffer = Buffer.concat(chunks);
+                try {
+                    data = JSON.parse(buffer.toString());
+                }
+                catch (e) {
+                    const contentDisposition = res.headers?.get('content-disposition');
+                    if (contentDisposition?.startsWith('attachment')) {
+                        data = buffer;
+                    }
+                }
+            }
+            const isOk = res.status === 200 || res.status === 201;
+            if (!isOk)
+                throw new Error(`non valid: ${res.status} ${JSON.stringify(res)}`);
+            return { data: data, status: res.status, maxAge: 0, path, ok: isOk };
+            //https://developer.moneybird.com/#responses
+        }
+        catch (e) {
+            // fetch error timeout and rate-limit not reached yet -> Try again
+            if (e instanceof Error && e.message === 'fetch failed' && retries < this.rateLimit) {
+                return this.exec(path, options, ++retries);
+            }
+            if (this.rejectIfNotValid)
+                throw e;
+            return {
+                data: { message: e.message },
+                maxAge: 0,
+                status: 500,
+                path,
+                ok: false
+            };
+        }
+    }
+}
+exports.RequestHandler = RequestHandler;
+_RequestHandler_apiToken = new WeakMap();