@timbro/invoices 0.7.0-next.30

package/dist/webhook-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-event.d.ts","sourceRoot":"","sources":["../src/webhook-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAwB,CAAC;AAExD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAiC,CAAC;AAE1E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,iFAAiF;AACjF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAGtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAEhE;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,qBAAqB,CAIlF"}

package/dist/webhook-event.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { zReceptionWebhookEventEnvelope, zWebhookEventEnvelope } from "./generated/index.js";
+export const webhookEventSchema = zWebhookEventEnvelope;
+export const receptionWebhookEventSchema = zReceptionWebhookEventEnvelope;
+/** Every notification an endpoint is delivered, told apart by its event type. */
+export const deliveredWebhookEventSchema = z.union([
+    webhookEventSchema,
+    receptionWebhookEventSchema,
+]);
+export function parseWebhookEvent(payload) {
+    return webhookEventSchema.parse(typeof payload === "string" ? JSON.parse(payload) : payload);
+}
+export function parseDeliveredWebhookEvent(payload) {
+    return deliveredWebhookEventSchema.parse(typeof payload === "string" ? JSON.parse(payload) : payload);
+}

package/dist/webhook-registration.d.ts

@@ -0,0 +1,12 @@
+import { type WebhookEndpointRegistration as GeneratedWebhookEndpointRegistration } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+import { type ReadonlyCamelCase } from "./public-case.ts";
+export type WebhookRegistrationCommand = {
+    readonly url: string;
+    readonly idempotencyKey: string;
+    readonly description?: string;
+    readonly signal?: AbortSignal;
+};
+export type WebhookRegistration = ReadonlyCamelCase<GeneratedWebhookEndpointRegistration>;
+export declare function registerWebhookResource(client: Client, command: WebhookRegistrationCommand): Promise<WebhookRegistration>;
+//# sourceMappingURL=webhook-registration.d.ts.map

package/dist/webhook-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-registration.d.ts","sourceRoot":"","sources":["../src/webhook-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,IAAI,oCAAoC,EAEzE,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,kBAAkB,CAAC;AAExE,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,oCAAoC,CAAC,CAAC;AAE1F,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CAyC9B"}

package/dist/webhook-registration.js

@@ -0,0 +1,37 @@
+import { registerWebhookEndpoint, } from "./generated/index.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { toPublicCase } from "./public-case.js";
+export async function registerWebhookResource(client, command) {
+    if (!/^[A-Za-z0-9._:-]{16,255}$/u.test(command.idempotencyKey)) {
+        throw new TypeError("idempotencyKey must contain 16–255 letters, digits, dots, underscores, colons, or hyphens");
+    }
+    const destination = URL.parse(command.url);
+    if (destination === null ||
+        destination.protocol !== "https:" ||
+        destination.username !== "" ||
+        destination.password !== "" ||
+        destination.hash !== "" ||
+        /\s/u.test(command.url) ||
+        [...command.url].length > 2048) {
+        throw new TypeError("url must be an HTTPS callback without credentials, a fragment, or whitespace");
+    }
+    if (command.description !== undefined &&
+        (command.description.trim() !== command.description ||
+            command.description === "" ||
+            [...command.description].length > 200)) {
+        throw new TypeError("description must contain 1–200 characters without surrounding whitespace");
+    }
+    const response = await registerWebhookEndpoint({
+        client,
+        headers: { "Idempotency-Key": command.idempotencyKey },
+        body: {
+            url: command.url,
+            ...(command.description === undefined ? {} : { description: command.description }),
+        },
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200 && response.status !== 201) {
+        throwGeneratedProblem(response, "Webhook registration failed");
+    }
+    return toPublicCase(response.body);
+}

package/dist/webhook-replay.d.ts

@@ -0,0 +1,12 @@
+import { type WebhookReplayResource as GeneratedWebhookReplayResource } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+import { type ReadonlyCamelCase } from "./public-case.ts";
+export type WebhookReplayCommand = {
+    readonly webhookEndpointId: string;
+    readonly eventIds: readonly string[];
+    readonly idempotencyKey: string;
+    readonly signal?: AbortSignal;
+};
+export type WebhookReplay = ReadonlyCamelCase<GeneratedWebhookReplayResource>;
+export declare function replayWebhookResource(client: Client, command: WebhookReplayCommand): Promise<WebhookReplay>;
+//# sourceMappingURL=webhook-replay.d.ts.map

package/dist/webhook-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-replay.d.ts","sourceRoot":"","sources":["../src/webhook-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,IAAI,8BAA8B,EAI7D,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAG9D,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,kBAAkB,CAAC;AAExE,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,iBAAiB,CAAC,8BAA8B,CAAC,CAAC;AAE9E,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC,CA4BxB"}

package/dist/webhook-replay.js

@@ -0,0 +1,27 @@
+import { replayWebhookEvents, zRegisteredWebhookEndpoint, zReplayEventIdsScope, } from "./generated/index.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { isValidIdempotencyKey } from "./idempotency-key.js";
+import { toPublicCase } from "./public-case.js";
+export async function replayWebhookResource(client, command) {
+    if (!isValidIdempotencyKey(command.idempotencyKey)) {
+        throw new TypeError("idempotencyKey must contain 16–255 letters, digits, dots, underscores, colons, or hyphens");
+    }
+    const request = {
+        path: { webhook_endpoint_id: command.webhookEndpointId },
+        headers: { "Idempotency-Key": command.idempotencyKey },
+        body: { webhook_event_ids: [...command.eventIds] },
+    };
+    if (!(zRegisteredWebhookEndpoint.shape.id.safeParse(command.webhookEndpointId).success &&
+        zReplayEventIdsScope.safeParse(request.body).success)) {
+        throw new TypeError("webhookEndpointId must be a UUID; eventIds must contain 1–100 UUIDs");
+    }
+    const response = await replayWebhookEvents({
+        client,
+        ...request,
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200 && response.status !== 201) {
+        throwGeneratedProblem(response, "Webhook replay failed");
+    }
+    return toPublicCase(response.body);
+}

package/dist/webhook-verification.d.ts

@@ -0,0 +1,25 @@
+import { type DeliveredWebhookEvent } from "./webhook-event.ts";
+export type WebhookVerificationRejection = "invalid_secret" | "missing_header" | "malformed_header" | "stale_timestamp" | "future_timestamp" | "signature_mismatch" | "unreadable_envelope" | "id_mismatch";
+export type WebhookVerificationErrorDetail = ErrorOptions & {
+    readonly rejection: WebhookVerificationRejection;
+};
+export declare class WebhookVerificationError extends Error {
+    readonly rejection: WebhookVerificationRejection;
+    constructor(message: string, detail: WebhookVerificationErrorDetail);
+}
+export type WebhookDeliveryHeaders = Readonly<Record<string, string | readonly string[] | undefined>>;
+export type WebhookVerificationCommand = {
+    readonly body: string;
+    readonly headers: WebhookDeliveryHeaders;
+    readonly nowSeconds?: number | undefined;
+} & ({
+    readonly secret: string;
+} | {
+    readonly secrets: readonly string[];
+});
+/**
+ * Verifies a Standard Webhooks delivery over the exact bytes the receiver was sent.
+ * Re-serializing a parsed body before verifying changes those bytes and always rejects.
+ */
+export declare function verifyWebhookDelivery(command: WebhookVerificationCommand): Promise<DeliveredWebhookEvent>;
+//# sourceMappingURL=webhook-verification.d.ts.map

package/dist/webhook-verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-verification.d.ts","sourceRoot":"","sources":["../src/webhook-verification.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,qBAAqB,EAA8B,MAAM,oBAAoB,CAAC;AAE5F,MAAM,MAAM,4BAA4B,GACpC,gBAAgB,GAChB,gBAAgB,GAChB,kBAAkB,GAClB,iBAAiB,GACjB,kBAAkB,GAClB,oBAAoB,GACpB,qBAAqB,GACrB,aAAa,CAAC;AAElB,MAAM,MAAM,8BAA8B,GAAG,YAAY,GAAG;IAC1D,QAAQ,CAAC,SAAS,EAAE,4BAA4B,CAAC;CAClD,CAAC;AAEF,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,SAAS,EAAE,4BAA4B,CAAC;IAEjD,YAAY,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,8BAA8B,EAIlE;CACF;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC,CACvD,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C,GAAG,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AAE5E;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,qBAAqB,CAAC,CA6BhC"}

package/dist/webhook-verification.js

@@ -0,0 +1,53 @@
+import { StandardWebhookVerificationError, verifyStandardWebhookSignature } from "@timbro/protocol";
+import { parseDeliveredWebhookEvent } from "./webhook-event.js";
+export class WebhookVerificationError extends Error {
+    rejection;
+    constructor(message, detail) {
+        super(message, detail);
+        this.name = "WebhookVerificationError";
+        this.rejection = detail.rejection;
+    }
+}
+/**
+ * Verifies a Standard Webhooks delivery over the exact bytes the receiver was sent.
+ * Re-serializing a parsed body before verifying changes those bytes and always rejects.
+ */
+export async function verifyWebhookDelivery(command) {
+    const secrets = "secret" in command ? [command.secret] : command.secrets;
+    let webhookId;
+    try {
+        ({ webhookId } = await verifyStandardWebhookSignature({
+            body: new TextEncoder().encode(command.body),
+            headers: command.headers,
+            secrets,
+            nowSeconds: command.nowSeconds,
+        }));
+    }
+    catch (cause) {
+        if (cause instanceof StandardWebhookVerificationError) {
+            throw new WebhookVerificationError(cause.message, {
+                rejection: cause.rejection,
+                cause,
+            });
+        }
+        throw cause;
+    }
+    const event = readEnvelope(command.body);
+    if (event.id !== webhookId) {
+        throw new WebhookVerificationError("webhook-id does not carry the envelope id", {
+            rejection: "id_mismatch",
+        });
+    }
+    return event;
+}
+function readEnvelope(body) {
+    try {
+        return parseDeliveredWebhookEvent(body);
+    }
+    catch (cause) {
+        throw new WebhookVerificationError("the signed body is not a Timbro webhook event", {
+            rejection: "unreadable_envelope",
+            cause,
+        });
+    }
+}

package/dist/workspace-session-transport.d.ts

@@ -0,0 +1,8 @@
+import type { TimbroTransport } from "./transport-contract.ts";
+export type WorkspaceSessionTransportOptions = {
+    readonly stampServerOrigin: string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly maxBinaryResponseBytes?: number;
+};
+export declare function createWorkspaceSessionTransport(options: WorkspaceSessionTransportOptions): TimbroTransport;
+//# sourceMappingURL=workspace-session-transport.d.ts.map

package/dist/workspace-session-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-session-transport.d.ts","sourceRoot":"","sources":["../src/workspace-session-transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,MAAM,MAAM,gCAAgC,GAAG;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACzC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAC1C,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,eAAe,CASjB"}

package/dist/workspace-session-transport.js

@@ -0,0 +1,11 @@
+import { createStampServerHttpTransport } from "./stamp-server-http-transport.js";
+export function createWorkspaceSessionTransport(options) {
+    return createStampServerHttpTransport({
+        stampServerOrigin: options.stampServerOrigin,
+        authentication: { mode: "workspace_session" },
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+        ...(options.maxBinaryResponseBytes === undefined
+            ? {}
+            : { maxBinaryResponseBytes: options.maxBinaryResponseBytes }),
+    });
+}

package/dist/workspace.d.ts

@@ -0,0 +1,74 @@
+import { type DirectConnectionWorkspaceOperations } from "./direct-connection.ts";
+import { type ElectronicFiscalDocumentType, type FiscalArtifactKind, type PrintedRepresentationA4ProfileVersion, type PrintedRepresentationProfile, type PrintedRepresentationReceiptProfileVersion, type WorkspaceFiscalOperationPage, type WorkspaceFiscalOperationResource } from "./generated/index.ts";
+/** Workspace artifact safety ceiling; larger artifacts are rejected before buffering. */
+export declare const WORKSPACE_ARTIFACT_MAX_BYTES: number;
+/** Options for a Workspace client. The default is the current browser origin. */
+export type WorkspaceClientOptions = {
+    /** An explicit Timbro origin for dedicated deployments and tests. */
+    readonly baseUrl?: string;
+    /** A fetch implementation for tests or a dedicated runtime. */
+    readonly fetch?: typeof globalThis.fetch;
+};
+export type WorkspaceFiscalOperationListCommand = {
+    readonly organizationId: string;
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+    /** Maximum number of pages read by listAll; list ignores this traversal-only option. */
+    readonly maxPages?: number;
+};
+export type WorkspaceFiscalOperationIdentity = {
+    readonly organizationId: string;
+    readonly fiscalOperationId: string;
+};
+export type WorkspaceFiscalOperationCommand = WorkspaceFiscalOperationIdentity & {
+    /** Cursor and limit page the operation's timeline. */
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+};
+export type WorkspaceFiscalArtifactCommand = WorkspaceFiscalOperationIdentity & {
+    readonly kind: FiscalArtifactKind;
+    readonly signal?: AbortSignal;
+};
+/** Verified bytes and identity metadata returned by a Workspace artifact retrieval. */
+export type WorkspaceFiscalArtifact = {
+    readonly artifactId: string;
+    readonly artifactKind: FiscalArtifactKind;
+    readonly bytes: Uint8Array;
+    readonly byteLength: number;
+    readonly contentSha256: string;
+    readonly contentDisposition: string;
+    readonly cacheControl: string;
+    readonly createdAt: string;
+    readonly fiscalOperationId: string;
+    readonly mediaType: "application/pdf" | "application/xml";
+    readonly signedSourceSha256?: string;
+    readonly printedRepresentation?: {
+        readonly fiscalDocumentType: ElectronicFiscalDocumentType;
+        readonly fiscalNumber: string;
+        readonly paginationPlanSha256: string;
+        readonly profile: PrintedRepresentationProfile;
+        readonly profileVersion: PrintedRepresentationA4ProfileVersion | PrintedRepresentationReceiptProfileVersion;
+        readonly rendererIdentity: string;
+        readonly pageCount: number;
+    };
+};
+export type WorkspaceFiscalOperations = {
+    readonly list: (command: WorkspaceFiscalOperationListCommand) => Promise<WorkspaceFiscalOperationPage>;
+    readonly listAll: (command: WorkspaceFiscalOperationListCommand) => AsyncIterable<WorkspaceFiscalOperationPage["data"][number]>;
+    readonly get: (command: WorkspaceFiscalOperationCommand) => Promise<WorkspaceFiscalOperationResource>;
+    readonly artifacts: {
+        readonly retrieve: (command: WorkspaceFiscalArtifactCommand) => Promise<WorkspaceFiscalArtifact>;
+    };
+};
+export type WorkspaceClient = {
+    readonly fiscalOperations: WorkspaceFiscalOperations;
+    readonly directConnections: DirectConnectionWorkspaceOperations;
+};
+/**
+ * Creates a Workspace client authenticated by the browser's same-origin session cookie.
+ * Importing this module does not load the document evaluator or any Wasm asset.
+ */
+export declare function createWorkspaceClient(options?: WorkspaceClientOptions): WorkspaceClient;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/workspace.d.ts.map

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

package/dist/workspace.js

@@ -0,0 +1,278 @@
+// biome-ignore-all lint/correctness/useQwikValidLexicalScope: this module is a plain SDK client, not a Qwik component.
+import { walkCollectionPages } from "./collection.js";
+import { createDirectConnectionWorkspaceOperations, } from "./direct-connection.js";
+import { FiscalError } from "./fiscal-error.js";
+import { listOrganizationFiscalOperations, readOrganizationFiscalOperation, retrieveWorkspaceFiscalArtifact, zElectronicFiscalDocumentType, } from "./generated/index.js";
+import { createGeneratedOperationClient } from "./generated-operation-client.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { isCanonicalRfc3339MillisecondUtc } from "./printed-representation.js";
+import { digestSha256Hex } from "./sha256.js";
+import { createWorkspaceSessionTransport } from "./workspace-session-transport.js";
+const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const FISCAL_NUMBER_PATTERN = /^E(?:31|32|33|34|41|43|44|45|46|47)[0-9]{10}$/;
+const POSITIVE_INTEGER_PATTERN = /^[0-9]+$/;
+const MAX_SAFE_INT = Number.MAX_SAFE_INTEGER;
+/** Workspace artifact safety ceiling; larger artifacts are rejected before buffering. */
+export const WORKSPACE_ARTIFACT_MAX_BYTES = 16 * 1024 * 1024;
+/**
+ * Creates a Workspace client authenticated by the browser's same-origin session cookie.
+ * Importing this module does not load the document evaluator or any Wasm asset.
+ */
+export function createWorkspaceClient(options = {}) {
+    const baseUrl = options.baseUrl ?? readBrowserOrigin();
+    if (baseUrl === undefined) {
+        throw new TypeError("a Workspace client needs a browser origin or an explicit baseUrl");
+    }
+    const client = createGeneratedOperationClient(createWorkspaceSessionTransport({
+        stampServerOrigin: baseUrl,
+        maxBinaryResponseBytes: WORKSPACE_ARTIFACT_MAX_BYTES,
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+    }));
+    return createWorkspaceClientFromGeneratedClient(client);
+}
+function createWorkspaceClientFromGeneratedClient(client) {
+    const list = (command) => readWorkspaceFiscalOperationPage(client, command);
+    return {
+        fiscalOperations: {
+            list,
+            listAll: (command) => walkCollectionPages((cursor, signal) => list({
+                ...command,
+                ...(cursor === undefined ? {} : { cursor }),
+                ...(signal === undefined ? {} : { signal }),
+            }), {
+                ...(command.maxPages === undefined ? {} : { maxPages: command.maxPages }),
+                ...(command.signal === undefined ? {} : { signal: command.signal }),
+            }),
+            get: (command) => readWorkspaceFiscalOperation(client, command),
+            artifacts: {
+                retrieve: (command) => readWorkspaceFiscalArtifact(client, command),
+            },
+        },
+        directConnections: createDirectConnectionWorkspaceOperations(client),
+    };
+}
+async function readWorkspaceFiscalOperationPage(client, command) {
+    validateIdentity(command.organizationId, "organizationId");
+    const response = await listOrganizationFiscalOperations({
+        client,
+        path: { organization_id: command.organizationId },
+        ...workspacePaginationQuery(command),
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Workspace Fiscal operation listing failed");
+    }
+    return response.body;
+}
+async function readWorkspaceFiscalOperation(client, command) {
+    validateIdentity(command.organizationId, "organizationId");
+    validateIdentity(command.fiscalOperationId, "fiscalOperationId");
+    const response = await readOrganizationFiscalOperation({
+        client,
+        path: {
+            organization_id: command.organizationId,
+            fiscal_operation_id: command.fiscalOperationId,
+        },
+        ...workspacePaginationQuery(command),
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Workspace Fiscal operation lookup failed");
+    }
+    return response.body;
+}
+function workspacePaginationQuery(command) {
+    return command.cursor === undefined && command.limit === undefined
+        ? {}
+        : {
+            query: {
+                ...(command.cursor === undefined ? {} : { cursor: command.cursor }),
+                ...(command.limit === undefined ? {} : { limit: command.limit }),
+            },
+        };
+}
+async function readWorkspaceFiscalArtifact(client, command) {
+    validateIdentity(command.organizationId, "organizationId");
+    validateIdentity(command.fiscalOperationId, "fiscalOperationId");
+    const response = await retrieveWorkspaceFiscalArtifact({
+        client,
+        path: {
+            organization_id: command.organizationId,
+            fiscal_operation_id: command.fiscalOperationId,
+            artifact_kind: command.kind,
+        },
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Workspace Fiscal artifact retrieval failed");
+    }
+    return verifyWorkspaceFiscalArtifact(response.body, response.headers, command);
+}
+async function verifyWorkspaceFiscalArtifact(body, headers, command) {
+    if (!(body instanceof Uint8Array)) {
+        throwArtifactFailure("Timbro returned a non-binary Workspace Fiscal artifact");
+    }
+    const contentSha256 = requiredDigestHeader(headers, "timbro-artifact-sha256");
+    if ((await digestSha256Hex(body)) !== contentSha256) {
+        throwArtifactFailure("the Workspace Fiscal artifact bytes do not match their SHA-256");
+    }
+    const byteLength = body.byteLength;
+    const artifactId = requiredUuidHeader(headers, "timbro-artifact-id");
+    const fiscalOperationId = requiredUuidHeader(headers, "timbro-fiscal-operation-id");
+    if (fiscalOperationId.toLowerCase() !== command.fiscalOperationId.toLowerCase()) {
+        throwArtifactFailure("the Workspace Fiscal artifact belongs to another Fiscal operation");
+    }
+    const mediaType = requiredHeader(headers, "content-type");
+    if (mediaType !== expectedMediaType(command.kind)) {
+        throwArtifactFailure("Timbro returned an unexpected Workspace Fiscal artifact media type");
+    }
+    const contentDisposition = requiredHeader(headers, "content-disposition");
+    const cacheControl = requiredHeader(headers, "cache-control");
+    if (cacheControl !== "private, no-store, no-transform") {
+        throwArtifactFailure("Timbro returned an unexpected Workspace Fiscal artifact cache policy");
+    }
+    const createdAt = requiredHeader(headers, "timbro-artifact-created-at");
+    if (!isCanonicalRfc3339MillisecondUtc(createdAt)) {
+        throwArtifactFailure("Timbro returned an invalid Workspace Fiscal artifact creation time");
+    }
+    const signedSourceSha256 = optionalDigestHeader(headers, "timbro-signed-source-sha256");
+    const printedRepresentation = command.kind === "printed_representation"
+        ? readPrintedRepresentationHeaders(headers, signedSourceSha256, contentSha256)
+        : undefined;
+    return {
+        artifactId,
+        artifactKind: command.kind,
+        bytes: body,
+        byteLength,
+        contentSha256,
+        contentDisposition,
+        cacheControl,
+        createdAt,
+        fiscalOperationId,
+        mediaType,
+        ...(signedSourceSha256 === undefined ? {} : { signedSourceSha256 }),
+        ...(printedRepresentation === undefined ? {} : { printedRepresentation }),
+    };
+}
+function expectedMediaType(kind) {
+    return kind === "printed_representation" ? "application/pdf" : "application/xml";
+}
+function readPrintedRepresentationHeaders(headers, signedSourceSha256, contentSha256) {
+    if (signedSourceSha256 === undefined) {
+        throwArtifactFailure("Timbro omitted required printed-representation source digest");
+    }
+    const fiscalDocumentType = requiredDocumentTypeHeader(headers);
+    const fiscalNumber = requiredHeader(headers, "timbro-fiscal-number");
+    if (!FISCAL_NUMBER_PATTERN.test(fiscalNumber)) {
+        throwArtifactFailure("Timbro returned an invalid fiscal number header");
+    }
+    if (fiscalNumber.slice(1, 3) !== fiscalDocumentType) {
+        throwArtifactFailure("Timbro returned a fiscal number for another document type");
+    }
+    if (requiredDigestHeader(headers, "timbro-pdf-sha256") !== contentSha256) {
+        throwArtifactFailure("Timbro returned mismatched artifact and PDF digests");
+    }
+    const rendererIdentity = requiredHeader(headers, "timbro-renderer-identity");
+    if (rendererIdentity.length > 200 || rendererIdentity !== rendererIdentity.trim()) {
+        throwArtifactFailure("Timbro returned an invalid renderer identity header");
+    }
+    const pageCount = requiredPositiveIntegerHeader(headers, "timbro-page-count");
+    if (pageCount > 100) {
+        throwArtifactFailure("Timbro returned a page count above the supported bound");
+    }
+    return {
+        fiscalDocumentType,
+        fiscalNumber,
+        paginationPlanSha256: requiredDigestHeader(headers, "timbro-pagination-plan-sha256"),
+        profile: requiredProfileHeader(headers),
+        profileVersion: requiredProfileVersionHeader(headers),
+        rendererIdentity,
+        pageCount,
+    };
+}
+function requiredDocumentTypeHeader(headers) {
+    const parsed = zElectronicFiscalDocumentType.safeParse(requiredHeader(headers, "timbro-fiscal-document-type"));
+    if (!parsed.success) {
+        throwArtifactFailure("Timbro returned an unsupported fiscal document type header");
+    }
+    return parsed.data;
+}
+function requiredProfileHeader(headers) {
+    const profile = requiredHeader(headers, "timbro-printed-representation-profile");
+    if (profile !== "a4" && profile !== "receipt_80mm") {
+        throwArtifactFailure("Timbro returned an unsupported printed representation profile");
+    }
+    return profile;
+}
+function requiredProfileVersionHeader(headers) {
+    const profile = requiredProfileHeader(headers);
+    const version = requiredHeader(headers, "timbro-printed-representation-profile-version");
+    if ((profile === "a4" && version === "a4.v1") ||
+        (profile === "receipt_80mm" && version === "receipt_80mm.v1")) {
+        return version;
+    }
+    throwArtifactFailure("Timbro returned a profile version that does not match its profile");
+}
+function requiredHeader(headers, name) {
+    const value = headerValue(headers, name);
+    if (value === undefined || value.trim() === "") {
+        throwArtifactFailure(`Timbro omitted required artifact header ${name}`);
+    }
+    return value;
+}
+function requiredDigestHeader(headers, name) {
+    const digest = requiredHeader(headers, name);
+    if (!SHA256_PATTERN.test(digest)) {
+        throwArtifactFailure(`Timbro returned an invalid digest header ${name}`);
+    }
+    return digest;
+}
+function optionalDigestHeader(headers, name) {
+    const value = headerValue(headers, name);
+    if (value === undefined) {
+        return;
+    }
+    if (!SHA256_PATTERN.test(value)) {
+        throwArtifactFailure(`Timbro returned an invalid digest header ${name}`);
+    }
+    return value;
+}
+function requiredUuidHeader(headers, name) {
+    const identity = requiredHeader(headers, name);
+    if (!UUID_PATTERN.test(identity)) {
+        throwArtifactFailure(`Timbro returned an invalid UUID header ${name}`);
+    }
+    return identity;
+}
+function requiredPositiveIntegerHeader(headers, name) {
+    const raw = requiredHeader(headers, name);
+    if (!POSITIVE_INTEGER_PATTERN.test(raw)) {
+        throwArtifactFailure(`Timbro returned a non-integer header ${name}`);
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_SAFE_INT) {
+        throwArtifactFailure(`Timbro returned an out-of-range header ${name}`);
+    }
+    return value;
+}
+function headerValue(headers, name) {
+    const direct = headers.get(name);
+    if (direct !== undefined) {
+        return direct;
+    }
+    const lowerName = name.toLowerCase();
+    return Array.from(headers).find(([headerName]) => headerName.toLowerCase() === lowerName)?.[1];
+}
+function validateIdentity(identity, name) {
+    if (identity.trim() === "") {
+        throw new TypeError(`${name} must not be blank`);
+    }
+}
+function readBrowserOrigin() {
+    const browserGlobal = globalThis;
+    return typeof browserGlobal.location === "object" ? browserGlobal.location.origin : undefined;
+}
+function throwArtifactFailure(message) {
+    throw new FiscalError(message, { failure: "server_processing" });
+}