@genz-its/sevdesk-sdk 0.0.0

package/dist/index.js

@@ -0,0 +1,2017 @@
+//#region src/errors.ts
+var SevDeskError = class extends Error {
+	status;
+	statusText;
+	body;
+	constructor(options) {
+		super(extractMessage(options));
+		this.name = "SevDeskError";
+		this.status = options.status;
+		this.statusText = options.statusText;
+		this.body = options.body;
+	}
+};
+function extractMessage(options) {
+	const fallback = `sevdesk API error: ${options.status} ${options.statusText}`;
+	const body = options.body;
+	if (typeof body === "string" && body.length > 0) return body;
+	if (typeof body === "object" && body !== null) {
+		const error = body.error;
+		if (typeof error === "object" && error !== null) {
+			const message = error.message;
+			if (typeof message === "string" && message.length > 0) return message;
+		}
+		const message = body.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return fallback;
+}
+//#endregion
+//#region src/http-client.ts
+const DEFAULT_BASE_URL = "https://my.sevdesk.de/api/v1";
+const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_USER_AGENT = "@genz-its/sevdesk-sdk";
+const RETRY_MAX_ATTEMPTS = 3;
+const RETRY_BASE_DELAY = 500;
+const RETRY_MAX_DELAY = 1e4;
+const RETRY_AFTER_MAX_DELAY = 6e4;
+const RETRYABLE_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"PUT",
+	"DELETE"
+]);
+const RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+var HttpClient = class {
+	token;
+	baseUrl;
+	timeout;
+	userAgent;
+	fetch;
+	constructor(options) {
+		this.token = options.token.trim();
+		this.baseUrl = options.baseUrl ?? "https://my.sevdesk.de/api/v1";
+		this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+		this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+		this.fetch = options.fetch ?? globalThis.fetch;
+	}
+	/**
+	* Performs a request and returns the payload of the `objects` response
+	* envelope. Responses without an envelope are returned as-is.
+	*/
+	async request(options) {
+		const text = await (await this.fetchWithRetry(options)).text();
+		if (text.length === 0) return;
+		return unwrap(JSON.parse(text));
+	}
+	async fetchWithRetry(options) {
+		const url = this.buildUrl(options);
+		const retryable = RETRYABLE_METHODS.has(options.method);
+		for (let attempt = 0;; attempt++) {
+			const canRetry = retryable && attempt < RETRY_MAX_ATTEMPTS;
+			let response;
+			try {
+				response = await this.fetch(url, this.buildRequestInit(options));
+			} catch (error) {
+				if (canRetry) {
+					await delay(backoffDelay(attempt));
+					continue;
+				}
+				throw error;
+			}
+			if (response.ok) return response;
+			if (canRetry && RETRYABLE_STATUS_CODES.has(response.status)) {
+				await delay(retryAfterDelay(response.headers.get("Retry-After")) ?? backoffDelay(attempt));
+				continue;
+			}
+			throw new SevDeskError({
+				status: response.status,
+				statusText: response.statusText,
+				body: await parseErrorBody(response)
+			});
+		}
+	}
+	buildUrl(options) {
+		const url = new URL(this.baseUrl + options.path);
+		for (const [key, value] of Object.entries(options.query ?? {})) {
+			if (value === void 0) continue;
+			url.searchParams.append(key, Array.isArray(value) ? value.join(",") : String(value));
+		}
+		return url.toString();
+	}
+	buildRequestInit(options) {
+		const headers = {
+			Authorization: this.token,
+			Accept: "application/json",
+			"User-Agent": this.userAgent
+		};
+		let body;
+		if (options.formData) body = options.formData;
+		else if (options.body !== void 0) {
+			headers["Content-Type"] = "application/json";
+			body = JSON.stringify(options.body);
+		}
+		return {
+			method: options.method,
+			headers,
+			body,
+			signal: AbortSignal.timeout(this.timeout)
+		};
+	}
+};
+function unwrap(payload) {
+	if (typeof payload === "object" && payload !== null && "objects" in payload) return payload.objects;
+	return payload;
+}
+async function parseErrorBody(response) {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function backoffDelay(attempt) {
+	const ceiling = Math.min(RETRY_MAX_DELAY, RETRY_BASE_DELAY * 2 ** attempt);
+	return ceiling / 2 + Math.random() * (ceiling / 2);
+}
+function retryAfterDelay(header) {
+	if (!header) return;
+	const seconds = Number(header);
+	const milliseconds = Number.isFinite(seconds) ? seconds * 1e3 : new Date(header).getTime() - Date.now();
+	if (!Number.isFinite(milliseconds) || milliseconds < 0) return;
+	return Math.min(milliseconds, RETRY_AFTER_MAX_DELAY);
+}
+function delay(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+//#endregion
+//#region src/resources/base.ts
+var BaseResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+};
+//#endregion
+//#region src/resources/basics.ts
+var BasicsResource = class extends BaseResource {
+	/** Retrieves the bookkeeping system version via `GET /Tools/bookkeepingSystemVersion`. */
+	async getBookkeepingSystemVersion() {
+		return (await this.http.request({
+			method: "GET",
+			path: "/Tools/bookkeepingSystemVersion"
+		})).version;
+	}
+};
+//#endregion
+//#region src/dates.ts
+/**
+* Serializes a date for voucher endpoints, which accept a Unix timestamp
+* or a `dd.mm.yyyy` string.
+*/
+function toVoucherDate(value) {
+	if (value instanceof Date) return Math.floor(value.getTime() / 1e3);
+	return value;
+}
+/** Serializes a date as ISO 8601, as expected by transaction endpoints. */
+function toIsoDateTime(value) {
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "number") return (/* @__PURE__ */ new Date(value * 1e3)).toISOString();
+	return value;
+}
+/** Serializes a date as `YYYY-MM-DD`. */
+function toPlainDate(value) {
+	if (value instanceof Date) return value.toISOString().slice(0, 10);
+	if (typeof value === "number") return (/* @__PURE__ */ new Date(value * 1e3)).toISOString().slice(0, 10);
+	return value;
+}
+//#endregion
+//#region src/resources/check-accounts.ts
+var CheckAccountsResource = class extends BaseResource {
+	/** Retrieves all check accounts via `GET /CheckAccount`. */
+	async list(options = {}) {
+		return this.http.request({
+			method: "GET",
+			path: "/CheckAccount",
+			query: {
+				limit: options.limit,
+				offset: options.offset
+			}
+		});
+	}
+	/** Retrieves a single check account via `GET /CheckAccount/{checkAccountId}`. */
+	async get(options) {
+		const checkAccount = (await this.http.request({
+			method: "GET",
+			path: `/CheckAccount/${options.checkAccountId}`
+		}))[0];
+		if (!checkAccount) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return checkAccount;
+	}
+	/** Creates a file import account via `POST /CheckAccount/Factory/fileImportAccount`. */
+	async createFileImportAccount(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/CheckAccount/Factory/fileImportAccount",
+			body: options
+		});
+	}
+	/** Creates a clearing account via `POST /CheckAccount/Factory/clearingAccount`. */
+	async createClearingAccount(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/CheckAccount/Factory/clearingAccount",
+			body: options
+		});
+	}
+	/** Updates a check account via `PUT /CheckAccount/{checkAccountId}`. */
+	async update(options) {
+		const { checkAccountId, ...body } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/CheckAccount/${checkAccountId}`,
+			body
+		});
+	}
+	/** Deletes a check account via `DELETE /CheckAccount/{checkAccountId}`. */
+	async delete(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/CheckAccount/${options.checkAccountId}`
+		});
+	}
+	/**
+	* Retrieves the balance at a date via `GET /CheckAccount/{checkAccountId}/getBalanceAtDate`.
+	*
+	* The balance is the sum of all transactions sevdesk knows up to and
+	* including the given date. It does not have to match the actual bank
+	* account balance, e.g. if old transactions were never imported.
+	*/
+	async getBalanceAtDate(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/CheckAccount/${options.checkAccountId}/getBalanceAtDate`,
+			query: { date: toPlainDate(options.date) }
+		});
+	}
+};
+//#endregion
+//#region src/resources/contacts.ts
+var ContactsResource = class extends BaseResource {
+	/** Retrieves contacts via `GET /Contact`. */
+	list(options = {}) {
+		const { depth, customerNumber, name, categoryId, parentId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Contact",
+			query: {
+				depth,
+				customerNumber,
+				name,
+				"category[id]": categoryId,
+				"category[objectName]": categoryId === void 0 ? void 0 : "Category",
+				"parent[id]": parentId,
+				"parent[objectName]": parentId === void 0 ? void 0 : "Contact",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single contact via `GET /Contact/{contactId}`. */
+	async get(options) {
+		const contact = (await this.http.request({
+			method: "GET",
+			path: `/Contact/${options.contactId}`
+		}))[0];
+		if (!contact) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return contact;
+	}
+	/** Creates a contact via `POST /Contact`. */
+	create(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/Contact",
+			body: toContactBody(options)
+		});
+	}
+	/** Updates a contact via `PUT /Contact/{contactId}`. */
+	update(options) {
+		const { contactId, ...fields } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Contact/${contactId}`,
+			body: toContactBody(fields)
+		});
+	}
+	/** Deletes a contact via `DELETE /Contact/{contactId}`. */
+	async delete(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/Contact/${options.contactId}`
+		});
+	}
+	/** Retrieves the next free customer number via `GET /Contact/Factory/getNextCustomerNumber`. */
+	getNextCustomerNumber() {
+		return this.http.request({
+			method: "GET",
+			path: "/Contact/Factory/getNextCustomerNumber"
+		});
+	}
+	/** Retrieves contacts by a custom field value via `GET /Contact/Factory/findContactsByCustomFieldValue`. */
+	findByCustomFieldValue(options) {
+		const { value, customFieldName, customFieldSettingId } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Contact/Factory/findContactsByCustomFieldValue",
+			query: {
+				value,
+				customFieldName,
+				"customFieldSetting[id]": customFieldSettingId,
+				"customFieldSetting[objectName]": customFieldSettingId === void 0 ? void 0 : "ContactCustomFieldSetting"
+			}
+		});
+	}
+	/** Checks if a customer number is still free via `GET /Contact/Mapper/checkCustomerNumberAvailability`. */
+	checkCustomerNumberAvailability(options) {
+		return this.http.request({
+			method: "GET",
+			path: "/Contact/Mapper/checkCustomerNumberAvailability",
+			query: { customerNumber: options.customerNumber }
+		});
+	}
+	/** Retrieves the document counts of a contact via `GET /Contact/{contactId}/getTabsItemCount`. */
+	getTabsItemCount(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/Contact/${options.contactId}/getTabsItemCount`
+		});
+	}
+};
+function toContactBody(fields) {
+	return {
+		objectName: "Contact",
+		mapAll: true,
+		category: toRef$6(fields.categoryId, "Category"),
+		parent: toRef$6(fields.parentId, "Contact"),
+		name: fields.name,
+		surename: fields.surename,
+		familyname: fields.familyname,
+		name2: fields.name2,
+		titel: fields.titel,
+		academicTitle: fields.academicTitle,
+		gender: fields.gender,
+		customerNumber: fields.customerNumber,
+		status: fields.status,
+		description: fields.description,
+		vatNumber: fields.vatNumber,
+		taxNumber: fields.taxNumber,
+		exemptVat: fields.exemptVat,
+		bankAccount: fields.bankAccount,
+		bankNumber: fields.bankNumber,
+		defaultTimeToPay: fields.defaultTimeToPay,
+		buyerReference: fields.buyerReference,
+		governmentAgency: fields.governmentAgency
+	};
+}
+function toRef$6(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+//#endregion
+//#region src/resources/credit-notes.ts
+var CreditNotesResource = class extends BaseResource {
+	/** Retrieves credit notes via `GET /CreditNote`. */
+	list(options = {}) {
+		const { status, creditNoteNumber, startDate, endDate, contactId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/CreditNote",
+			query: {
+				status,
+				creditNoteNumber,
+				startDate: toOptionalDate$1(startDate),
+				endDate: toOptionalDate$1(endDate),
+				"contact[id]": contactId,
+				"contact[objectName]": contactId === void 0 ? void 0 : "Contact",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single credit note via `GET /CreditNote/{creditNoteId}`. */
+	async get(options) {
+		const creditNote = (await this.http.request({
+			method: "GET",
+			path: `/CreditNote/${options.creditNoteId}`
+		}))[0];
+		if (!creditNote) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return creditNote;
+	}
+	/** Creates or updates a credit note with its positions via `POST /CreditNote/Factory/saveCreditNote`. */
+	async save(options) {
+		const { creditNote, positions } = options;
+		const result = await this.http.request({
+			method: "POST",
+			path: "/CreditNote/Factory/saveCreditNote",
+			body: {
+				creditNote: toCreditNoteBody(creditNote),
+				creditNotePosSave: positions.map(toCreditNotePositionBody),
+				creditNotePosDelete: null,
+				discountSave: null,
+				discountDelete: null
+			}
+		});
+		return {
+			creditNote: result.creditNote,
+			positions: result.creditNotePos
+		};
+	}
+	/** Creates a credit note from an invoice via `POST /CreditNote/Factory/createFromInvoice`. */
+	async createFromInvoice(options) {
+		const result = await this.http.request({
+			method: "POST",
+			path: "/CreditNote/Factory/createFromInvoice",
+			body: { invoice: {
+				id: options.invoiceId,
+				objectName: "Invoice"
+			} }
+		});
+		return {
+			creditNote: result.creditNote,
+			positions: result.creditNotePos,
+			discounts: result.discount
+		};
+	}
+	/** Updates a credit note via `PUT /CreditNote/{creditNoteId}`. */
+	update(options) {
+		const { creditNoteId, creditNoteDate, deliveryDate, ...rest } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/CreditNote/${creditNoteId}`,
+			body: {
+				...rest,
+				creditNoteDate: toOptionalDate$1(creditNoteDate),
+				deliveryDate: toOptionalDate$1(deliveryDate)
+			}
+		});
+	}
+	/** Deletes a credit note via `DELETE /CreditNote/{creditNoteId}`. */
+	async delete(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/CreditNote/${options.creditNoteId}`
+		});
+	}
+	/** Sends a credit note via email using `POST /CreditNote/{creditNoteId}/sendViaEmail`. */
+	sendViaEmail(options) {
+		const { creditNoteId, ...body } = options;
+		return this.http.request({
+			method: "POST",
+			path: `/CreditNote/${creditNoteId}/sendViaEmail`,
+			body
+		});
+	}
+	/** Retrieves the pdf of a credit note via `GET /CreditNote/{creditNoteId}/getPdf`. */
+	getPdf(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/CreditNote/${options.creditNoteId}/getPdf`,
+			query: { preventSendBy: options.preventSendBy }
+		});
+	}
+	/** Marks a credit note as sent via `PUT /CreditNote/{creditNoteId}/sendBy`. */
+	sendBy(options) {
+		const { creditNoteId, sendType, sendDraft } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/CreditNote/${creditNoteId}/sendBy`,
+			body: {
+				sendType,
+				sendDraft
+			}
+		});
+	}
+	/** Books an amount on a credit note via `PUT /CreditNote/{creditNoteId}/bookAmount`. */
+	book(options) {
+		const { creditNoteId, amount, date, type, checkAccountId, checkAccountTransactionId, createFeed } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/CreditNote/${creditNoteId}/bookAmount`,
+			body: {
+				amount,
+				date: toIsoDateTime(date),
+				type,
+				checkAccount: {
+					id: checkAccountId,
+					objectName: "CheckAccount"
+				},
+				checkAccountTransaction: toRef$5(checkAccountTransactionId, "CheckAccountTransaction"),
+				createFeed
+			}
+		});
+	}
+	/** Enshrines a credit note via `PUT /CreditNote/{creditNoteId}/enshrine`. This cannot be undone. */
+	async enshrine(options) {
+		await this.http.request({
+			method: "PUT",
+			path: `/CreditNote/${options.creditNoteId}/enshrine`
+		});
+	}
+	/** Resets the credit note status to open via `PUT /CreditNote/{creditNoteId}/resetToOpen`. */
+	resetToOpen(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/CreditNote/${options.creditNoteId}/resetToOpen`
+		});
+	}
+	/** Resets the credit note status to draft via `PUT /CreditNote/{creditNoteId}/resetToDraft`. */
+	resetToDraft(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/CreditNote/${options.creditNoteId}/resetToDraft`
+		});
+	}
+	/** Retrieves credit note positions via `GET /CreditNotePos`. */
+	listPositions(options = {}) {
+		const { creditNoteId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/CreditNotePos",
+			query: {
+				"creditNote[id]": creditNoteId,
+				"creditNote[objectName]": creditNoteId === void 0 ? void 0 : "CreditNote",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+};
+function toCreditNoteBody(creditNote) {
+	return {
+		objectName: "CreditNote",
+		mapAll: true,
+		creditNoteNumber: creditNote.creditNoteNumber,
+		creditNoteDate: toVoucherDate(creditNote.creditNoteDate),
+		contact: {
+			id: creditNote.contactId,
+			objectName: "Contact"
+		},
+		status: creditNote.status,
+		header: creditNote.header,
+		bookingCategory: creditNote.bookingCategory,
+		contactPerson: {
+			id: creditNote.contactPersonId,
+			objectName: "SevUser"
+		},
+		taxRule: {
+			id: creditNote.taxRuleId,
+			objectName: "TaxRule"
+		},
+		taxRate: creditNote.taxRate,
+		taxText: creditNote.taxText,
+		currency: creditNote.currency,
+		deliveryDate: toVoucherDate(creditNote.deliveryDate),
+		addressCountry: toRef$5(creditNote.addressCountryId, "StaticCountry"),
+		headText: creditNote.headText,
+		footText: creditNote.footText,
+		address: creditNote.address,
+		smallSettlement: creditNote.smallSettlement,
+		showNet: creditNote.showNet,
+		customerInternalNote: creditNote.customerInternalNote,
+		sendDate: toOptionalDate$1(creditNote.sendDate),
+		sendType: creditNote.sendType
+	};
+}
+function toCreditNotePositionBody(position) {
+	return {
+		objectName: "CreditNotePos",
+		mapAll: true,
+		unity: {
+			id: position.unityId,
+			objectName: "Unity"
+		},
+		quantity: position.quantity,
+		taxRate: position.taxRate,
+		name: position.name,
+		price: position.price,
+		text: position.text,
+		part: toRef$5(position.partId, "Part"),
+		positionNumber: position.positionNumber,
+		discount: position.discount,
+		optional: position.optional
+	};
+}
+function toRef$5(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+function toOptionalDate$1(value) {
+	return value === void 0 ? void 0 : toVoucherDate(value);
+}
+//#endregion
+//#region src/resources/exports.ts
+var ExportsResource = class extends BaseResource {
+	/**
+	* Updates the export config via `PUT /SevClient/{sevClientId}/updateExportConfig`.
+	*
+	* The accounting year has to be set once before any DATEV export can be run.
+	*/
+	async updateExportConfig(options) {
+		const { sevClientId, accountantNumber, accountantClientNumber, accountingYearBegin } = options;
+		await this.http.request({
+			method: "PUT",
+			path: `/SevClient/${sevClientId}/updateExportConfig`,
+			body: {
+				accountantNumber,
+				accountantClientNumber,
+				accountingYearBegin: toVoucherDate(accountingYearBegin)
+			}
+		});
+	}
+	/** Starts a DATEV CSV zip export via `GET /Export/createDatevCsvZipExportJob` and returns the job id. */
+	createDatevCsvZipExportJob(options) {
+		const { startDate, endDate, ...rest } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Export/createDatevCsvZipExportJob",
+			query: {
+				startDate: toVoucherDate(startDate),
+				endDate: toVoucherDate(endDate),
+				...rest
+			}
+		});
+	}
+	/** Starts a DATEV XML zip export via `GET /Export/createDatevXmlZipExportJob` and returns the job id. */
+	createDatevXmlZipExportJob(options) {
+		const { startDate, endDate, ...rest } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Export/createDatevXmlZipExportJob",
+			query: {
+				startDate: toVoucherDate(startDate),
+				endDate: toVoucherDate(endDate),
+				...rest
+			}
+		});
+	}
+	/** Generates the hash of an export job via `GET /Progress/generateDownloadHash`. */
+	generateDownloadHash(options) {
+		return this.http.request({
+			method: "GET",
+			path: "/Progress/generateDownloadHash",
+			query: { jobId: options.jobId }
+		});
+	}
+	/** Retrieves the progress of an export via `GET /Progress/getProgress`. */
+	getProgress(options) {
+		return this.http.request({
+			method: "GET",
+			path: "/Progress/getProgress",
+			query: { hash: options.hash }
+		});
+	}
+	/** Retrieves the download url of a finished export job via `GET /ExportJob/jobDownloadInfo`. */
+	getJobDownloadInfo(options) {
+		return this.http.request({
+			method: "GET",
+			path: "/ExportJob/jobDownloadInfo",
+			query: { jobId: options.jobId }
+		});
+	}
+	/** Exports invoices as CSV via `GET /Export/invoiceCsv`. */
+	exportInvoicesCsv(options = {}) {
+		return this.requestExport("/Export/invoiceCsv", options, {
+			modelName: "Invoice",
+			limit: options.limit,
+			filter: toExportInvoiceFilter(options.filter)
+		});
+	}
+	/** Exports invoices as zip via `GET /Export/invoiceZip`. */
+	exportInvoicesZip(options = {}) {
+		return this.requestExport("/Export/invoiceZip", options, {
+			modelName: "Invoice",
+			limit: options.limit,
+			filter: toExportInvoiceFilter(options.filter)
+		});
+	}
+	/** Exports credit notes as CSV via `GET /Export/creditNoteCsv`. */
+	exportCreditNotesCsv(options = {}) {
+		return this.requestExport("/Export/creditNoteCsv", options, {
+			modelName: "CreditNote",
+			limit: options.limit,
+			filter: toExportDocumentFilter(options.filter)
+		});
+	}
+	/** Exports vouchers as CSV via `GET /Export/voucherListCsv`. */
+	exportVouchersCsv(options = {}) {
+		return this.requestExport("/Export/voucherListCsv", options, {
+			modelName: "Voucher",
+			limit: options.limit,
+			filter: toExportVoucherFilter(options.filter)
+		});
+	}
+	/** Exports vouchers as zip via `GET /Export/voucherZip`. */
+	exportVouchersZip(options = {}) {
+		return this.requestExport("/Export/voucherZip", options, {
+			modelName: "Voucher",
+			limit: options.limit,
+			filter: toExportVoucherFilter(options.filter)
+		});
+	}
+	/** Exports transactions as CSV via `GET /Export/transactionsCsv`. */
+	exportTransactionsCsv(options = {}) {
+		return this.requestExport("/Export/transactionsCsv", options, {
+			modelName: "CheckAccountTransaction",
+			limit: options.limit,
+			filter: toExportTransactionFilter(options.filter)
+		});
+	}
+	/** Exports contacts as CSV via `GET /Export/contactListCsv`. */
+	exportContactsCsv(options = {}) {
+		return this.requestExport("/Export/contactListCsv", options, {
+			modelName: "Contact",
+			limit: options.limit,
+			filter: toExportContactFilter(options.filter)
+		});
+	}
+	requestExport(path, options, sevQuery) {
+		return this.http.request({
+			method: "GET",
+			path,
+			query: {
+				download: options.download,
+				...toExportSevQueryParams(sevQuery)
+			}
+		});
+	}
+};
+/**
+* Flattens a `sevQuery` object into the deep bracket query parameters expected
+* by the export and report endpoints, e.g. `sevQuery[filter][startDate]`.
+*/
+function toExportSevQueryParams(sevQuery) {
+	const query = {};
+	flattenSevQueryValue("sevQuery", {
+		objectName: "SevQuery",
+		...sevQuery
+	}, query);
+	return query;
+}
+/** Maps a document export filter to its `sevQuery` representation. */
+function toExportDocumentFilter(filter = {}) {
+	return {
+		startDate: toOptionalIsoDateTime$1(filter.startDate),
+		endDate: toOptionalIsoDateTime$1(filter.endDate),
+		contact: toRef$4(filter.contactId, "Contact"),
+		startAmount: filter.startAmount,
+		endAmount: filter.endAmount
+	};
+}
+/** Maps an invoice export filter to its `sevQuery` representation. */
+function toExportInvoiceFilter(filter = {}) {
+	return {
+		...toExportDocumentFilter(filter),
+		invoiceType: filter.invoiceType
+	};
+}
+/** Maps a voucher export filter to its `sevQuery` representation. */
+function toExportVoucherFilter(filter = {}) {
+	return {
+		...toExportDocumentFilter(filter),
+		startPayDate: toOptionalIsoDateTime$1(filter.startPayDate),
+		endPayDate: toOptionalIsoDateTime$1(filter.endPayDate)
+	};
+}
+/** Maps a contact export filter to its `sevQuery` representation. */
+function toExportContactFilter(filter = {}) {
+	return {
+		zip: filter.zip,
+		city: filter.city,
+		country: toRef$4(filter.countryId, "StaticCountry"),
+		depth: filter.depth,
+		onlyPeople: filter.onlyPeople
+	};
+}
+function toExportTransactionFilter(filter = {}) {
+	return {
+		paymtPurpose: filter.paymtPurpose,
+		name: filter.name,
+		startDate: toOptionalIsoDateTime$1(filter.startDate),
+		endDate: toOptionalIsoDateTime$1(filter.endDate),
+		startAmount: filter.startAmount,
+		endAmount: filter.endAmount,
+		checkAccount: toRef$4(filter.checkAccountId, "CheckAccount")
+	};
+}
+function flattenSevQueryValue(key, value, query) {
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => flattenSevQueryValue(`${key}[${index}]`, item, query));
+		return;
+	}
+	if (typeof value === "object") {
+		for (const [nestedKey, nestedValue] of Object.entries(value)) if (nestedValue !== void 0) flattenSevQueryValue(`${key}[${nestedKey}]`, nestedValue, query);
+		return;
+	}
+	query[key] = value;
+}
+function toRef$4(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+function toOptionalIsoDateTime$1(value) {
+	return value === void 0 ? void 0 : toIsoDateTime(value);
+}
+//#endregion
+//#region src/resources/invoices.ts
+var InvoicesResource = class extends BaseResource {
+	/** Retrieves invoices via `GET /Invoice`. */
+	list(options = {}) {
+		const { status, invoiceNumber, startDate, endDate, contactId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Invoice",
+			query: {
+				status,
+				invoiceNumber,
+				startDate: toOptionalInvoiceDate(startDate),
+				endDate: toOptionalInvoiceDate(endDate),
+				"contact[id]": contactId,
+				"contact[objectName]": contactId === void 0 ? void 0 : "Contact",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single invoice via `GET /Invoice/{invoiceId}`. */
+	async get(options) {
+		const invoice = (await this.http.request({
+			method: "GET",
+			path: `/Invoice/${options.invoiceId}`
+		}))[0];
+		if (!invoice) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return invoice;
+	}
+	/**
+	* Creates or updates an invoice with its positions via
+	* `POST /Invoice/Factory/saveInvoice`.
+	*
+	* Invoices can only be created as drafts. Use `sendViaEmail`, `sendBy` and
+	* `book` to advance the status afterwards.
+	*/
+	async save(options) {
+		const { invoice, positions, takeDefaultAddress } = options;
+		const result = await this.http.request({
+			method: "POST",
+			path: "/Invoice/Factory/saveInvoice",
+			body: {
+				invoice: toInvoiceBody(invoice),
+				invoicePosSave: positions.map(toInvoicePositionBody),
+				invoicePosDelete: null,
+				discountSave: null,
+				discountDelete: null,
+				...takeDefaultAddress === void 0 ? {} : { takeDefaultAddress }
+			}
+		});
+		return {
+			invoice: result.invoice,
+			positions: result.invoicePos
+		};
+	}
+	/** Creates an invoice from an order via `POST /Invoice/Factory/createInvoiceFromOrder`. */
+	createFromOrder(options) {
+		const { orderId, type, amount, partialType } = options;
+		return this.http.request({
+			method: "POST",
+			path: "/Invoice/Factory/createInvoiceFromOrder",
+			body: {
+				order: {
+					id: orderId,
+					objectName: "Order"
+				},
+				type,
+				amount,
+				partialType
+			}
+		});
+	}
+	/** Creates a reminder for an invoice via `POST /Invoice/Factory/createInvoiceReminder`. */
+	createReminder(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/Invoice/Factory/createInvoiceReminder",
+			body: { invoice: {
+				id: options.invoiceId,
+				objectName: "Invoice"
+			} }
+		});
+	}
+	/** Retrieves the positions of an invoice via `GET /Invoice/{invoiceId}/getPositions`. */
+	getPositions(options) {
+		const { invoiceId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: `/Invoice/${invoiceId}/getPositions`,
+			query: {
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/**
+	* Checks if an invoice is partially paid via
+	* `GET /Invoice/{invoiceId}/getIsPartiallyPaid`.
+	*
+	* Fully paid invoices are regarded as not partially paid.
+	*/
+	isPartiallyPaid(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/Invoice/${options.invoiceId}/getIsPartiallyPaid`
+		});
+	}
+	/**
+	* Cancels an invoice via `POST /Invoice/{invoiceId}/cancelInvoice` and
+	* returns the created cancellation invoice.
+	*/
+	cancel(options) {
+		return this.http.request({
+			method: "POST",
+			path: `/Invoice/${options.invoiceId}/cancelInvoice`
+		});
+	}
+	/** Renders the pdf document of an invoice via `POST /Invoice/{invoiceId}/render`. */
+	render(options) {
+		return this.http.request({
+			method: "POST",
+			path: `/Invoice/${options.invoiceId}/render`,
+			body: { forceReload: options.forceReload }
+		});
+	}
+	/**
+	* Sends an invoice to the end-customer via
+	* `POST /Invoice/{invoiceId}/sendViaEmail`. This marks the invoice as sent.
+	*/
+	sendViaEmail(options) {
+		const { invoiceId, ...body } = options;
+		return this.http.request({
+			method: "POST",
+			path: `/Invoice/${invoiceId}/sendViaEmail`,
+			body
+		});
+	}
+	/** Retrieves the pdf document of an invoice via `GET /Invoice/{invoiceId}/getPdf`. */
+	getPdf(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/Invoice/${options.invoiceId}/getPdf`,
+			query: { preventSendBy: options.preventSendBy }
+		});
+	}
+	/** Retrieves the xml of an e-invoice via `GET /Invoice/{invoiceId}/getXml`. */
+	getXml(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/Invoice/${options.invoiceId}/getXml`
+		});
+	}
+	/** Marks an invoice as sent via `PUT /Invoice/{invoiceId}/sendBy`. */
+	sendBy(options) {
+		const { invoiceId, sendType, sendDraft } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Invoice/${invoiceId}/sendBy`,
+			body: {
+				sendType,
+				sendDraft
+			}
+		});
+	}
+	/** Books an amount on an invoice via `PUT /Invoice/{invoiceId}/bookAmount`. */
+	book(options) {
+		const { invoiceId, amount, date, type, checkAccountId, checkAccountTransactionId, createFeed } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Invoice/${invoiceId}/bookAmount`,
+			body: {
+				amount,
+				date: toIsoDateTime(date),
+				type,
+				checkAccount: {
+					id: checkAccountId,
+					objectName: "CheckAccount"
+				},
+				checkAccountTransaction: toRef$3(checkAccountTransactionId, "CheckAccountTransaction"),
+				createFeed
+			}
+		});
+	}
+	/**
+	* Enshrines an invoice via `PUT /Invoice/{invoiceId}/enshrine`.
+	*
+	* Requires a status of at least `200` and cannot be undone.
+	*/
+	async enshrine(options) {
+		await this.http.request({
+			method: "PUT",
+			path: `/Invoice/${options.invoiceId}/enshrine`
+		});
+	}
+	/**
+	* Resets the invoice status to open via `PUT /Invoice/{invoiceId}/resetToOpen`.
+	*
+	* Linked transactions are unlinked. Not possible for enshrined invoices.
+	*/
+	resetToOpen(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/Invoice/${options.invoiceId}/resetToOpen`
+		});
+	}
+	/**
+	* Resets the invoice status to draft via `PUT /Invoice/{invoiceId}/resetToDraft`.
+	*
+	* Only possible for invoices with the status `200`.
+	*/
+	resetToDraft(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/Invoice/${options.invoiceId}/resetToDraft`
+		});
+	}
+};
+function toInvoiceBody(invoice) {
+	return {
+		objectName: "Invoice",
+		mapAll: true,
+		invoiceNumber: invoice.invoiceNumber,
+		contact: {
+			id: invoice.contactId,
+			objectName: "Contact"
+		},
+		contactPerson: {
+			id: invoice.contactPersonId,
+			objectName: "SevUser"
+		},
+		invoiceDate: toVoucherDate(invoice.invoiceDate),
+		header: invoice.header,
+		headText: invoice.headText,
+		footText: invoice.footText,
+		timeToPay: invoice.timeToPay,
+		discount: invoice.discount ?? 0,
+		address: invoice.address,
+		addressCountry: toRef$3(invoice.addressCountryId, "StaticCountry"),
+		payDate: toOptionalInvoiceDate(invoice.payDate),
+		deliveryDate: toOptionalInvoiceDate(invoice.deliveryDate),
+		deliveryDateUntil: toOptionalInvoiceDate(invoice.deliveryDateUntil),
+		status: invoice.status,
+		smallSettlement: invoice.smallSettlement,
+		taxRate: 0,
+		taxRule: {
+			id: invoice.taxRuleId,
+			objectName: "TaxRule"
+		},
+		taxText: invoice.taxText,
+		paymentMethod: toRef$3(invoice.paymentMethodId, "PaymentMethod"),
+		invoiceType: invoice.invoiceType,
+		currency: invoice.currency,
+		showNet: invoice.showNet,
+		customerInternalNote: invoice.customerInternalNote,
+		propertyIsEInvoice: invoice.propertyIsEInvoice
+	};
+}
+function toInvoicePositionBody(position) {
+	return {
+		objectName: "InvoicePos",
+		mapAll: true,
+		invoice: null,
+		part: toRef$3(position.partId, "Part"),
+		quantity: position.quantity,
+		price: position.price,
+		name: position.name,
+		unity: {
+			id: position.unityId,
+			objectName: "Unity"
+		},
+		positionNumber: position.positionNumber,
+		text: position.text,
+		discount: position.discount,
+		taxRate: position.taxRate
+	};
+}
+function toRef$3(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+function toOptionalInvoiceDate(value) {
+	return value === void 0 ? void 0 : toVoucherDate(value);
+}
+//#endregion
+//#region src/resources/orders.ts
+var OrdersResource = class extends BaseResource {
+	/** Retrieves orders via `GET /Order`. */
+	list(options = {}) {
+		const { status, orderNumber, startDate, endDate, contactId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Order",
+			query: {
+				status,
+				orderNumber,
+				startDate: toOptionalDate(startDate),
+				endDate: toOptionalDate(endDate),
+				"contact[id]": contactId,
+				"contact[objectName]": contactId === void 0 ? void 0 : "Contact",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single order via `GET /Order/{orderId}`. */
+	async get(options) {
+		const order = (await this.http.request({
+			method: "GET",
+			path: `/Order/${options.orderId}`
+		}))[0];
+		if (!order) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return order;
+	}
+	/** Creates or updates an order with its positions via `POST /Order/Factory/saveOrder`. */
+	async save(options) {
+		const { order, positions } = options;
+		const result = await this.http.request({
+			method: "POST",
+			path: "/Order/Factory/saveOrder",
+			body: {
+				order: toOrderBody(order),
+				orderPosSave: positions.map(toOrderPositionBody),
+				orderPosDelete: null
+			}
+		});
+		return {
+			order: result.order,
+			positions: result.orderPos
+		};
+	}
+	/** Updates an order via `PUT /Order/{orderId}`. */
+	update(options) {
+		const { orderId, orderDate, ...rest } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Order/${orderId}`,
+			body: {
+				...rest,
+				orderDate: toOptionalDate(orderDate)
+			}
+		});
+	}
+	/** Deletes an order via `DELETE /Order/{orderId}`. */
+	async delete(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/Order/${options.orderId}`
+		});
+	}
+	/** Retrieves the positions of an order via `GET /Order/{orderId}/getPositions`. */
+	getPositions(options) {
+		const { orderId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: `/Order/${orderId}/getPositions`,
+			query: {
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves the discounts of an order via `GET /Order/{orderId}/getDiscounts`. */
+	getDiscounts(options) {
+		const { orderId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: `/Order/${orderId}/getDiscounts`,
+			query: {
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves the objects related to an order via `GET /Order/{orderId}/getRelatedObjects`. */
+	getRelatedObjects(options) {
+		const { orderId, includeItself, sortByType, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: `/Order/${orderId}/getRelatedObjects`,
+			query: {
+				includeItself,
+				sortByType,
+				embed
+			}
+		});
+	}
+	/** Sends an order via email using `POST /Order/{orderId}/sendViaEmail`. */
+	sendViaEmail(options) {
+		const { orderId, ...body } = options;
+		return this.http.request({
+			method: "POST",
+			path: `/Order/${orderId}/sendViaEmail`,
+			body
+		});
+	}
+	/** Creates a packing list from an order via `POST /Order/Factory/createPackingListFromOrder`. */
+	createPackingList(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/Order/Factory/createPackingListFromOrder",
+			query: {
+				"order[id]": options.orderId,
+				"order[objectName]": "Order"
+			},
+			body: {
+				id: options.orderId,
+				objectName: "Order"
+			}
+		});
+	}
+	/** Creates a contract note from an order via `POST /Order/Factory/createContractNoteFromOrder`. */
+	createContractNote(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/Order/Factory/createContractNoteFromOrder",
+			query: {
+				"order[id]": options.orderId,
+				"order[objectName]": "Order"
+			},
+			body: {
+				id: options.orderId,
+				objectName: "Order"
+			}
+		});
+	}
+	/** Retrieves the pdf of an order via `GET /Order/{orderId}/getPdf`. */
+	getPdf(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/Order/${options.orderId}/getPdf`,
+			query: { preventSendBy: options.preventSendBy }
+		});
+	}
+	/** Marks an order as sent via `PUT /Order/{orderId}/sendBy`. */
+	sendBy(options) {
+		const { orderId, sendType, sendDraft } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Order/${orderId}/sendBy`,
+			body: {
+				sendType,
+				sendDraft
+			}
+		});
+	}
+	/** Retrieves order positions via `GET /OrderPos`. */
+	listPositions(options = {}) {
+		const { orderId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/OrderPos",
+			query: {
+				"order[id]": orderId,
+				"order[objectName]": orderId === void 0 ? void 0 : "Order",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single order position via `GET /OrderPos/{orderPosId}`. */
+	async getPosition(options) {
+		const position = (await this.http.request({
+			method: "GET",
+			path: `/OrderPos/${options.orderPosId}`
+		}))[0];
+		if (!position) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return position;
+	}
+	/** Updates an order position via `PUT /OrderPos/{orderPosId}`. */
+	updatePosition(options) {
+		const { orderPosId, unityId, partId, ...rest } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/OrderPos/${orderPosId}`,
+			body: {
+				...rest,
+				unity: toRef$2(unityId, "Unity"),
+				part: toRef$2(partId, "Part")
+			}
+		});
+	}
+	/** Deletes an order position via `DELETE /OrderPos/{orderPosId}`. */
+	async deletePosition(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/OrderPos/${options.orderPosId}`
+		});
+	}
+};
+function toOrderBody(order) {
+	return {
+		objectName: "Order",
+		mapAll: true,
+		orderNumber: order.orderNumber,
+		orderDate: toVoucherDate(order.orderDate),
+		contact: {
+			id: order.contactId,
+			objectName: "Contact"
+		},
+		status: order.status,
+		orderType: order.orderType,
+		header: order.header,
+		version: order.version,
+		addressCountry: {
+			id: order.addressCountryId,
+			objectName: "StaticCountry"
+		},
+		contactPerson: {
+			id: order.contactPersonId,
+			objectName: "SevUser"
+		},
+		taxRule: {
+			id: order.taxRuleId,
+			objectName: "TaxRule"
+		},
+		taxRate: order.taxRate,
+		taxText: order.taxText,
+		currency: order.currency,
+		headText: order.headText,
+		footText: order.footText,
+		deliveryTerms: order.deliveryTerms,
+		paymentTerms: order.paymentTerms,
+		smallSettlement: order.smallSettlement,
+		showNet: order.showNet,
+		address: order.address,
+		customerInternalNote: order.customerInternalNote,
+		sendDate: toOptionalDate(order.sendDate),
+		sendType: order.sendType
+	};
+}
+function toOrderPositionBody(position) {
+	return {
+		objectName: "OrderPos",
+		mapAll: true,
+		unity: {
+			id: position.unityId,
+			objectName: "Unity"
+		},
+		quantity: position.quantity,
+		taxRate: position.taxRate,
+		name: position.name,
+		price: position.price,
+		text: position.text,
+		part: toRef$2(position.partId, "Part"),
+		positionNumber: position.positionNumber,
+		discount: position.discount,
+		optional: position.optional
+	};
+}
+function toRef$2(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+function toOptionalDate(value) {
+	return value === void 0 ? void 0 : toVoucherDate(value);
+}
+//#endregion
+//#region src/resources/parts.ts
+var PartsResource = class extends BaseResource {
+	/** Retrieves parts via `GET /Part`. */
+	list(options = {}) {
+		const { partNumber, name, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Part",
+			query: {
+				partNumber,
+				name,
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single part via `GET /Part/{partId}`. */
+	async get(options) {
+		const part = (await this.http.request({
+			method: "GET",
+			path: `/Part/${options.partId}`
+		}))[0];
+		if (!part) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return part;
+	}
+	/** Creates a part via `POST /Part`. */
+	create(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/Part",
+			body: toPartBody(options)
+		});
+	}
+	/** Updates a part via `PUT /Part/{partId}`. */
+	update(options) {
+		const { partId, ...fields } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Part/${partId}`,
+			body: toPartBody(fields)
+		});
+	}
+	/** Retrieves the current stock amount of a part via `GET /Part/{partId}/getStock`. */
+	getStock(options) {
+		return this.http.request({
+			method: "GET",
+			path: `/Part/${options.partId}/getStock`
+		});
+	}
+};
+function toPartBody(fields) {
+	return {
+		objectName: "Part",
+		mapAll: true,
+		name: fields.name,
+		partNumber: fields.partNumber,
+		unity: toRef$1(fields.unityId, "Unity"),
+		taxRate: fields.taxRate,
+		stock: fields.stock,
+		text: fields.text,
+		category: toRef$1(fields.categoryId, "Category"),
+		stockEnabled: fields.stockEnabled,
+		price: fields.price,
+		priceNet: fields.priceNet,
+		priceGross: fields.priceGross,
+		pricePurchase: fields.pricePurchase,
+		status: fields.status,
+		internalComment: fields.internalComment
+	};
+}
+function toRef$1(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+//#endregion
+//#region src/resources/receipt-guidance.ts
+var ReceiptGuidanceResource = class extends BaseResource {
+	/** Retrieves guidance for all accounts via `GET /ReceiptGuidance/forAllAccounts`. */
+	forAllAccounts() {
+		return this.http.request({
+			method: "GET",
+			path: "/ReceiptGuidance/forAllAccounts"
+		});
+	}
+	/** Retrieves guidance for a datev account number via `GET /ReceiptGuidance/forAccountNumber`. */
+	forAccountNumber(options) {
+		return this.http.request({
+			method: "GET",
+			path: "/ReceiptGuidance/forAccountNumber",
+			query: { accountNumber: options.accountNumber }
+		});
+	}
+	/** Retrieves guidance for a tax rule via `GET /ReceiptGuidance/forTaxRule`. */
+	forTaxRule(options) {
+		return this.http.request({
+			method: "GET",
+			path: "/ReceiptGuidance/forTaxRule",
+			query: { taxRule: options.taxRule }
+		});
+	}
+	/** Retrieves guidance for revenue accounts via `GET /ReceiptGuidance/forRevenue`. */
+	forRevenue() {
+		return this.http.request({
+			method: "GET",
+			path: "/ReceiptGuidance/forRevenue"
+		});
+	}
+	/** Retrieves guidance for expense accounts via `GET /ReceiptGuidance/forExpense`. */
+	forExpense() {
+		return this.http.request({
+			method: "GET",
+			path: "/ReceiptGuidance/forExpense"
+		});
+	}
+};
+//#endregion
+//#region src/resources/reports.ts
+var ReportsResource = class extends BaseResource {
+	/** Creates an invoice list report as PDF via `GET /Report/invoicelist`. */
+	invoiceList(options = {}) {
+		return this.requestReport("/Report/invoicelist", {
+			download: options.download,
+			view: options.view ?? "all"
+		}, {
+			modelName: "Invoice",
+			limit: options.limit,
+			filter: toExportInvoiceFilter(options.filter)
+		});
+	}
+	/** Creates an order list report as PDF via `GET /Report/orderlist`. */
+	orderList(options = {}) {
+		return this.requestReport("/Report/orderlist", {
+			download: options.download,
+			view: options.view ?? "all"
+		}, {
+			modelName: "Order",
+			limit: options.limit,
+			filter: {
+				...toExportDocumentFilter(options.filter),
+				orderType: options.filter?.orderType
+			}
+		});
+	}
+	/** Creates a contact list report as PDF via `GET /Report/contactlist`. */
+	contactList(options = {}) {
+		return this.requestReport("/Report/contactlist", options, {
+			modelName: "Contact",
+			limit: options.limit,
+			filter: toExportContactFilter(options.filter)
+		});
+	}
+	/** Creates a voucher list report as PDF via `GET /Report/voucherlist`. */
+	voucherList(options = {}) {
+		return this.requestReport("/Report/voucherlist", options, {
+			modelName: "Voucher",
+			limit: options.limit,
+			filter: toExportVoucherFilter(options.filter)
+		});
+	}
+	requestReport(path, options, sevQuery) {
+		return this.http.request({
+			method: "GET",
+			path,
+			query: {
+				download: options.download,
+				view: options.view,
+				...toExportSevQueryParams(sevQuery)
+			}
+		});
+	}
+};
+//#endregion
+//#region src/resources/tags.ts
+var TagsResource = class extends BaseResource {
+	/** Retrieves tags via `GET /Tag`. */
+	list(options = {}) {
+		const { name, limit, offset } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Tag",
+			query: {
+				name,
+				limit,
+				offset
+			}
+		});
+	}
+	/** Retrieves a single tag via `GET /Tag/{tagId}`. */
+	async get(options) {
+		const tag = (await this.http.request({
+			method: "GET",
+			path: `/Tag/${options.tagId}`
+		}))[0];
+		if (!tag) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return tag;
+	}
+	/**
+	* Creates a tag and attaches it to a document via `POST /Tag/Factory/create`.
+	* Returns the created tag relation.
+	*/
+	create(options) {
+		const { name, objectId, objectName } = options;
+		return this.http.request({
+			method: "POST",
+			path: "/Tag/Factory/create",
+			body: {
+				name,
+				object: {
+					id: objectId,
+					objectName
+				}
+			}
+		});
+	}
+	/** Renames a tag via `PUT /Tag/{tagId}`. */
+	update(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/Tag/${options.tagId}`,
+			body: { name: options.name }
+		});
+	}
+	/** Deletes a tag via `DELETE /Tag/{tagId}`. */
+	async delete(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/Tag/${options.tagId}`
+		});
+	}
+	/** Retrieves tag relations via `GET /TagRelation`. */
+	listRelations(options = {}) {
+		return this.http.request({
+			method: "GET",
+			path: "/TagRelation",
+			query: {
+				limit: options.limit,
+				offset: options.offset
+			}
+		});
+	}
+};
+//#endregion
+//#region src/resources/transactions.ts
+var TransactionsResource = class extends BaseResource {
+	/** Retrieves transactions via `GET /CheckAccountTransaction`. */
+	async list(options = {}) {
+		return this.http.request({
+			method: "GET",
+			path: "/CheckAccountTransaction",
+			query: {
+				"checkAccount[id]": options.checkAccountId,
+				"checkAccount[objectName]": options.checkAccountId === void 0 ? void 0 : "CheckAccount",
+				isBooked: options.isBooked,
+				paymtPurpose: options.paymtPurpose,
+				startDate: toOptionalIsoDateTime(options.startDate),
+				endDate: toOptionalIsoDateTime(options.endDate),
+				payeePayerName: options.payeePayerName,
+				onlyCredit: options.onlyCredit,
+				onlyDebit: options.onlyDebit,
+				limit: options.limit,
+				offset: options.offset
+			}
+		});
+	}
+	/** Retrieves a single transaction via `GET /CheckAccountTransaction/{transactionId}`. */
+	async get(options) {
+		const transaction = (await this.http.request({
+			method: "GET",
+			path: `/CheckAccountTransaction/${options.transactionId}`
+		}))[0];
+		if (!transaction) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return transaction;
+	}
+	/**
+	* Creates a transaction via `POST /CheckAccountTransaction`.
+	*
+	* Should only be used on check accounts of type online, preferably on
+	* accounts that import their transactions from CSV files.
+	*/
+	async create(options) {
+		return this.http.request({
+			method: "POST",
+			path: "/CheckAccountTransaction",
+			body: {
+				objectName: "CheckAccountTransaction",
+				mapAll: true,
+				valueDate: toIsoDateTime(options.valueDate),
+				entryDate: toOptionalIsoDateTime(options.entryDate),
+				amount: options.amount,
+				payeePayerName: options.payeePayerName,
+				paymtPurpose: options.paymtPurpose,
+				payeePayerAcctNo: options.payeePayerAcctNo,
+				payeePayerBankCode: options.payeePayerBankCode,
+				checkAccount: {
+					id: options.checkAccountId,
+					objectName: "CheckAccount"
+				},
+				status: options.status ?? 100
+			}
+		});
+	}
+	/** Updates a transaction via `PUT /CheckAccountTransaction/{transactionId}`. */
+	async update(options) {
+		const { transactionId, valueDate, entryDate, ...rest } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/CheckAccountTransaction/${transactionId}`,
+			body: {
+				...rest,
+				valueDate: toOptionalIsoDateTime(valueDate),
+				entryDate: toOptionalIsoDateTime(entryDate)
+			}
+		});
+	}
+	/** Deletes a transaction via `DELETE /CheckAccountTransaction/{transactionId}`. */
+	async delete(options) {
+		await this.http.request({
+			method: "DELETE",
+			path: `/CheckAccountTransaction/${options.transactionId}`
+		});
+	}
+	/**
+	* Enshrines a transaction via `PUT /CheckAccountTransaction/{transactionId}/enshrine`.
+	*
+	* Requires a status of at least `200` and cannot be undone. Linked invoices,
+	* credit notes and vouchers can no longer be changed afterwards.
+	*/
+	async enshrine(options) {
+		await this.http.request({
+			method: "PUT",
+			path: `/CheckAccountTransaction/${options.transactionId}/enshrine`
+		});
+	}
+};
+function toOptionalIsoDateTime(value) {
+	return value === void 0 ? void 0 : toIsoDateTime(value);
+}
+//#endregion
+//#region src/resources/vouchers.ts
+var VouchersResource = class extends BaseResource {
+	/** Retrieves vouchers via `GET /Voucher`. */
+	list(options = {}) {
+		const { status, creditDebit, descriptionLike, startDate, endDate, contactId, limit, offset, embed } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/Voucher",
+			query: {
+				status,
+				creditDebit,
+				descriptionLike,
+				startDate: toOptionalVoucherDate(startDate),
+				endDate: toOptionalVoucherDate(endDate),
+				"contact[id]": contactId,
+				"contact[objectName]": contactId === void 0 ? void 0 : "Contact",
+				limit,
+				offset,
+				embed
+			}
+		});
+	}
+	/** Retrieves a single voucher via `GET /Voucher/{voucherId}`. */
+	async get(options) {
+		const voucher = (await this.http.request({
+			method: "GET",
+			path: `/Voucher/${options.voucherId}`
+		}))[0];
+		if (!voucher) throw new SevDeskError({
+			status: 404,
+			statusText: "Not Found",
+			body: null
+		});
+		return voucher;
+	}
+	/** Uploads a voucher document via `POST /Voucher/Factory/uploadTempFile`. */
+	uploadFile(options) {
+		const { file, filename = "upload" } = options;
+		const formData = new FormData();
+		const blob = file instanceof Blob ? file : new Blob([file]);
+		formData.append("file", blob, filename);
+		return this.http.request({
+			method: "POST",
+			path: "/Voucher/Factory/uploadTempFile",
+			formData
+		});
+	}
+	/** Creates or updates a voucher with its positions via `POST /Voucher/Factory/saveVoucher`. */
+	async save(options) {
+		const { voucher, positions, filename } = options;
+		const result = await this.http.request({
+			method: "POST",
+			path: "/Voucher/Factory/saveVoucher",
+			body: {
+				voucher: toVoucherBody(voucher),
+				voucherPosSave: positions.map(toVoucherPositionBody),
+				voucherPosDelete: null,
+				...filename === void 0 ? {} : { filename }
+			}
+		});
+		return {
+			voucher: result.voucher,
+			positions: result.voucherPos,
+			filename: result.filename
+		};
+	}
+	/** Uploads a document and creates a voucher with it attached. */
+	async createFromFile(options) {
+		const { file, filename, voucher, positions } = options;
+		const upload = await this.uploadFile({
+			file,
+			filename
+		});
+		return this.save({
+			voucher,
+			positions,
+			filename: upload.filename
+		});
+	}
+	/** Updates simple fields of a draft voucher via `PUT /Voucher/{voucherId}`. */
+	update(options) {
+		const { voucherId, voucherDate, description, payDate, supplierName } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Voucher/${voucherId}`,
+			body: {
+				voucherDate: toOptionalVoucherDate(voucherDate),
+				description,
+				payDate: toOptionalVoucherDate(payDate),
+				supplierName
+			}
+		});
+	}
+	/** Books an amount on a voucher via `PUT /Voucher/{voucherId}/bookAmount`. */
+	book(options) {
+		const { voucherId, amount, date, type, checkAccountId, checkAccountTransactionId, createFeed } = options;
+		return this.http.request({
+			method: "PUT",
+			path: `/Voucher/${voucherId}/bookAmount`,
+			body: {
+				amount,
+				date: toIsoDateTime(date),
+				type,
+				checkAccount: {
+					id: checkAccountId,
+					objectName: "CheckAccount"
+				},
+				checkAccountTransaction: toRef(checkAccountTransactionId, "CheckAccountTransaction"),
+				createFeed
+			}
+		});
+	}
+	/** Resets the voucher status to open via `PUT /Voucher/{voucherId}/resetToOpen`. */
+	resetToOpen(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/Voucher/${options.voucherId}/resetToOpen`
+		});
+	}
+	/** Resets the voucher status to draft via `PUT /Voucher/{voucherId}/resetToDraft`. */
+	resetToDraft(options) {
+		return this.http.request({
+			method: "PUT",
+			path: `/Voucher/${options.voucherId}/resetToDraft`
+		});
+	}
+	/** Enshrines a voucher via `PUT /Voucher/{voucherId}/enshrine`. This cannot be undone. */
+	async enshrine(options) {
+		await this.http.request({
+			method: "PUT",
+			path: `/Voucher/${options.voucherId}/enshrine`
+		});
+	}
+	/** Retrieves the positions of a voucher via `GET /VoucherPos`. */
+	listPositions(options) {
+		const { voucherId, limit, offset } = options;
+		return this.http.request({
+			method: "GET",
+			path: "/VoucherPos",
+			query: {
+				"voucher[id]": voucherId,
+				"voucher[objectName]": "Voucher",
+				limit,
+				offset
+			}
+		});
+	}
+};
+function toVoucherBody(voucher) {
+	return {
+		objectName: "Voucher",
+		mapAll: true,
+		status: voucher.status,
+		creditDebit: voucher.creditDebit,
+		taxRule: {
+			id: voucher.taxRuleId,
+			objectName: "TaxRule"
+		},
+		voucherType: voucher.voucherType ?? "VOU",
+		voucherDate: toOptionalVoucherDate(voucher.voucherDate),
+		payDate: toOptionalVoucherDate(voucher.payDate),
+		deliveryDate: toOptionalVoucherDate(voucher.deliveryDate),
+		deliveryDateUntil: toOptionalVoucherDate(voucher.deliveryDateUntil),
+		supplier: toRef(voucher.supplierId, "Contact"),
+		supplierName: voucher.supplierName,
+		description: voucher.description,
+		currency: voucher.currency,
+		propertyExchangeRate: voucher.propertyExchangeRate,
+		costCentre: toRef(voucher.costCentreId, "CostCentre")
+	};
+}
+function toVoucherPositionBody(position) {
+	return {
+		objectName: "VoucherPos",
+		mapAll: true,
+		voucher: null,
+		accountDatev: {
+			id: position.accountDatevId,
+			objectName: "AccountDatev"
+		},
+		taxRate: position.taxRate,
+		net: position.net,
+		sumNet: position.sumNet,
+		sumGross: position.sumGross,
+		isAsset: position.isAsset,
+		comment: position.comment
+	};
+}
+function toRef(id, objectName) {
+	return id === void 0 ? void 0 : {
+		id,
+		objectName
+	};
+}
+function toOptionalVoucherDate(value) {
+	return value === void 0 ? void 0 : toVoucherDate(value);
+}
+//#endregion
+//#region src/client.ts
+var SevDesk = class {
+	basics;
+	checkAccounts;
+	contacts;
+	creditNotes;
+	exports;
+	invoices;
+	orders;
+	parts;
+	receiptGuidance;
+	reports;
+	tags;
+	transactions;
+	vouchers;
+	constructor(options) {
+		const http = new HttpClient(options);
+		this.basics = new BasicsResource(http);
+		this.checkAccounts = new CheckAccountsResource(http);
+		this.contacts = new ContactsResource(http);
+		this.creditNotes = new CreditNotesResource(http);
+		this.exports = new ExportsResource(http);
+		this.invoices = new InvoicesResource(http);
+		this.orders = new OrdersResource(http);
+		this.parts = new PartsResource(http);
+		this.receiptGuidance = new ReceiptGuidanceResource(http);
+		this.reports = new ReportsResource(http);
+		this.tags = new TagsResource(http);
+		this.transactions = new TransactionsResource(http);
+		this.vouchers = new VouchersResource(http);
+	}
+};
+//#endregion
+export { BasicsResource, CheckAccountsResource, ContactsResource, CreditNotesResource, DEFAULT_BASE_URL, ExportsResource, InvoicesResource, OrdersResource, PartsResource, ReceiptGuidanceResource, ReportsResource, SevDesk, SevDeskError, TagsResource, TransactionsResource, VouchersResource, toExportContactFilter, toExportDocumentFilter, toExportInvoiceFilter, toExportSevQueryParams, toExportVoucherFilter };
+
+//# sourceMappingURL=index.js.map