@invowerk-dev/sdk 0.0.0-bootstrap.0 → 1.0.0

package/dist/core/serverSentEvents.gen.js

@@ -0,0 +1,132 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+    let lastEventId;
+    const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const createStream = async function* () {
+        let retryDelay = sseDefaultRetryDelay ?? 3000;
+        let attempt = 0;
+        const signal = options.signal ?? new AbortController().signal;
+        while (true) {
+            if (signal.aborted)
+                break;
+            attempt++;
+            const headers = options.headers instanceof Headers
+                ? options.headers
+                : new Headers(options.headers);
+            if (lastEventId !== undefined) {
+                headers.set('Last-Event-ID', lastEventId);
+            }
+            try {
+                const requestInit = {
+                    redirect: 'follow',
+                    ...options,
+                    body: options.serializedBody,
+                    headers,
+                    signal,
+                };
+                let request = new Request(url, requestInit);
+                if (onRequest) {
+                    request = await onRequest(url, requestInit);
+                }
+                // fetch must be assigned here, otherwise it would throw the error:
+                // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+                const _fetch = options.fetch ?? globalThis.fetch;
+                const response = await _fetch(request);
+                if (!response.ok)
+                    throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+                if (!response.body)
+                    throw new Error('No body in SSE response');
+                const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+                let buffer = '';
+                const abortHandler = () => {
+                    try {
+                        reader.cancel();
+                    }
+                    catch {
+                        // noop
+                    }
+                };
+                signal.addEventListener('abort', abortHandler);
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += value;
+                        buffer = buffer.replace(/\r\n?/g, '\n'); // normalize line endings
+                        const chunks = buffer.split('\n\n');
+                        buffer = chunks.pop() ?? '';
+                        for (const chunk of chunks) {
+                            const lines = chunk.split('\n');
+                            const dataLines = [];
+                            let eventName;
+                            for (const line of lines) {
+                                if (line.startsWith('data:')) {
+                                    dataLines.push(line.replace(/^data:\s*/, ''));
+                                }
+                                else if (line.startsWith('event:')) {
+                                    eventName = line.replace(/^event:\s*/, '');
+                                }
+                                else if (line.startsWith('id:')) {
+                                    lastEventId = line.replace(/^id:\s*/, '');
+                                }
+                                else if (line.startsWith('retry:')) {
+                                    const parsed = Number.parseInt(line.replace(/^retry:\s*/, ''), 10);
+                                    if (!Number.isNaN(parsed)) {
+                                        retryDelay = parsed;
+                                    }
+                                }
+                            }
+                            let data;
+                            let parsedJson = false;
+                            if (dataLines.length) {
+                                const rawData = dataLines.join('\n');
+                                try {
+                                    data = JSON.parse(rawData);
+                                    parsedJson = true;
+                                }
+                                catch {
+                                    data = rawData;
+                                }
+                            }
+                            if (parsedJson) {
+                                if (responseValidator) {
+                                    await responseValidator(data);
+                                }
+                                if (responseTransformer) {
+                                    data = await responseTransformer(data);
+                                }
+                            }
+                            onSseEvent?.({
+                                data,
+                                event: eventName,
+                                id: lastEventId,
+                                retry: retryDelay,
+                            });
+                            if (dataLines.length) {
+                                yield data;
+                            }
+                        }
+                    }
+                }
+                finally {
+                    signal.removeEventListener('abort', abortHandler);
+                    reader.releaseLock();
+                }
+                break; // exit loop on normal completion
+            }
+            catch (error) {
+                // connection failed or aborted; retry after delay
+                onSseError?.(error);
+                if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+                    break; // stop after firing error
+                }
+                // exponential backoff: double retry each attempt, cap at 30s
+                const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+                await sleep(backoff);
+            }
+        }
+    };
+    const stream = createStream();
+    return { stream };
+}

package/dist/core/types.gen.d.ts

@@ -0,0 +1,83 @@
+import type { Auth, AuthToken } from './auth.gen.js';
+import type { BodySerializer, QuerySerializer, QuerySerializerOptions } from './bodySerializer.gen.js';
+export type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+export type Client<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+export interface Config {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+export interface ClientMeta {
+}
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never] ? true : [T] extends [never | undefined] ? [undefined] extends [T] ? false : true : false;
+export type OmitNever<T extends Record<string, unknown>> = {
+    [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K];
+};
+export {};

package/dist/core/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};

package/dist/core/utils.gen.d.ts

@@ -0,0 +1,19 @@
+import type { BodySerializer, QuerySerializer } from './bodySerializer.gen.js';
+export interface PathSerializer {
+    path: Record<string, unknown>;
+    url: string;
+}
+export declare const PATH_PARAM_RE: RegExp;
+export declare const defaultPathSerializer: ({ path, url: _url }: PathSerializer) => string;
+export declare const getUrl: ({ baseUrl, path, query, querySerializer, url: _url, }: {
+    baseUrl?: string;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    querySerializer: QuerySerializer;
+    url: string;
+}) => string;
+export declare function getValidRequestBody(options: {
+    body?: unknown;
+    bodySerializer?: BodySerializer | null;
+    serializedBody?: unknown;
+}): unknown;

package/dist/core/utils.gen.js

@@ -0,0 +1,87 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { serializeArrayParam, serializeObjectParam, serializePrimitiveParam, } from './pathSerializer.gen.js';
+export const PATH_PARAM_RE = /\{[^{}]+\}/g;
+export const defaultPathSerializer = ({ path, url: _url }) => {
+    let url = _url;
+    const matches = _url.match(PATH_PARAM_RE);
+    if (matches) {
+        for (const match of matches) {
+            let explode = false;
+            let name = match.substring(1, match.length - 1);
+            let style = 'simple';
+            if (name.endsWith('*')) {
+                explode = true;
+                name = name.substring(0, name.length - 1);
+            }
+            if (name.startsWith('.')) {
+                name = name.substring(1);
+                style = 'label';
+            }
+            else if (name.startsWith(';')) {
+                name = name.substring(1);
+                style = 'matrix';
+            }
+            const value = path[name];
+            if (value === undefined || value === null) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+                continue;
+            }
+            if (typeof value === 'object') {
+                url = url.replace(match, serializeObjectParam({
+                    explode,
+                    name,
+                    style,
+                    value: value,
+                    valueOnly: true,
+                }));
+                continue;
+            }
+            if (style === 'matrix') {
+                url = url.replace(match, `;${serializePrimitiveParam({
+                    name,
+                    value: value,
+                })}`);
+                continue;
+            }
+            const replaceValue = encodeURIComponent(style === 'label' ? `.${value}` : value);
+            url = url.replace(match, replaceValue);
+        }
+    }
+    return url;
+};
+export const getUrl = ({ baseUrl, path, query, querySerializer, url: _url, }) => {
+    const pathUrl = _url.startsWith('/') ? _url : `/${_url}`;
+    let url = (baseUrl ?? '') + pathUrl;
+    if (path) {
+        url = defaultPathSerializer({ path, url });
+    }
+    let search = query ? querySerializer(query) : '';
+    if (search.startsWith('?')) {
+        search = search.substring(1);
+    }
+    if (search) {
+        url += `?${search}`;
+    }
+    return url;
+};
+export function getValidRequestBody(options) {
+    const hasBody = options.body !== undefined;
+    const isSerializedBody = hasBody && options.bodySerializer;
+    if (isSerializedBody) {
+        if ('serializedBody' in options) {
+            const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== '';
+            return hasSerializedBody ? options.serializedBody : null;
+        }
+        // not all clients implement a serializedBody property (i.e., client-axios)
+        return options.body !== '' ? options.body : null;
+    }
+    // plain/text body
+    if (hasBody) {
+        return options.body;
+    }
+    // no body was provided
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { client, type CreateClientConfig } from './client.gen.js';
+export { convertInvoice, explainCodes, generateInvoice, getMe, type Options, parseInvoice, renderInvoice, validateInvoice } from './sdk.gen.js';
+export type { BodyRenderInvoice, Buyer, ClientOptions, ContentClass, ConvertInvoiceData, ConvertInvoiceError, ConvertInvoiceErrors, ConvertInvoiceResponse, ConvertInvoiceResponses, ConvertResponse, ConvertSelfValidation, CreditsInfo, DocumentTotals, ERechnungDe, ErrorClasses, Evidence, ExplainCodesData, ExplainCodesError, ExplainCodesErrors, ExplainCodesResponse, ExplainCodesResponses, ExplainResponse, Finding, Flavor, GenerateInvoiceData, GenerateInvoiceError, GenerateInvoiceErrors, GenerateInvoiceResponse, GenerateInvoiceResponses, GenerateRequest, GenerateResponse, GetMeData, GetMeResponse, GetMeResponses, HintInfo, InvoiceLine, MeResponse, ParseDetection, ParseInvoiceData, ParseInvoiceResponse, ParseInvoiceResponses, ParseResponse, PostalAddress, Problem, RateLimitInfo, RenderInvoiceData, RenderInvoiceError, RenderInvoiceErrors, RenderInvoiceResponse, RenderInvoiceResponses, RenderResponse, RuleExplanation, ScenarioInfo, SelfValidation, Seller, Syntax, TaxBreakdown, ValidateInvoiceData, ValidateInvoiceError, ValidateInvoiceErrors, ValidateInvoiceResponse, ValidateInvoiceResponses, ValidationResponse, ValidatorVersions } from './types.gen.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { client } from './client.gen.js';
+export { convertInvoice, explainCodes, generateInvoice, getMe, parseInvoice, renderInvoice, validateInvoice } from './sdk.gen.js';

package/dist/sdk.gen.d.ts

@@ -0,0 +1,148 @@
+import { type Client, type ClientMeta, type Options as Options2, type RequestResult, type TDataShape } from './client/index.js';
+import type { ConvertInvoiceData, ConvertInvoiceErrors, ConvertInvoiceResponses, ExplainCodesData, ExplainCodesErrors, ExplainCodesResponses, GenerateInvoiceData, GenerateInvoiceErrors, GenerateInvoiceResponses, GetMeData, GetMeResponses, ParseInvoiceData, ParseInvoiceResponses, RenderInvoiceData, RenderInvoiceErrors, RenderInvoiceResponses, ValidateInvoiceData, ValidateInvoiceErrors, ValidateInvoiceResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+/**
+ * Your plan, remaining requests, and remaining credits
+ *
+ * Check where you stand before a call fails.
+ *
+ * Returns the plan this request runs on and whether your key was recognized.
+ * Without an `X-API-Key`, the call runs anonymously at the rate limit for
+ * calls without a key. It also returns the requests left in the current window
+ * and the features your plan includes. On plans priced in credits, it returns
+ * the credits left in the current billing period.
+ *
+ * This call does not count against your rate limit, so the numbers it reports
+ * are the numbers you have.
+ *
+ * **Credits:** free. This endpoint is not metered.
+ */
+export declare const getMe: <ThrowOnError extends boolean = false>(options?: Options<GetMeData, ThrowOnError>) => RequestResult<GetMeResponses, unknown, ThrowOnError>;
+/**
+ * Read an e-invoice into JSON
+ *
+ * Read an existing e-invoice into JSON keyed on EN 16931 Business Terms.
+ *
+ * The JSON in `model` is the request body of `POST /v1/generate`, so you can edit
+ * it and create the invoice again. Send an XML invoice (UBL or CII) or a
+ * ZUGFeRD / Factur-X PDF as the raw request body or as a multipart file part, at
+ * most 20 MB. A PDF may have at most 500 pages and 16 attachments. UBL credit
+ * notes are not supported. The answer also has `detection` (syntax, flavor,
+ * CustomizationID) and `source` (`xml` or `pdf-embedded`). A file that cannot be
+ * read returns 422; `detail` starts with an error code. More than 100,000 XML
+ * elements return 413; 429 means every slot is busy (callers without an API key
+ * share one), 504 that reading took longer than 20 s. Costs 2 credits.
+ *
+ * **Credits:** 2 per call.
+ */
+export declare const parseInvoice: <ThrowOnError extends boolean = false>(options: Options<ParseInvoiceData, ThrowOnError>) => RequestResult<ParseInvoiceResponses, unknown, ThrowOnError>;
+/**
+ * Convert an e-invoice between UBL and CII
+ *
+ * Convert an e-invoice between UBL and CII.
+ *
+ * Send the invoice as for `POST /v1/parse`: XML or a ZUGFeRD / Factur-X PDF, raw
+ * body or multipart file part, at most 20 MB. `target_syntax` is required (`ubl`
+ * or `cii`). `target_flavor` (`en16931` or `xrechnung`) is optional; without it
+ * the flavor of the source is kept. invowerk checks the converted XML before
+ * answering and never returns an invalid document. The answer is
+ * `application/xml`; `?format=json` returns `{xml, syntax, flavor,
+ * self_validation}`. Errors: 422 when the input cannot be read, with an error code
+ * at the start of `detail`; 500 when the converted XML fails the check (the
+ * credits are refunded); 413, 429 and 504 as for `POST /v1/parse`. Costs 3
+ * credits.
+ *
+ * **Credits:** 3 per call.
+ */
+export declare const convertInvoice: <ThrowOnError extends boolean = false>(options: Options<ConvertInvoiceData, ThrowOnError>) => RequestResult<ConvertInvoiceResponses, ConvertInvoiceErrors, ThrowOnError>;
+/**
+ * Create an e-invoice from JSON
+ *
+ * Create an EN 16931 e-invoice from JSON.
+ *
+ * The JSON body is keyed on EN 16931 Business Terms (BT-*). `syntax` selects UBL
+ * (default) or CII. `flavor` selects plain EN 16931 (default) or XRechnung, which
+ * requires `buyer_reference` (BT-10, the Leitweg-ID). invowerk writes your
+ * amounts as given. It does not compute or correct them. Before answering,
+ * invowerk checks the generated XML and never returns an invalid document. The
+ * answer is `application/xml`; `?format=json` returns
+ * `{xml, syntax, flavor, self_validation}`. Errors: 422 for invalid input, with
+ * details per field; 500 when the generated XML fails the check (the credits are
+ * refunded); 429 when every slot is busy (callers without an API key share
+ * one); 504 when it took longer than 20 s. Costs 5 credits.
+ *
+ * **Credits:** 5 per call.
+ */
+export declare const generateInvoice: <ThrowOnError extends boolean = false>(options: Options<GenerateInvoiceData, ThrowOnError>) => RequestResult<GenerateInvoiceResponses, GenerateInvoiceErrors, ThrowOnError>;
+/**
+ * Explain an error code
+ *
+ * Explain rule codes and invowerk's own `IW-*` Hinweise in German or English.
+ *
+ * For each code the answer has the title, what the rule requires, common causes,
+ * how to fix the invoice, the affected Business Terms and `explain_url`, the path
+ * of the German page under `/codes/`. The codes appear in `findings` and `hints`
+ * of `POST /v1/validate`. If any code has no explanation, the answer is HTTP 404
+ * and names those codes. Costs 0 credits; an API key is not needed and does not
+ * raise the rate limit.
+ *
+ * **Credits:** free. This endpoint is not metered.
+ */
+export declare const explainCodes: <ThrowOnError extends boolean = false>(options: Options<ExplainCodesData, ThrowOnError>) => RequestResult<ExplainCodesResponses, ExplainCodesErrors, ThrowOnError>;
+/**
+ * Render an e-invoice as HTML
+ *
+ * Render an XML e-invoice as a readable HTML page.
+ *
+ * Send an XML invoice (UBL or CII, e.g. XRechnung) as the raw request body or as
+ * a multipart `file` part. PDFs are not accepted. invowerk renders it with the
+ * KoSIT XRechnung visualization and answers with `text/html`; `?format=json`
+ * returns `{html, lang, flavor, syntax}` instead. `lang` sets the label language
+ * (`de` or `en`; otherwise `Accept-Language`, then `de`). Errors: 400 for an
+ * empty body, 415 for a file that is not an XML invoice, 422 for malformed XML or
+ * a DOCTYPE, 413 for more than 100,000 elements, 429 when every render slot is
+ * busy (callers without an API key share one), 504 when the render ran longer
+ * than 20 s. Costs 1 credit.
+ *
+ * **Credits:** 1 per call.
+ */
+export declare const renderInvoice: <ThrowOnError extends boolean = false>(options?: Options<RenderInvoiceData, ThrowOnError>) => RequestResult<RenderInvoiceResponses, RenderInvoiceErrors, ThrowOnError>;
+/**
+ * Check an e-invoice
+ *
+ * Check an e-invoice against EN 16931 and the German rules.
+ *
+ * Send an XML invoice (UBL or CII, e.g. XRechnung) or a ZUGFeRD / Factur-X PDF as
+ * the raw request body or as a multipart file part, at most 20 MB. A PDF may have
+ * at most 500 pages and 16 attachments. invowerk detects the format from the
+ * bytes, not from the Content-Type. A larger body gets HTTP 413. Otherwise the
+ * answer is always HTTP 200, because a failed check is a result, not an error.
+ * `valid` is the result, `findings` lists each problem, `e_rechnung_de` maps the
+ * result onto the BMF categories and `evidence` identifies the checked file.
+ * `hints` are extra observations that never change `valid`. For XRechnung the
+ * KoSIT validator decides `valid`. If it is unreachable, invowerk's own check
+ * with the same rules decides, `verdict_source` is `local` and the
+ * `X-EInvoice-Degraded` header is set (`official-lane-unavailable`;
+ * `pdfa-lane-unavailable` when the PDF/A check did not answer; comma-separated).
+ * `disagreement` is true when both checks ran and differ. For a PDF,
+ * `pdfa_verdict` is the PDF/A check with veraPDF. `?explain=true` adds the
+ * explanation for rules that have one, in `lang` (`de` or `en`). An XML file
+ * with more than 100,000 elements gets HTTP 413. HTTP 429 means every check
+ * slot is busy (callers without an API key share one), HTTP 504 that the check
+ * ran longer than 20 s. Costs 1 credit.
+ *
+ * **Credits:** 1 per call.
+ */
+export declare const validateInvoice: <ThrowOnError extends boolean = false>(options: Options<ValidateInvoiceData, ThrowOnError>) => RequestResult<ValidateInvoiceResponses, ValidateInvoiceErrors, ThrowOnError>;

package/dist/sdk.gen.js

@@ -0,0 +1,188 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { client } from './client.gen.js';
+import { formDataBodySerializer } from './client/index.js';
+/**
+ * Your plan, remaining requests, and remaining credits
+ *
+ * Check where you stand before a call fails.
+ *
+ * Returns the plan this request runs on and whether your key was recognized.
+ * Without an `X-API-Key`, the call runs anonymously at the rate limit for
+ * calls without a key. It also returns the requests left in the current window
+ * and the features your plan includes. On plans priced in credits, it returns
+ * the credits left in the current billing period.
+ *
+ * This call does not count against your rate limit, so the numbers it reports
+ * are the numbers you have.
+ *
+ * **Credits:** free. This endpoint is not metered.
+ */
+export const getMe = (options) => (options?.client ?? client).get({
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/me',
+    ...options
+});
+/**
+ * Read an e-invoice into JSON
+ *
+ * Read an existing e-invoice into JSON keyed on EN 16931 Business Terms.
+ *
+ * The JSON in `model` is the request body of `POST /v1/generate`, so you can edit
+ * it and create the invoice again. Send an XML invoice (UBL or CII) or a
+ * ZUGFeRD / Factur-X PDF as the raw request body or as a multipart file part, at
+ * most 20 MB. A PDF may have at most 500 pages and 16 attachments. UBL credit
+ * notes are not supported. The answer also has `detection` (syntax, flavor,
+ * CustomizationID) and `source` (`xml` or `pdf-embedded`). A file that cannot be
+ * read returns 422; `detail` starts with an error code. More than 100,000 XML
+ * elements return 413; 429 means every slot is busy (callers without an API key
+ * share one), 504 that reading took longer than 20 s. Costs 2 credits.
+ *
+ * **Credits:** 2 per call.
+ */
+export const parseInvoice = (options) => (options.client ?? client).post({
+    ...formDataBodySerializer,
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/parse',
+    ...options,
+    headers: {
+        'Content-Type': null,
+        ...options.headers
+    }
+});
+/**
+ * Convert an e-invoice between UBL and CII
+ *
+ * Convert an e-invoice between UBL and CII.
+ *
+ * Send the invoice as for `POST /v1/parse`: XML or a ZUGFeRD / Factur-X PDF, raw
+ * body or multipart file part, at most 20 MB. `target_syntax` is required (`ubl`
+ * or `cii`). `target_flavor` (`en16931` or `xrechnung`) is optional; without it
+ * the flavor of the source is kept. invowerk checks the converted XML before
+ * answering and never returns an invalid document. The answer is
+ * `application/xml`; `?format=json` returns `{xml, syntax, flavor,
+ * self_validation}`. Errors: 422 when the input cannot be read, with an error code
+ * at the start of `detail`; 500 when the converted XML fails the check (the
+ * credits are refunded); 413, 429 and 504 as for `POST /v1/parse`. Costs 3
+ * credits.
+ *
+ * **Credits:** 3 per call.
+ */
+export const convertInvoice = (options) => (options.client ?? client).post({
+    ...formDataBodySerializer,
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/convert',
+    ...options,
+    headers: {
+        'Content-Type': null,
+        ...options.headers
+    }
+});
+/**
+ * Create an e-invoice from JSON
+ *
+ * Create an EN 16931 e-invoice from JSON.
+ *
+ * The JSON body is keyed on EN 16931 Business Terms (BT-*). `syntax` selects UBL
+ * (default) or CII. `flavor` selects plain EN 16931 (default) or XRechnung, which
+ * requires `buyer_reference` (BT-10, the Leitweg-ID). invowerk writes your
+ * amounts as given. It does not compute or correct them. Before answering,
+ * invowerk checks the generated XML and never returns an invalid document. The
+ * answer is `application/xml`; `?format=json` returns
+ * `{xml, syntax, flavor, self_validation}`. Errors: 422 for invalid input, with
+ * details per field; 500 when the generated XML fails the check (the credits are
+ * refunded); 429 when every slot is busy (callers without an API key share
+ * one); 504 when it took longer than 20 s. Costs 5 credits.
+ *
+ * **Credits:** 5 per call.
+ */
+export const generateInvoice = (options) => (options.client ?? client).post({
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/generate',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Explain an error code
+ *
+ * Explain rule codes and invowerk's own `IW-*` Hinweise in German or English.
+ *
+ * For each code the answer has the title, what the rule requires, common causes,
+ * how to fix the invoice, the affected Business Terms and `explain_url`, the path
+ * of the German page under `/codes/`. The codes appear in `findings` and `hints`
+ * of `POST /v1/validate`. If any code has no explanation, the answer is HTTP 404
+ * and names those codes. Costs 0 credits; an API key is not needed and does not
+ * raise the rate limit.
+ *
+ * **Credits:** free. This endpoint is not metered.
+ */
+export const explainCodes = (options) => (options.client ?? client).get({
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/explain',
+    ...options
+});
+/**
+ * Render an e-invoice as HTML
+ *
+ * Render an XML e-invoice as a readable HTML page.
+ *
+ * Send an XML invoice (UBL or CII, e.g. XRechnung) as the raw request body or as
+ * a multipart `file` part. PDFs are not accepted. invowerk renders it with the
+ * KoSIT XRechnung visualization and answers with `text/html`; `?format=json`
+ * returns `{html, lang, flavor, syntax}` instead. `lang` sets the label language
+ * (`de` or `en`; otherwise `Accept-Language`, then `de`). Errors: 400 for an
+ * empty body, 415 for a file that is not an XML invoice, 422 for malformed XML or
+ * a DOCTYPE, 413 for more than 100,000 elements, 429 when every render slot is
+ * busy (callers without an API key share one), 504 when the render ran longer
+ * than 20 s. Costs 1 credit.
+ *
+ * **Credits:** 1 per call.
+ */
+export const renderInvoice = (options) => (options?.client ?? client).post({
+    ...formDataBodySerializer,
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/render',
+    ...options,
+    headers: {
+        'Content-Type': null,
+        ...options?.headers
+    }
+});
+/**
+ * Check an e-invoice
+ *
+ * Check an e-invoice against EN 16931 and the German rules.
+ *
+ * Send an XML invoice (UBL or CII, e.g. XRechnung) or a ZUGFeRD / Factur-X PDF as
+ * the raw request body or as a multipart file part, at most 20 MB. A PDF may have
+ * at most 500 pages and 16 attachments. invowerk detects the format from the
+ * bytes, not from the Content-Type. A larger body gets HTTP 413. Otherwise the
+ * answer is always HTTP 200, because a failed check is a result, not an error.
+ * `valid` is the result, `findings` lists each problem, `e_rechnung_de` maps the
+ * result onto the BMF categories and `evidence` identifies the checked file.
+ * `hints` are extra observations that never change `valid`. For XRechnung the
+ * KoSIT validator decides `valid`. If it is unreachable, invowerk's own check
+ * with the same rules decides, `verdict_source` is `local` and the
+ * `X-EInvoice-Degraded` header is set (`official-lane-unavailable`;
+ * `pdfa-lane-unavailable` when the PDF/A check did not answer; comma-separated).
+ * `disagreement` is true when both checks ran and differ. For a PDF,
+ * `pdfa_verdict` is the PDF/A check with veraPDF. `?explain=true` adds the
+ * explanation for rules that have one, in `lang` (`de` or `en`). An XML file
+ * with more than 100,000 elements gets HTTP 413. HTTP 429 means every check
+ * slot is busy (callers without an API key share one), HTTP 504 that the check
+ * ran longer than 20 s. Costs 1 credit.
+ *
+ * **Credits:** 1 per call.
+ */
+export const validateInvoice = (options) => (options.client ?? client).post({
+    ...formDataBodySerializer,
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/v1/validate',
+    ...options,
+    headers: {
+        'Content-Type': null,
+        ...options.headers
+    }
+});