@voyant-travel/plugin-smartbill 0.119.2

package/dist/client.js

@@ -0,0 +1,234 @@
+import { createCircuitBreaker, resilientFetch } from "@voyant-travel/utils/resilience";
+import { SmartbillApiError, SmartbillRateLimitCircuitOpenError, SmartbillRateLimitError, } from "./client/errors.js";
+import { asResilientFetch, createGlobalSmartbillFetch } from "./client/fetch.js";
+import { parseSmartbillRateLimit } from "./client/rate-limit.js";
+import { surfacingRetry } from "./client/resilience.js";
+export { SmartbillApiError, SmartbillRateLimitCircuitOpenError, SmartbillRateLimitError, } from "./client/errors.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function createSmartbillClient(options) {
+    const apiUrl = (options.apiUrl ?? "https://ws.smartbill.ro/SBORO/api").replace(/\/$/, "");
+    const fetchImpl = options.fetch ?? createGlobalSmartbillFetch();
+    const now = options.rateLimit?.now ?? (() => new Date());
+    let rateLimitCircuitOpenUntil;
+    const resilience = options.resilience ?? {};
+    // One breaker per upstream SmartBill account — the client is a per-worker
+    // singleton, so a per-instance breaker has the right scope.
+    const breaker = resilience.breaker ?? createCircuitBreaker();
+    const timeoutMs = resilience.timeoutMs ?? 10_000;
+    const retryTuning = resilience.retry === false ? undefined : resilience.retry;
+    function maxAttemptsFor(retryable) {
+        return retryable && resilience.retry !== false ? (retryTuning?.attempts ?? 3) : 1;
+    }
+    function authHeader() {
+        return `Basic ${btoa(`${options.username}:${options.apiToken}`)}`;
+    }
+    function headers() {
+        return {
+            Authorization: authHeader(),
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        };
+    }
+    async function request(operation, method, path, body, requestOptions) {
+        if (!fetchImpl) {
+            throw new Error("SmartBill client requires a fetch implementation");
+        }
+        assertRateLimitCircuitClosed(operation);
+        const init = {
+            method,
+            headers: headers(),
+        };
+        if (body !== undefined)
+            init.body = JSON.stringify(body);
+        // Default policy: GET/PUT/DELETE are idempotent against SmartBill (state
+        // setters, lookups), POSTs create documents and must not retry. Call
+        // sites override where the HTTP method is misleading (e.g. reverse).
+        const retryable = requestOptions?.retryable ?? method !== "POST";
+        const response = await resilientFetch(`${apiUrl}${path}`, init, {
+            timeoutMs,
+            breaker,
+            // Per-operation policy above already gates retries via attempts.
+            retryNonIdempotent: true,
+            retry: surfacingRetry(maxAttemptsFor(retryable), retryTuning),
+            fetchImpl: asResilientFetch(fetchImpl),
+        });
+        let text = "";
+        let parsed = null;
+        try {
+            text = await response.text();
+            parsed = text ? JSON.parse(text) : null;
+        }
+        catch {
+            // leave parsed as null, surface text
+        }
+        if (!response.ok) {
+            throw buildApiError(operation, response.status, text, parsed);
+        }
+        const envelope = (parsed ?? {});
+        if (envelope.status === "Error" || envelope.errorText) {
+            throw buildApiError(operation, response.status, text, parsed);
+        }
+        return envelope;
+    }
+    async function fetchPdf(operation, path) {
+        if (!fetchImpl) {
+            throw new Error("SmartBill client requires a fetch implementation");
+        }
+        assertRateLimitCircuitClosed(operation);
+        const response = await resilientFetch(`${apiUrl}${path}`, {
+            method: "GET",
+            headers: { ...headers(), Accept: "application/octet-stream" },
+        }, {
+            timeoutMs,
+            breaker,
+            // PDF downloads are pure reads — always safe to retry.
+            retry: surfacingRetry(maxAttemptsFor(true), retryTuning),
+            fetchImpl: asResilientFetch(fetchImpl),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw buildApiError(operation, response.status, text, parseJson(text));
+        }
+        const buffer = await response.arrayBuffer();
+        const contentType = response.headers?.get("content-type") ?? "application/pdf";
+        return { bytes: new Uint8Array(buffer), contentType };
+    }
+    function pdfQuery(companyVatCode, seriesName, number) {
+        return `cif=${encodeURIComponent(companyVatCode)}&seriesname=${encodeURIComponent(seriesName)}&number=${encodeURIComponent(number)}`;
+    }
+    function assertRateLimitCircuitClosed(operation) {
+        if (!options.rateLimit?.circuitBreaker || !rateLimitCircuitOpenUntil)
+            return;
+        const currentTime = now();
+        if (currentTime.getTime() >= rateLimitCircuitOpenUntil.getTime()) {
+            rateLimitCircuitOpenUntil = undefined;
+            return;
+        }
+        throw new SmartbillRateLimitCircuitOpenError({
+            operation,
+            retryAfterAt: rateLimitCircuitOpenUntil,
+            retryAfterMs: rateLimitCircuitOpenUntil.getTime() - currentTime.getTime(),
+        });
+    }
+    function buildApiError(operation, status, text, parsed) {
+        const rateLimit = parseSmartbillRateLimit(status, parsed, now());
+        if (rateLimit) {
+            if (options.rateLimit?.circuitBreaker && rateLimit.retryAfterAt) {
+                rateLimitCircuitOpenUntil = rateLimit.retryAfterAt;
+            }
+            return new SmartbillRateLimitError(`SmartBill ${operation} rate-limited: ${rateLimit.errorText}`, {
+                operation,
+                status,
+                body: text,
+                response: parsed,
+                retryAfterMs: rateLimit.retryAfterMs,
+                retryAfterAt: rateLimit.retryAfterAt,
+                blockedAt: rateLimit.blockedAt,
+            });
+        }
+        const envelope = isRecord(parsed) ? parsed : null;
+        const message = envelope?.errorText || envelope?.message
+            ? `SmartBill ${operation} failed: ${envelope.errorText ?? envelope.message ?? "Error"}`
+            : `SmartBill ${operation} failed (${status}): ${text}`;
+        return new SmartbillApiError(message, {
+            operation,
+            status,
+            body: text,
+            response: parsed,
+        });
+    }
+    function parseJson(text) {
+        try {
+            return text ? JSON.parse(text) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async function createInvoice(body) {
+        // No retry: POST creates an invoice and SmartBill has no idempotency
+        // keys — a duplicate invoice is worse than a failed sync (the outbox
+        // redelivers, and external-ref dedup skips already-created invoices).
+        return request("createInvoice", "POST", "/invoice", body);
+    }
+    async function createProforma(body) {
+        // No retry: creates a proforma document (same reasoning as createInvoice).
+        return request("createProforma", "POST", "/estimate", body);
+    }
+    async function convertEstimateToInvoice(companyVatCode, estimateSeriesName, estimateNumber, body) {
+        // No retry: POST creates the converted invoice (no idempotency keys).
+        return request("convertEstimateToInvoice", "POST", "/invoice", {
+            ...body,
+            companyVatCode,
+            useEstimateDetails: true,
+            estimate: {
+                seriesName: estimateSeriesName,
+                number: estimateNumber,
+            },
+            useStock: body.useStock ?? false,
+        });
+    }
+    async function cancelInvoice(companyVatCode, seriesName, number) {
+        // Retried: cancel is an idempotent state-setter (cancelling twice is a no-op).
+        return request("cancelInvoice", "PUT", "/invoice/cancel", {
+            companyVatCode,
+            seriesName,
+            number,
+        });
+    }
+    async function restoreInvoice(companyVatCode, seriesName, number) {
+        return request("restoreInvoice", "PUT", "/invoice/restore", {
+            companyVatCode,
+            seriesName,
+            number,
+        });
+    }
+    async function deleteInvoice(companyVatCode, seriesName, number) {
+        return request("deleteInvoice", "DELETE", `/invoice?${pdfQuery(companyVatCode, seriesName, number)}`);
+    }
+    async function reverseInvoice(companyVatCode, seriesName, number) {
+        // No retry despite the PUT: reversing issues a NEW credit-note style
+        // reversal invoice, so a retried ambiguous failure could double-reverse.
+        return request("reverseInvoice", "PUT", "/invoice/reverse", {
+            companyVatCode,
+            seriesName,
+            number,
+        }, { retryable: false });
+    }
+    async function viewInvoicePdf(companyVatCode, seriesName, number) {
+        return fetchPdf("viewInvoicePdf", `/invoice/pdf?${pdfQuery(companyVatCode, seriesName, number)}`);
+    }
+    async function viewEstimatePdf(companyVatCode, seriesName, number) {
+        return fetchPdf("viewEstimatePdf", `/estimate/pdf?${pdfQuery(companyVatCode, seriesName, number)}`);
+    }
+    async function getPaymentStatus(companyVatCode, seriesName, number) {
+        return request("getPaymentStatus", "GET", `/invoice/paymentstatus?${pdfQuery(companyVatCode, seriesName, number)}`);
+    }
+    async function listTaxes() {
+        return request("listTaxes", "GET", "/tax");
+    }
+    async function listSeries() {
+        return request("listSeries", "GET", "/series");
+    }
+    async function listEstimateInvoices(companyVatCode, seriesName, number) {
+        return request("listEstimateInvoices", "GET", `/estimate/invoices?${pdfQuery(companyVatCode, seriesName, number)}`);
+    }
+    return {
+        createInvoice,
+        createProforma,
+        convertEstimateToInvoice,
+        cancelInvoice,
+        restoreInvoice,
+        deleteInvoice,
+        reverseInvoice,
+        viewInvoicePdf,
+        viewPdf: viewInvoicePdf,
+        viewEstimatePdf,
+        getPaymentStatus,
+        listTaxes,
+        listSeries,
+        listEstimateInvoices,
+    };
+}

package/dist/hono.d.ts

@@ -0,0 +1,199 @@
+import type { ModuleContainer } from "@voyant-travel/core";
+import type { HonoModule } from "@voyant-travel/hono/module";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { SmartbillPluginOptions } from "./plugin.js";
+type Env = {
+    Bindings: Record<string, unknown>;
+    Variables: {
+        container?: ModuleContainer;
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export interface SmartbillAdminModuleOptions {
+    pluginOptions: SmartbillPluginOptions | SmartbillPluginOptionsResolver;
+}
+export type SmartbillPluginOptionsResolver = (bindings: Record<string, unknown>) => SmartbillPluginOptions;
+export interface SmartbillAdminRouteRuntime {
+    pluginOptions: SmartbillPluginOptions;
+}
+export declare const SMARTBILL_ADMIN_RUNTIME_CONTAINER_KEY = "providers.smartbill.adminRuntime";
+export declare function createSmartbillAdminRoutes(options: SmartbillAdminModuleOptions): import("hono/hono-base").HonoBase<Env, {
+    "/invoices/:id/sync": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 409;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    status: "existing_ref";
+                    invoiceId: string;
+                    documentType: import("./artifacts.js").SmartbillDocumentType;
+                    externalRef: {
+                        metadata: import("hono/utils/types").JSONValue;
+                        id: string;
+                        externalId: string | null;
+                        externalNumber: string | null;
+                        externalUrl: string | null;
+                        invoiceId: string;
+                    };
+                    artifact: {
+                        status: "skipped";
+                        reason: "missing_db" | "missing_invoice" | "missing_document_storage" | "missing_smartbill_reference";
+                    } | {
+                        status: "registered_ref";
+                        reason?: "missing_number" | undefined;
+                    } | {
+                        status: "already_exists";
+                        attachment: {
+                            metadata: import("hono/utils/types").JSONValue;
+                            id: string;
+                            name: string;
+                            createdAt: string;
+                            storageKey: string | null;
+                            kind: string;
+                            fileSize: number | null;
+                            checksum: string | null;
+                            mimeType: string | null;
+                            invoiceId: string;
+                        } | null;
+                    } | {
+                        status: "persisted";
+                        rendition: {
+                            metadata: import("hono/utils/types").JSONValue;
+                            format: "json" | "html" | "pdf" | "xml";
+                            id: string;
+                            status: "failed" | "pending" | "ready" | "stale";
+                            createdAt: string;
+                            updatedAt: string;
+                            storageKey: string | null;
+                            errorMessage: string | null;
+                            language: string | null;
+                            templateId: string | null;
+                            fileSize: number | null;
+                            checksum: string | null;
+                            generatedAt: string | null;
+                            invoiceId: string;
+                        } | null;
+                        attachment: {
+                            metadata: import("hono/utils/types").JSONValue;
+                            id: string;
+                            name: string;
+                            createdAt: string;
+                            storageKey: string | null;
+                            kind: string;
+                            fileSize: number | null;
+                            checksum: string | null;
+                            mimeType: string | null;
+                            invoiceId: string;
+                        } | null;
+                    } | null;
+                } | {
+                    status: "created";
+                    invoiceId: string;
+                    documentType: import("./artifacts.js").SmartbillDocumentType;
+                    result: {
+                        number?: string | undefined;
+                        series?: string | undefined;
+                        url?: string | undefined;
+                        status?: string | undefined;
+                        message?: string | undefined;
+                        errorText?: string | undefined;
+                    };
+                    artifact: {
+                        status: "skipped";
+                        reason: "missing_db" | "missing_invoice" | "missing_document_storage" | "missing_smartbill_reference";
+                    } | {
+                        status: "registered_ref";
+                        reason?: "missing_number" | undefined;
+                    } | {
+                        status: "already_exists";
+                        attachment: {
+                            metadata: import("hono/utils/types").JSONValue;
+                            id: string;
+                            name: string;
+                            createdAt: string;
+                            storageKey: string | null;
+                            kind: string;
+                            fileSize: number | null;
+                            checksum: string | null;
+                            mimeType: string | null;
+                            invoiceId: string;
+                        } | null;
+                    } | {
+                        status: "persisted";
+                        rendition: {
+                            metadata: import("hono/utils/types").JSONValue;
+                            format: "json" | "html" | "pdf" | "xml";
+                            id: string;
+                            status: "failed" | "pending" | "ready" | "stale";
+                            createdAt: string;
+                            updatedAt: string;
+                            storageKey: string | null;
+                            errorMessage: string | null;
+                            language: string | null;
+                            templateId: string | null;
+                            fileSize: number | null;
+                            checksum: string | null;
+                            generatedAt: string | null;
+                            invoiceId: string;
+                        } | null;
+                        attachment: {
+                            metadata: import("hono/utils/types").JSONValue;
+                            id: string;
+                            name: string;
+                            createdAt: string;
+                            storageKey: string | null;
+                            kind: string;
+                            fileSize: number | null;
+                            checksum: string | null;
+                            mimeType: string | null;
+                            invoiceId: string;
+                        } | null;
+                    } | null;
+                };
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 502;
+        };
+    };
+}, "/", "/invoices/:id/sync">;
+export declare function createSmartbillAdminModule(options: SmartbillAdminModuleOptions): HonoModule;
+export declare function buildSmartbillAdminRouteRuntime(bindings: Record<string, unknown>, options: SmartbillAdminModuleOptions): SmartbillAdminRouteRuntime;
+export {};
+//# sourceMappingURL=hono.d.ts.map

package/dist/hono.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono.d.ts","sourceRoot":"","sources":["../src/hono.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAKlE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGzD,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,SAAS,CAAC,EAAE,eAAe,CAAA;QAC3B,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,sBAAsB,GAAG,8BAA8B,CAAA;CACvE;AAED,MAAM,MAAM,8BAA8B,GAAG,CAC3C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,sBAAsB,CAAA;AAE3B,MAAM,WAAW,0BAA0B;IACzC,aAAa,EAAE,sBAAsB,CAAA;CACtC;AAED,eAAO,MAAM,qCAAqC,qCAAqC,CAAA;AAEvF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAyB9E;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,2BAA2B,GAAG,UAAU,CAe3F;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CAO5B"}

package/dist/hono.js

@@ -0,0 +1,77 @@
+import { FINANCE_ROUTE_RUNTIME_CONTAINER_KEY, } from "@voyant-travel/finance";
+import { Hono } from "hono";
+import { syncSmartbillInvoice } from "./sync.js";
+export const SMARTBILL_ADMIN_RUNTIME_CONTAINER_KEY = "providers.smartbill.adminRuntime";
+export function createSmartbillAdminRoutes(options) {
+    return new Hono().post("/invoices/:id/sync", async (c) => {
+        try {
+            const runtime = resolveSmartbillAdminRouteRuntime(c, options);
+            const financeRuntime = resolveFinanceRouteRuntime(c.var.container);
+            const result = await syncSmartbillInvoice({
+                db: c.get("db"),
+                invoiceId: c.req.param("id"),
+                pluginOptions: runtime.pluginOptions,
+                issueRuntime: financeRuntime,
+            });
+            if (result.status === "not_found") {
+                return c.json({ error: "Invoice not found" }, 404);
+            }
+            if (result.status === "unsupported_document_type") {
+                return c.json({ error: `SmartBill sync does not support ${result.invoiceType}` }, 409);
+            }
+            return c.json({ data: result }, result.status === "created" ? 201 : 200);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "SmartBill sync failed";
+            return c.json({ error: message }, 502);
+        }
+    });
+}
+export function createSmartbillAdminModule(options) {
+    const module = {
+        name: "smartbill",
+        bootstrap: ({ bindings, container }) => {
+            container.register(SMARTBILL_ADMIN_RUNTIME_CONTAINER_KEY, buildSmartbillAdminRouteRuntime(bindings, options));
+        },
+    };
+    return {
+        module,
+        adminRoutes: createSmartbillAdminRoutes(options),
+    };
+}
+export function buildSmartbillAdminRouteRuntime(bindings, options) {
+    return {
+        pluginOptions: typeof options.pluginOptions === "function"
+            ? options.pluginOptions(bindings)
+            : options.pluginOptions,
+    };
+}
+function resolveSmartbillAdminRouteRuntime(c, options) {
+    if (c.var.container) {
+        try {
+            return c.var.container.resolve(SMARTBILL_ADMIN_RUNTIME_CONTAINER_KEY);
+        }
+        catch {
+            // Fall through for tests and minimal apps that mount routes without bootstrap.
+        }
+    }
+    return buildSmartbillAdminRouteRuntime(c.env, options);
+}
+function resolveFinanceRouteRuntime(container) {
+    if (!container)
+        return undefined;
+    try {
+        const runtime = container.resolve(FINANCE_ROUTE_RUNTIME_CONTAINER_KEY);
+        return {
+            invoiceFxSettings: runtime.invoiceFxSettings,
+            resolveInvoiceFxSettings: runtime.resolveInvoiceFxSettings,
+            updateInvoiceFxSettings: runtime.updateInvoiceFxSettings,
+            resolveInvoiceExchangeRate: runtime.resolveInvoiceExchangeRate,
+            resolveInvoiceExchangeRateResolver: runtime.resolveInvoiceExchangeRateResolver,
+            onInvoiceFxResolutionError: runtime.onInvoiceFxResolutionError,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export type { RetrySmartbillInvoiceArtifactInput, SmartbillArtifactPersistenceOptions, SmartbillArtifactPersistenceResult, SmartbillArtifactPersistenceRuntime, SmartbillArtifactStorageContext, SmartbillDbResolver, SmartbillDocumentStorageResolver, SmartbillDocumentType, SmartbillExternalRef, SmartbillStorageKeyPrefixResolver, } from "./artifacts.js";
+export { retrySmartbillInvoiceArtifact } from "./artifacts.js";
+export type { SmartbillApiErrorOptions, SmartbillClientApi, SmartbillClientOptions, } from "./client.js";
+export { createSmartbillClient, SmartbillApiError, SmartbillRateLimitCircuitOpenError, SmartbillRateLimitError, } from "./client.js";
+export type { SmartbillAdminModuleOptions, SmartbillAdminRouteRuntime, SmartbillPluginOptionsResolver, } from "./hono.js";
+export { buildSmartbillAdminRouteRuntime, createSmartbillAdminModule, createSmartbillAdminRoutes, SMARTBILL_ADMIN_RUNTIME_CONTAINER_KEY, } from "./hono.js";
+export type { SmartbillEventValue, SmartbillMappingOptions, SmartbillMaybePromise, } from "./mapping.js";
+export { mapClient, mapLineItems, mapVoyantInvoiceToSmartbill, mapVoyantInvoiceToSmartbillAsync, } from "./mapping.js";
+export type { SmartbillMockDocument, SmartbillMockDocumentKind, SmartbillMockDocumentStatus, SmartbillMockListenOptions, SmartbillMockRequest, SmartbillMockResponse, SmartbillMockSeries, SmartbillMockServer, SmartbillMockServerHandle, SmartbillMockServerOptions, SmartbillMockTax, } from "./mock.js";
+export { createSmartbillMockServer } from "./mock.js";
+export type { SmartbillErrorHandler, SmartbillIdempotencyOptions, SmartbillInvoiceNumberWriteBackFormatter, SmartbillLogger, SmartbillMapFn, SmartbillPluginOptions, SmartbillSyncEventNames, } from "./plugin.js";
+export { smartbillPlugin } from "./plugin.js";
+export type { ResolvedSmartbillSyncEventNames, SmartbillSyncRuntime } from "./runtime.js";
+export { createSmartbillSyncRuntime } from "./runtime.js";
+export type { SmartbillInvoiceSettlementPoller, SmartbillInvoiceSettlementPollerOptions, SmartbillSettlementExternalRef, SmartbillSettlementInvoice, SmartbillSettlementPollerContext, SmartbillSettlementPollerResult, SmartbillSettlementSeriesContext, } from "./settlement.js";
+export { createSmartbillInvoiceSettlementPoller } from "./settlement.js";
+export type { SyncSmartbillInvoiceEventInput, SyncSmartbillInvoiceEventResult, SyncSmartbillInvoiceInput, SyncSmartbillInvoiceResult, } from "./sync.js";
+export { syncSmartbillInvoice, syncSmartbillInvoiceEvent } from "./sync.js";
+export type { SmartbillClient, SmartbillEnvelope, SmartbillEstimateInvoicesResponse, SmartbillFetch, SmartbillInvoiceBody, SmartbillInvoiceResponse, SmartbillPaymentEntry, SmartbillPdfResponse, SmartbillProduct, SmartbillSeriesResponse, SmartbillStatusResponse, SmartbillTaxesResponse, VoyantInvoiceEvent, } from "./types.js";
+export type { SmartbillCandidateExternalRefRecorder, SmartbillCandidateExternalRefRecorderContext, SmartbillCandidateInvoice, SmartbillDriftFinding, SmartbillDriftFindingType, SmartbillDriftReconciler, SmartbillDriftReconcilerOptions, SmartbillDriftReconcilerResult, SmartbillKnownLocalDriftFinding, SmartbillMissingLocalDriftFinding, SmartbillProformaConversion, SmartbillProformaConversionPoller, SmartbillProformaConversionPollerOptions, SmartbillProformaConversionPollerResult, SmartbillReferenceParts, SmartbillRemoteDocument, SmartbillRemoteDocumentAccessors, SmartbillRemoteDocumentStatus, SmartbillWorkflowCandidateSource, SmartbillWorkflowDocumentType, SmartbillWorkflowError, SmartbillWorkflowExternalRef, SmartbillWorkflowInvoice, SmartbillWorkflowLogger, } from "./workflows.js";
+export { createSmartbillDriftReconciler, createSmartbillProformaConversionPoller, } from "./workflows.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { retrySmartbillInvoiceArtifact } from "./artifacts.js";
+export { createSmartbillClient, SmartbillApiError, SmartbillRateLimitCircuitOpenError, SmartbillRateLimitError, } from "./client.js";
+export { buildSmartbillAdminRouteRuntime, createSmartbillAdminModule, createSmartbillAdminRoutes, SMARTBILL_ADMIN_RUNTIME_CONTAINER_KEY, } from "./hono.js";
+export { mapClient, mapLineItems, mapVoyantInvoiceToSmartbill, mapVoyantInvoiceToSmartbillAsync, } from "./mapping.js";
+export { createSmartbillMockServer } from "./mock.js";
+export { smartbillPlugin } from "./plugin.js";
+export { createSmartbillSyncRuntime } from "./runtime.js";
+export { createSmartbillInvoiceSettlementPoller } from "./settlement.js";
+export { syncSmartbillInvoice, syncSmartbillInvoiceEvent } from "./sync.js";
+export { createSmartbillDriftReconciler, createSmartbillProformaConversionPoller, } from "./workflows.js";

package/dist/invoice-ui-data.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const smartbillInvoiceExternalRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    invoiceId: z.ZodString;
+    provider: z.ZodString;
+    externalId: z.ZodNullable<z.ZodString>;
+    externalNumber: z.ZodNullable<z.ZodString>;
+    externalUrl: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    syncedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+    syncError: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+    updatedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+}, z.core.$strip>;
+export declare const smartbillInvoiceExternalRefsResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        invoiceId: z.ZodString;
+        provider: z.ZodString;
+        externalId: z.ZodNullable<z.ZodString>;
+        externalNumber: z.ZodNullable<z.ZodString>;
+        externalUrl: z.ZodNullable<z.ZodString>;
+        status: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        syncedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+        syncError: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+        updatedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SmartbillInvoiceExternalRef = z.infer<typeof smartbillInvoiceExternalRefSchema>;
+export interface SmartbillInvoiceReferenceParts {
+    companyVatCode: string | null;
+    seriesName: string | null;
+    number: string | null;
+    documentType: "invoice" | "proforma" | string | null;
+}
+export interface SmartbillInvoiceDocumentLink {
+    label: string;
+    href: string;
+}
+export declare function selectSmartbillInvoiceRef(refs: ReadonlyArray<SmartbillInvoiceExternalRef>): SmartbillInvoiceExternalRef | null;
+export declare function resolveSmartbillInvoiceReferenceParts(ref: SmartbillInvoiceExternalRef | null | undefined): SmartbillInvoiceReferenceParts;
+export declare function getSmartbillInvoiceDocumentLinks(ref: SmartbillInvoiceExternalRef | null | undefined): SmartbillInvoiceDocumentLink[];
+//# sourceMappingURL=invoice-ui-data.d.ts.map

package/dist/invoice-ui-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoice-ui-data.d.ts","sourceRoot":"","sources":["../src/invoice-ui-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;iBAa5C,CAAA;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;iBAErD,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAE3F,MAAM,WAAW,8BAA8B;IAC7C,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,YAAY,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CAAA;CACrD;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,aAAa,CAAC,2BAA2B,CAAC,GAC/C,2BAA2B,GAAG,IAAI,CAEpC;AAED,wBAAgB,qCAAqC,CACnD,GAAG,EAAE,2BAA2B,GAAG,IAAI,GAAG,SAAS,GAClD,8BAA8B,CAYhC;AAED,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,2BAA2B,GAAG,IAAI,GAAG,SAAS,GAClD,4BAA4B,EAAE,CAchC"}