@timbro/invoices 0.7.0-next.30

package/README.md

@@ -0,0 +1,308 @@
+# @timbro/invoices
+
+Issue Dominican electronic invoices (e-CF) from your application, ERP, or POS with one configured client. Invoice issuance and payment collection have separate lifecycles. Use `@timbro/payments` when you also need Timbro to collect money through Checkout.
+
+Rust owns the fiscal wire contract. This SDK uses generated operation bindings and validators at every HTTP boundary.
+
+```ts
+import { createTimbroClient } from "@timbro/invoices";
+import type { FiscalDocument } from "@timbro/invoices";
+
+const credential = process.env.TIMBRO_CREDENTIAL;
+if (credential === undefined || credential.trim() === "") {
+  throw new Error("TIMBRO_CREDENTIAL is required");
+}
+
+const document: FiscalDocument = {
+  kind: "type31",
+  snapshot: {
+    currency: "DOP",
+    incomeType: "01",
+    paymentType: "1",
+    buyer: { taxId: "101234567", legalName: "Example Buyer" },
+    lines: [{
+      sourceLineId: "line-1",
+      name: "Example product",
+      quantity: "1.00",
+      measurementUnit: "31",
+      unitPrice: "118.00",
+      billingIndicator: "1",
+      goodsOrServiceIndicator: "1",
+    }],
+    paymentAllocations: [{ method: "1", amount: "118.00" }],
+  },
+};
+
+const timbro = createTimbroClient({
+  baseUrl: "https://stamp.example.test",
+  authentication: { mode: "source_connection", credential },
+});
+
+const operation = await timbro.fiscalDocuments.issue({
+  source: {
+    id: "checkout-order-1001",
+    version: "v1",
+  },
+  document,
+  numberingInstruction: { kind: "centralAssignment" },
+  printedRepresentation: { profile: "receipt_80mm" },
+});
+
+const page = await timbro.fiscalDocuments.list({ limit: 20 });
+
+const numbering = await timbro.fiscalNumbering.getReadiness();
+const type31 = numbering.documents.e31;
+const custody = await timbro.certificateCustody.getReadiness();
+```
+
+The repository includes complete, runnable issuance examples for both supported integration styles:
+
+- [`examples/fiscal-document.ts`](examples/fiscal-document.ts) uses the typed SDK
+- [`examples/fiscal_document.py`](examples/fiscal_document.py) uses Python's standard-library HTTP client and the raw snake-case wire contract
+
+Set `TIMBRO_BASE_URL`, `TIMBRO_CREDENTIAL`, and a unique `TIMBRO_SOURCE_ID` before running either
+example. `TIMBRO_SOURCE_VERSION` defaults to `v1`. Run the TypeScript example with
+`node packages/sdk/examples/fiscal-document.ts` on the repository's Node 24 runtime, or run the
+Python example with `python3 packages/sdk/examples/fiscal_document.py`. Use a Source connection in
+the intended fiscal environment because either command submits an issuance task.
+
+The immutable Source identity is the `{ id, version }` tuple; `version` is an opaque trimmed string chosen by the Source system. Timbro computes and retains the canonical digest internally. The caller does not send a digest or an idempotency header. Repeating an older tuple recovers its original operation even after another version becomes current.
+
+To replace a request rejected before numbering, submit corrected content with a new Source version and `predecessorOperationId` set to the rejected operation's `fiscalOperationId`. The predecessor must still be current. An accepted document requires a separate legal correction; an unknown outcome requires reconciliation. After authority rejection, replacement also requires the existing administrator authorization. A missing or stale predecessor returns `source_predecessor_conflict` without issuing again.
+
+Inspect `operation.outcome.outcome`, `operation.signedDocument.status` and `operation.printedRepresentation.status` independently. Authority acceptance can precede XML/PDF availability. The SDK preserves these owning-contract facts and exposes no derived top-level `status` or `issued` shortcut. Both immediate and pending admission responses return the resource. [Spanish retry and recovery guide](../../docs/integrations/source-submission-recovery.md)
+
+`fiscalDocuments.issue` is the one issuance task for ordinary documents and corrections. A
+correction names both the affected Timbro operation and the original Source identity explicitly:
+
+```ts
+await timbro.fiscalDocuments.issue({
+  source: { id: "odoo-credit-1002", version: "v1" },
+  action: {
+    kind: "creditNote",
+    correction: "correctAmounts",
+    affectedFiscalOperationId: original.fiscalOperationId,
+    originalSource: { id: "odoo-invoice-1001", version: "v3" },
+    reason: "The taxable amount was corrected",
+  },
+  document,
+  numberingInstruction: { kind: "centralAssignment" },
+  printedRepresentation: { profile: "a4" },
+});
+```
+
+All issuance task boundaries return a retained operation when fiscal evaluation rejects it; inspect `operation.outcome` and its diagnostics just as you would after `get` or a webhook. Exceptions remain reserved for malformed or unsupported input, authentication and authorization failures, conflicts, transport failures, and other cases where no modeled result can be returned.
+
+`fiscalDocuments.get({ fiscalOperationId })` recovers an operation and its actor-facing outcome, returning `undefined` for a typed not-found response. `fiscalDocuments.findBySource({ source: { id, version } })` arbitrates by the caller's source identity. Public resources use camelCase, keep every amount as an exact decimal string, and expose `fiscalOperationId` separately from the fiscal authority identity (`outcome.fiscalIdentity`) and its fiscal number. The status vocabulary preserves `requested`, `processing`, `delayed`, `unavailable`, `verifying`, `issued`, `rejected`, and `actionRequired`. Fiscal numbering and certificate-custody readiness are separate tasks from issuance, and artifact retrieval is exposed through `fiscalArtifacts`.
+
+`fiscalDocuments.getTiming({ fiscalOperationId })` returns the bounded diagnostic projection of timing contract version 4. `stages` names each step of the operation as a `TimingStageId` occurrence with its clock, bound, duration, and exclusive time; `TIMING_STAGE_IDS` lists every published id. `workClaims` lists each executing claim on the operation's work, `drainRuns` the drains that made those claims, and `readAt` is Timbro's database clock at the read, so a reader on another clock can measure its skew. These fields are optional in the types: a version 3 report still parses and carries none of them, so branch on `timingContractVersion`. The row lists name work `dueToSettlementMs` and Webhook `queuedToSettlementMs` by their endpoints, and expose `fiscalDeliveries`, `fiscalDeliveryAttempts`, and `fiscalDeliveryEvents` so `submitted`, `delivered`, and `bounced` remain distinct. `attemptDurationMs` measures the stamp-side interval from delivery claim through recorded settlement, including local preparation; it does not isolate provider time. Event rows correlate through `fiscalDeliveryId`, and their provider-created and stamp-received times remain separate. The report omits recipient addresses and provider identifiers.
+
+When `operation.signedDocument.status` is `ready`, its `artifactKind` is `signed_complete_document` and its `artifactId` identifies the immutable artifact. Retrieve and verify it with `fiscalArtifacts.downloadSignedDocument({ fiscalOperationId: operation.fiscalOperationId })`.
+
+An `outcome_unknown` submission remains `pending` while Timbro reconciles the same fiscal identity with DGII. Continue observing it without resubmitting the document. Only `intervention_required` means automatic reconciliation exhausted its bounded budget and an operator must take over.
+
+`fiscalArtifacts.downloadPrintedRepresentation({ fiscalOperationId })` retrieves the operation-addressed immutable PDF and verifies every published identity header, profile/version, renderer identity, digest, signed-source digest, pagination-plan digest, length, page count, creation time, media type, and the actual bytes. The result exposes one content digest as `contentSha256`; storage keys and compatibility aliases are not exposed.
+
+### Share an already-issued receipt
+
+The development contract in `0.7.0-next.30` lets the issuing Source share an accepted operation without issuing another invoice or sending email. Registry availability is a separate release requirement. Keep the returned reference in protected server-side storage and pass it through an authenticated service handoff:
+
+```ts
+const receipt = await issuer.fiscalDocuments.shareReceipt({ fiscalOperationId });
+const metadata = await receiver.fiscalReceipts.get({ receipt });
+if (metadata?.printedRepresentation.status === "ready") {
+  const pdf = await receiver.fiscalReceipts.downloadPrintedRepresentation({ receipt });
+  // Deliver pdf.bytes through the receiving service's authorized receipt route.
+}
+```
+
+Both clients use the existing `createTimbroClient` setup. Receipt reads apply only the reference's bearer token, even if the receiving client normally uses workload authentication. The receiver obtains the verified issuer RNC, environment, Source revision, fiscal identity, DOP totals, acceptance timestamp, and PDF readiness. It receives neither XML nor diagnostics. A missing or revoked receipt returns `undefined`; a pending PDF returns `fiscal_artifact_not_found`. Use the [Spanish receipt guide](../../docs/integrations/source-receipts.md) for handoff and payment checks.
+
+Source credentials can also operate the received-document namespace. The server infers the
+Organization, Legal issuer, and Fiscal environment from that credential, so the list cannot be
+widened with a tenant or issuer path parameter:
+
+```ts
+const received = await timbro.receivedDocuments.list({ limit: 50, recovery: "pending" });
+const document = await timbro.receivedDocuments.get({
+  fiscalReceptionId: received.data[0].fiscalReceptionId,
+});
+await timbro.receivedDocuments.respond({
+  fiscalReceptionId: document.summary.fiscalReceptionId,
+  response: { decision: "accepted" },
+});
+const signedXml = await timbro.receivedDocuments.downloadSignedDocument({
+  fiscalReceptionId: document.summary.fiscalReceptionId,
+});
+```
+
+`receivedDocuments.respond` accepts `accepted` or `rejected` with a non-blank `motive` for a
+rejected response; an exact
+replay returns the recorded response and a changed decision or motive raises a conflict. The
+downloaded XML is retained inbound evidence and the SDK verifies its media type, length, and
+SHA-256 digest. If the Evidence Vault is unavailable, the download returns the typed
+`fiscal_artifact_unavailable` problem with HTTP 503.
+
+Buyer delivery is independent of representation readiness:
+
+```ts
+const delivery = await timbro.fiscalDeliveries.create({
+  fiscalOperationId: operation.fiscalOperationId,
+  recipientEmail: "buyer@example.test",
+  accountClaimUrl: "https://checkout.example.test/account?receipt=order-1001",
+  idempotencyKey: "checkout-order-1001-email",
+});
+```
+
+The email is in Spanish and names the Legal issuer and the e-NCF. `accountClaimUrl` is optional;
+when present, the email also offers "Guardar en Cuenta Timbro" with that `https` URL. The URL
+grants nothing by itself, because delivery emails are often forwarded.
+
+### Webhooks and recovery
+
+An approved direct Source registers its HTTPS callback with the same scoped credential:
+
+```ts
+const registration = await timbro.webhooks.register({
+  url: "https://erp.example.com/timbro/webhook",
+  idempotencyKey: "odoo-company-42-callback-v1",
+});
+```
+
+Persist that key before setup, and store `registration.signingSecret` in your server's secret
+store. The exact key and body recover the same endpoint and original secret for 24 hours while
+the endpoint remains active and unrotated. Later retries return the endpoint with a null secret;
+they never issue another secret. A different registration key or changed body returns a conflict.
+Hosted and provider-managed callbacks retain their own setup lifecycle.
+
+The complete `node packages/sdk/examples/register-webhook.ts` example reads `TIMBRO_BASE_URL`,
+`TIMBRO_CREDENTIAL`, `TIMBRO_CALLBACK_URL`, `TIMBRO_CALLBACK_REGISTRATION_KEY`, and
+`TIMBRO_WEBHOOK_SECRET_FILE`. It saves the secret in a private file and prints only endpoint
+metadata. See [Recibe avisos del e-CF](../../docs/integrations/source-webhooks.md) for setup and recovery.
+
+After a receiver outage, inspect `webhookDeliveries.list` for pending or dead-letter deliveries
+and replay selected retained fiscal events:
+
+```ts
+const replay = await timbro.webhooks.replay({
+  webhookEndpointId: registration.webhookEndpoint.id,
+  eventIds: [delivery.webhook_event_id],
+  idempotencyKey: "odoo-company-42-replay-20261001",
+});
+```
+
+Persist the key and selection first. An exact retry returns the same `webhookReplayId` without
+creating another delivery. Replay preserves the original event ID, sequence, and payload;
+deduplicate it alongside automatic retries. Select 1–100 outbound fiscal events from your Source.
+Supplier reception events are outside this method's scope.
+
+The complete `node packages/sdk/examples/replay-webhook.ts` example reads `TIMBRO_BASE_URL`,
+`TIMBRO_CREDENTIAL`, `TIMBRO_WEBHOOK_ENDPOINT_ID`, comma-separated `TIMBRO_WEBHOOK_EVENT_IDS`,
+and `TIMBRO_WEBHOOK_REPLAY_KEY`. It prints replay metadata only.
+
+Deliveries follow the [Standard Webhooks](https://www.standardwebhooks.com) contract. Each request
+carries `webhook-id`, `webhook-timestamp`, and `webhook-signature`, and the signature covers
+`<webhook-id>.<webhook-timestamp>.<body>`. Verify it against the exact request body bytes before
+parsing. Do not parse, reserialize, or pretty-print the body first; the signed payload is the
+original UTF-8 text.
+
+`webhooks.verify` checks the headers and returns the typed event, so a receiver never parses an
+unverified body:
+
+```ts
+const event = await timbro.webhooks.verify({
+  body: requestBodyText,
+  headers: Object.fromEntries(request.headers),
+  secret: webhookSecret,
+});
+if (event.type === "source_connection.verification_requested") {
+  // Build and submit the signed activation proof before acknowledging this event.
+  // See examples/webhook-receiver.ts for the complete server-runtime flow.
+  throw new Error("activation verification must complete before acknowledgement");
+}
+const recovered =
+  event.type === "fiscal_reception.received" || event.type === "fiscal_reception.not_received"
+    ? undefined
+    : await timbro.fiscalDocuments.get({ fiscalOperationId: event.data.fiscal_operation_id });
+```
+
+The operation's `source.id` and `source.version` identify the caller's retained invoice even if
+the callback arrives before the caller records the issuance response. Retrieve current state
+under the same Source credential, then apply it to that invoice through your existing processor.
+
+A rejected delivery throws `WebhookVerificationError`, whose `rejection` names the cause:
+`invalid_secret`, `missing_header`, `malformed_header`, `stale_timestamp`, `future_timestamp`,
+`signature_mismatch`, `unreadable_envelope`, or `id_mismatch`. Answer a delivery you cannot trust
+with a 4xx and no side effect. `invalid_secret` is the one exception: the secret you configured is
+unusable, the delivery itself is intact, so answer 500 and let Timbro retry the event while you
+repair the secret.
+
+```ts
+import { WebhookVerificationError } from "@timbro/invoices";
+
+try {
+  await timbro.webhooks.verify({ body, headers, secrets: [nextSecret, retiredSecret] });
+} catch (cause) {
+  if (cause instanceof WebhookVerificationError) {
+    return new Response(cause.rejection, {
+      status: cause.rejection === "invalid_secret" ? 500 : 400,
+    });
+  }
+  throw cause;
+}
+```
+
+The signing secret is issued as `whsec_<base64>`; the HMAC key is the base64-decoded remainder, and
+a secret that is not that shape is rejected rather than used as literal bytes. `webhook-signature`
+carries one space-separated `v1,` entry per valid secret, and a delivery is verified when any entry
+matches any secret you hold. A timestamp more than five minutes from the receiver's clock is refused
+in both directions. `verify` refuses a delivery whose `webhook-id` is not the envelope `id`, and
+that id is the key you deduplicate on. `sequence` stays a decimal string so JavaScript cannot lose
+bigint precision. If an operation-event delivery is missed, recover the current actor-facing outcome
+with `fiscalDocuments.get` using its operation ID.
+
+Every public list returns one page: `object: list`, `data`, `hasMore`, and an opaque `nextCursor`
+bound to the Organization and the list that minted it, down to the Webhook endpoint for a
+delivery cursor.
+Presenting a cursor anywhere else answers 400 `invalid_collection_cursor`. `limit` accepts 1 to
+100 and defaults to 20, and a multi-value filter repeats its parameter. `list` returns a single
+page, while `listAll` follows every cursor for you:
+
+```ts
+const page = await timbro.webhookDeliveries.list({
+  webhookEndpointId,
+  states: ["pending", "dead_lettered"],
+  limit: 50,
+});
+
+for await (const delivery of timbro.webhookDeliveries.listAll({ webhookEndpointId })) {
+  await reconcile(delivery);
+}
+```
+
+`webhookDeliveries`, `fiscalDocuments`, and `receivedDocuments` are the credential-scoped lists this
+client wraps. The operation timeline is read with a Workspace session instead of a credential,
+so a Workspace consumer reads those pages through its own session-authenticated request and walks
+them with the exported `walkCollectionPages`:
+
+```ts
+import { walkCollectionPages } from "@timbro/invoices";
+import { zWorkspaceFiscalOperationPage } from "@timbro/invoices/generated";
+
+for await (const operation of walkCollectionPages(async (cursor) => {
+  const query = cursor === undefined ? "?limit=100" : `?limit=100&cursor=${cursor}`;
+  const response = await fetch(
+    `${stampServerOrigin}/v1/organizations/${organizationId}/fiscal-operations${query}`,
+    { credentials: "include" },
+  );
+  return zWorkspaceFiscalOperationPage.parse(await response.json());
+})) {
+  await render(operation);
+}
+```
+
+The walk throws a `FiscalError` when a page reports more resources without a cursor to resume
+from, or returns the cursor it was read with, because neither page can be walked to the end of
+the list.
+
+Credentials belong on a trusted application server or native-assisted client. The package does not establish DGII approval, printer compatibility or legibility, hosted Checkout cutover, production capacity, or certification.

package/dist/artifact-headers.d.ts

@@ -0,0 +1,9 @@
+type HeaderFailure = (message: string) => never;
+export declare function createArtifactHeaderReader(headers: ReadonlyMap<string, string>, subject?: string, fail?: HeaderFailure): {
+    readonly digest: (name: string) => string;
+    readonly positiveInteger: (name: string) => number;
+    readonly required: (name: string) => string;
+    readonly uuid: (name: string) => string;
+};
+export {};
+//# sourceMappingURL=artifact-headers.d.ts.map

package/dist/artifact-headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-headers.d.ts","sourceRoot":"","sources":["../src/artifact-headers.ts"],"names":[],"mappings":"AAKA,KAAK,aAAa,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,KAAK,CAAC;AAEhD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,OAAO,SAAa,EACpB,IAAI,GAAE,aAA8B;4BAYd,MAAM,KAAG,MAAM;qCAgBN,MAAM,KAAG,MAAM;8BA1BtB,MAAM,KAAG,MAAM;0BAkBnB,MAAM,KAAG,MAAM;EAqBpC"}

package/dist/artifact-headers.js

@@ -0,0 +1,43 @@
+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 POSITIVE_INTEGER_PATTERN = /^[0-9]+$/;
+const POSITIVE_INT32_MAX = 2_147_483_647;
+export function createArtifactHeaderReader(headers, subject = "artifact", fail = throwTypeError) {
+    function required(name) {
+        const direct = headers.get(name);
+        const value = direct ?? Array.from(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+        if (value === undefined || value === "") {
+            fail(`Timbro omitted required ${subject} header ${name}`);
+        }
+        return value;
+    }
+    function digest(name) {
+        const value = required(name);
+        if (!SHA256_PATTERN.test(value)) {
+            fail(`Timbro returned an invalid digest header ${name}`);
+        }
+        return value;
+    }
+    function uuid(name) {
+        const value = required(name);
+        if (!UUID_PATTERN.test(value)) {
+            fail(`Timbro returned an invalid UUID header ${name}`);
+        }
+        return value;
+    }
+    function positiveInteger(name) {
+        const value = required(name);
+        if (!POSITIVE_INTEGER_PATTERN.test(value)) {
+            fail(`Timbro returned a non-integer header ${name}`);
+        }
+        const parsed = Number(value);
+        if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > POSITIVE_INT32_MAX) {
+            fail(`Timbro returned an out-of-range header ${name}`);
+        }
+        return parsed;
+    }
+    return { digest, positiveInteger, required, uuid };
+}
+function throwTypeError(message) {
+    throw new TypeError(message);
+}

package/dist/certificate-custody-import.d.ts

@@ -0,0 +1,13 @@
+import type { HostedFiscalTenant } from "./fiscal-operation.ts";
+import { type HostedImportResponse } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+import { type ReadonlyCamelCase } from "./public-case.ts";
+export type CertificateCustodyImportCommand = {
+    readonly certificateP12Base64: string;
+    readonly password: string;
+    readonly hosted: Pick<HostedFiscalTenant, "checkoutTenantId"> & Partial<Pick<HostedFiscalTenant, "environment">>;
+    readonly signal?: AbortSignal;
+};
+export type CertificateCustodyImportResult = ReadonlyCamelCase<HostedImportResponse>;
+export declare function importHostedCertificateCustodyResource(client: Client, command: CertificateCustodyImportCommand): Promise<CertificateCustodyImportResult>;
+//# sourceMappingURL=certificate-custody-import.d.ts.map

package/dist/certificate-custody-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"certificate-custody-import.d.ts","sourceRoot":"","sources":["../src/certificate-custody-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,KAAK,oBAAoB,EAAkC,MAAM,sBAAsB,CAAC;AACjG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,kBAAkB,CAAC;AAExE,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,GAC3D,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;AAErF,wBAAsB,sCAAsC,CAC1D,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,8BAA8B,CAAC,CA0BzC"}

package/dist/certificate-custody-import.js

@@ -0,0 +1,30 @@
+import { importHostedCertificateCustody } from "./generated/index.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { toPublicCase } from "./public-case.js";
+export async function importHostedCertificateCustodyResource(client, command) {
+    if (command.certificateP12Base64.trim() === "") {
+        throw new TypeError("certificateP12Base64 must not be blank");
+    }
+    if (command.password.length === 0) {
+        throw new TypeError("password must not be blank");
+    }
+    if (command.hosted.checkoutTenantId.trim() === "") {
+        throw new TypeError("hosted.checkoutTenantId must not be blank");
+    }
+    const response = await importHostedCertificateCustody({
+        client,
+        body: {
+            checkout_tenant_id: command.hosted.checkoutTenantId,
+            certificate_p12_base64: command.certificateP12Base64,
+            password: command.password,
+            ...(command.hosted.environment === undefined
+                ? {}
+                : { environment: command.hosted.environment }),
+        },
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Certificate custody import failed");
+    }
+    return toPublicCase(response.body);
+}

package/dist/certificate-custody-readiness.d.ts

@@ -0,0 +1,6 @@
+import { type CertificateCustodyReadiness as GeneratedCertificateCustodyReadiness } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+import { type ReadonlyCamelCase } from "./public-case.ts";
+export type CertificateCustodyReadiness = ReadonlyCamelCase<GeneratedCertificateCustodyReadiness>;
+export declare function readCertificateCustodyReadinessResource(client: Client, signal: AbortSignal | undefined): Promise<CertificateCustodyReadiness>;
+//# sourceMappingURL=certificate-custody-readiness.d.ts.map

package/dist/certificate-custody-readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"certificate-custody-readiness.d.ts","sourceRoot":"","sources":["../src/certificate-custody-readiness.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,2BAA2B,GAAG,iBAAiB,CAAC,oCAAoC,CAAC,CAAC;AAElG,wBAAsB,uCAAuC,CAC3D,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,2BAA2B,CAAC,CAStC"}

package/dist/certificate-custody-readiness.js

@@ -0,0 +1,13 @@
+import { readCertificateCustodyReadiness, } from "./generated/index.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { toPublicCase } from "./public-case.js";
+export async function readCertificateCustodyReadinessResource(client, signal) {
+    const response = await readCertificateCustodyReadiness({
+        client,
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Certificate-custody readiness read failed");
+    }
+    return toPublicCase(response.body);
+}

package/dist/collection.d.ts

@@ -0,0 +1,13 @@
+import { type CursorPage, type CursorPageWalkOptions } from "@timbro/protocol";
+/** One page of a Timbro Collection, as every list operation returns it. */
+export type CollectionPage<TResource> = CursorPage<TResource>;
+export type CollectionWalkOptions = CursorPageWalkOptions;
+/**
+ * Yields every resource in a Collection, following `next_cursor` until `has_more` is false.
+ *
+ * A page that reports more resources without a cursor, or that returns the cursor it was read
+ * with, cannot be walked to the end of the Collection, so the walk throws rather than stopping
+ * short of resources the caller asked for or replaying the page it already yielded.
+ */
+export declare function walkCollectionPages<TResource>(readPage: (cursor: string | undefined, signal: AbortSignal | undefined) => Promise<CollectionPage<TResource>>, options?: CollectionWalkOptions): AsyncGenerator<TResource, void, undefined>;
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,qBAAqB,EAE3B,MAAM,kBAAkB,CAAC;AAG1B,2EAA2E;AAC3E,MAAM,MAAM,cAAc,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,qBAAqB,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAuB,mBAAmB,CAAC,SAAS,EAClD,QAAQ,EAAE,CACR,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,MAAM,EAAE,WAAW,GAAG,SAAS,KAC5B,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,EACvC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,CAAC,CAc5C"}

package/dist/collection.js

@@ -0,0 +1,21 @@
+import { CursorPageWalkError, walkCursorPages, } from "@timbro/protocol";
+import { FiscalError } from "./fiscal-error.js";
+/**
+ * Yields every resource in a Collection, following `next_cursor` until `has_more` is false.
+ *
+ * A page that reports more resources without a cursor, or that returns the cursor it was read
+ * with, cannot be walked to the end of the Collection, so the walk throws rather than stopping
+ * short of resources the caller asked for or replaying the page it already yielded.
+ */
+export async function* walkCollectionPages(readPage, options) {
+    try {
+        yield* walkCursorPages(readPage, options);
+    }
+    catch (cause) {
+        if (!(cause instanceof CursorPageWalkError)) {
+            throw cause;
+        }
+        // biome-ignore lint/style/useErrorCause: FiscalError already exposes the bounded protocol failure detail.
+        throw new FiscalError(cause.message, { failure: cause.rejection === "aborted" ? "cancelled" : "server_processing" }, { cause });
+    }
+}

package/dist/direct-connection.d.ts

@@ -0,0 +1,74 @@
+import { type CreateDirectConnectionRequest, type DirectConnectionPreviewResource, type DirectConnectionRequestState } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+export type DirectConnectionEnvironment = CreateDirectConnectionRequest["environment"];
+export type DirectConnectionCreateCommand = {
+    readonly clientRequestId: string;
+    readonly installationId: string;
+    readonly databaseId: string;
+    readonly companyId: string;
+    readonly companyName: string;
+    readonly companyTaxId: string;
+    readonly softwareVersion: string;
+    readonly environment: DirectConnectionEnvironment;
+    /** A customer-managed Source bearer provisioned before authorization begins. */
+    readonly credential: string;
+    readonly pollingSecret: string;
+};
+export type DirectConnectionRequestCommand = DirectConnectionCreateCommand;
+export type DirectConnectionApprovalCommand = {
+    readonly legalIssuerId: string;
+};
+export type DirectConnectionRequest = {
+    readonly requestId: string;
+    readonly userCode: string;
+    readonly verificationUri: string;
+    readonly expiresAt: string;
+    readonly pollingSecret: string;
+};
+export type DirectConnectionPoll = {
+    readonly requestId: string;
+    readonly state: DirectConnectionRequestState;
+    readonly sourceConnectionId?: string | null | undefined;
+    readonly expiresAt: string;
+};
+export type DirectConnectionPreview = {
+    readonly requestId: string;
+    readonly installationId: string;
+    readonly companyId: string;
+    readonly companyName: string;
+    readonly companyTaxId: string;
+    readonly softwareVersion: string;
+    readonly environment: DirectConnectionPreviewResource["environment"];
+    readonly state: DirectConnectionRequestState;
+    readonly expiresAt: string;
+};
+export type DirectConnectionApproval = {
+    readonly requestId: string;
+    readonly sourceConnectionId: string;
+    readonly state: DirectConnectionRequestState;
+};
+export type DirectConnectionConfirmation = {
+    readonly sourceConnectionId: string;
+    readonly confirmed: boolean;
+};
+export type DirectConnectionClientOptions = {
+    readonly baseUrl: string;
+    readonly fetch?: typeof globalThis.fetch;
+};
+export type DirectConnectionClient = {
+    readonly create: (body: DirectConnectionCreateCommand) => Promise<DirectConnectionRequest>;
+    readonly poll: (requestId: string, pollingSecret: string) => Promise<DirectConnectionPoll>;
+    readonly cancel: (requestId: string, pollingSecret: string) => Promise<void>;
+    readonly confirm: (sourceConnectionId: string, credential: string) => Promise<DirectConnectionConfirmation>;
+};
+/** Generates the customer-managed bearer used by a direct Source connection. */
+export declare function generateDirectConnectionCredential(environment: DirectConnectionEnvironment): string;
+/** Creates the unauthenticated create/poll/cancel client and credential-scoped confirm call. */
+export declare function createDirectConnectionClient(options: DirectConnectionClientOptions): DirectConnectionClient;
+export type DirectConnectionWorkspaceOperations = {
+    readonly preview: (organizationId: string, userCode: string) => Promise<DirectConnectionPreview>;
+    readonly approve: (organizationId: string, userCode: string, body: DirectConnectionApprovalCommand) => Promise<DirectConnectionApproval>;
+};
+/** Adds Workspace-session preview and approval to the authenticated Workspace client. */
+export declare function createDirectConnectionWorkspaceOperations(client: Client): DirectConnectionWorkspaceOperations;
+//# sourceMappingURL=direct-connection.d.ts.map

package/dist/direct-connection.d.ts.map

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