@codespar/cli 0.17.0 → 0.18.0

package/templates/checkout-agent/packages/agent-core/src/stubs/mandate-status.ts

@@ -0,0 +1,58 @@
+/**
+ * STUB, for runs without a key: the CI, the scenarios and `rerun`, where
+ * there is no network. Answers the section 4.7 status check from the local
+ * state.db, so a scenario can revoke or pause a mandate mid-run
+ * (`before_decision`, `before_execute` in the scenario packs) and the core
+ * reacts exactly as it does against the API. Behind the same
+ * `MandateStatusSource` interface as `api/mandate-status.ts`, which is what
+ * a run with a test key gets instead; this file is never consulted on that
+ * path.
+ *
+ * It also holds the organization kill switch (`pauseAll`), so `org_paused`
+ * can be exercised locally the way `GET /v1/mandates/{id}` reports it
+ * (ent#1648): a flag next to the mandate's own status, which it leaves alone.
+ */
+import type { MandateStatusSource, MandateStatus, MandateStatusReport } from "../revocation.js";
+import type { StateStore } from "../state/store.js";
+
+export const STUB_ORG_ID = "org_local_stub";
+
+export class LocalMandateStatusStub implements MandateStatusSource {
+  constructor(
+    private readonly store: StateStore,
+    private readonly clock: () => Date = () => new Date(),
+  ) {}
+
+  async check(mandateId: string): Promise<MandateStatusReport> {
+    const row = this.store.stubMandateStatus(mandateId);
+    return {
+      mandate_id: mandateId,
+      status: (row?.status as MandateStatus | undefined) ?? "active",
+      org_paused: this.store.stubOrgPaused(STUB_ORG_ID),
+      checked_at: this.clock().toISOString(),
+      source: "stub",
+    };
+  }
+
+  /** `codespar mandate revoke <id>`, locally. */
+  revoke(mandateId: string, reason = "revoked by operator"): void {
+    this.store.stubSetMandateStatus(mandateId, "revoked", reason, this.clock().toISOString());
+  }
+
+  pause(mandateId: string, reason = "paused by operator"): void {
+    this.store.stubSetMandateStatus(mandateId, "paused", reason, this.clock().toISOString());
+  }
+
+  resume(mandateId: string): void {
+    this.store.stubSetMandateStatus(mandateId, "active", null, this.clock().toISOString());
+  }
+
+  /** The organization kill switch, locally. Against the API it is pressed with `POST /v1/orgs/{orgId}/pause`, which the kit never calls. */
+  pauseAll(): void {
+    this.store.stubSetOrgPaused(STUB_ORG_ID, true, this.clock().toISOString());
+  }
+
+  resumeAll(): void {
+    this.store.stubSetOrgPaused(STUB_ORG_ID, false, this.clock().toISOString());
+  }
+}

package/templates/checkout-agent/packages/agent-core/src/stubs/rail.ts

@@ -0,0 +1,209 @@
+/**
+ * STUB rail. A deterministic stand-in for the CodeSpar sandbox so the
+ * scenarios, the adversarial suite and the restart test run offline. Every
+ * attempt is persisted in state.db before the outcome is returned, which is
+ * what lets a process killed right after "the money left" be reconciled on
+ * `resume` instead of paying again. A repeat of an attempt id is answered the
+ * way the deployed API answers it (ent#1671): replayed when it settled,
+ * in flight while the provider is on it, spent when it failed, and refused
+ * when the id arrives with a different payment. A stub that simply replayed
+ * whatever it held would let a suite pass that the API fails. Receipts here are HMAC-shaped only in
+ * form; nothing about them is verifiable by anyone.
+ */
+import { canonicalJson, sha256Hex } from "../hash.js";
+import { checkQuote } from "../quote.js";
+import { checkSpendApproval, type PaymentRail, type RailLookup, type RailOutcome, type RailPayment, type RailReceipt } from "../rail.js";
+import type { StateStore } from "../state/store.js";
+import type { Actor } from "../types.js";
+
+export interface StubRailOptions {
+  clock?: () => Date;
+  /** Payees the stub refuses, to script a `failed` outcome. */
+  refusePayees?: string[];
+  /** Attempt ids the stub answers `uncertain` for, once. */
+  uncertainOnce?: string[];
+  /**
+   * Payees whose first presentation answers `uncertain`, the way a timeout
+   * does: the provider still took the attempt, so a later lookup finds it.
+   * The payee twin of `refusePayees`, for scripting an unknown outcome in the
+   * MIDDLE of a multi-item execution, where the attempt ids are not known
+   * until the execution exists.
+   */
+  uncertainPayees?: string[];
+  /** Test hook: called after the attempt is persisted and before the outcome is returned. */
+  afterDispatch?: (attemptId: string) => void;
+  /** Attempt ids whose first lookup answers `in_flight` and whose second lookup finds the provider finished (settled), with no pay() in between. */
+  inFlightThenSettled?: string[];
+  /**
+   * Where the "provider" keeps its books, when that is not the agent's own
+   * state file. The real rail is a server two machines share; a test that
+   * runs the same batch from two state files points both at one ledger.
+   */
+  ledger?: StateStore;
+}
+
+/** What the stub's books hold for an attempt the "provider" took and has not finished. */
+const IN_FLIGHT = { status: "in_flight" } as const;
+
+type Recorded = RailOutcome | typeof IN_FLIGHT;
+
+/**
+ * The fields a repeat of an attempt id is compared on, the stub's share of
+ * the API's attempt tuple (ent#1671): whose money, how much, to whom, the
+ * digest of the quote and the approval the spend carried (ent#1670). Rail
+ * and instrument are the API's and have no stub counterpart.
+ */
+function mismatchedFields(recorded: Omit<RailPayment, "actor">, asked: Omit<RailPayment, "actor">): string[] {
+  const out: string[] = [];
+  if (recorded.mandate_id !== asked.mandate_id) out.push("mandate");
+  if (recorded.amount_minor !== asked.amount_minor) out.push("amount_minor");
+  if (recorded.currency !== asked.currency) out.push("currency");
+  if (recorded.payee !== asked.payee) out.push("payee");
+  if (canonicalJson(recorded.quote ?? null) !== canonicalJson(asked.quote ?? null)) out.push("quote");
+  if (canonicalJson(recorded.approval ?? null) !== canonicalJson(asked.approval ?? null)) out.push("approval");
+  return out;
+}
+
+export class StubRail implements PaymentRail {
+  readonly name = "stub" as const;
+  private readonly clock: () => Date;
+  private readonly uncertainPending: Set<string>;
+
+  private readonly store: StateStore;
+
+  constructor(
+    store: StateStore,
+    private readonly options: StubRailOptions = {},
+  ) {
+    this.store = options.ledger ?? store;
+    this.clock = options.clock ?? (() => new Date());
+    this.uncertainPending = new Set(options.uncertainOnce ?? []);
+  }
+
+  private uncertainArmed = false;
+  private readonly inFlightSeen = new Set<string>();
+  /** Attempts that already gave their one `uncertain`, so a re-presentation behaves normally. */
+  private readonly uncertainAnswered = new Set<string>();
+  /** How many times pay() reached the point of persisting a NEW attempt. */
+  payCount = 0;
+
+  /** The NEXT new attempt answers `uncertain` once, whatever its id; the provider still took it, so a later lookup sees it in flight and then settled. For scenarios that reconcile. */
+  armUncertainOnce(): void {
+    this.uncertainArmed = true;
+  }
+
+  async pay(payment: RailPayment): Promise<RailOutcome> {
+    // The same refusal the CodeSpar rail makes before its call, so a scenario exercises it.
+    const quoted = checkQuote(payment);
+    if (!quoted.ok) return { status: "failed", code: quoted.code, message: `${quoted.detail}; nothing was sent` };
+    const approval = checkSpendApproval(payment);
+    if (!approval.ok) return { status: "failed", code: approval.code, message: `${approval.detail}; nothing was sent` };
+    const { actor: _actor, ...request } = payment;
+    const existing = this.store.stubRailGet(payment.attempt_id);
+    if (existing) return this.repeat(payment.attempt_id, existing.request as Omit<RailPayment, "actor">, existing.outcome as Recorded, request);
+
+    const uncertainPayee = this.options.uncertainPayees?.includes(payment.payee) === true && !this.uncertainAnswered.has(payment.attempt_id);
+    if (this.uncertainArmed || this.uncertainPending.has(payment.attempt_id) || uncertainPayee) {
+      // Armed and payee-scripted attempts were TAKEN by the provider, so they are on its books as in flight; `uncertainOnce` never reached it.
+      if (this.uncertainArmed || uncertainPayee) this.store.stubRailPut(payment.attempt_id, request, IN_FLIGHT, this.clock().toISOString());
+      this.uncertainAnswered.add(payment.attempt_id);
+      this.uncertainArmed = false;
+      this.uncertainPending.delete(payment.attempt_id);
+      return { status: "uncertain", code: "psp_dispatch_uncertain", message: "stub: outcome unknown on first presentation" };
+    }
+
+    const at = this.clock().toISOString();
+    const outcome: RailOutcome = this.options.refusePayees?.includes(payment.payee)
+      ? { status: "failed", code: "psp_dispatch_failed", message: `stub: provider refused payee ${payment.payee}` }
+      : settledOutcome(payment.attempt_id, { stub: true, attempt_id: payment.attempt_id, at });
+    this.payCount += 1;
+    this.store.stubRailPut(payment.attempt_id, request, outcome, at);
+    this.options.afterDispatch?.(payment.attempt_id);
+    return outcome;
+  }
+
+  /**
+   * A presentation of an attempt id the books already hold, answered the way
+   * the deployed API answers it (ent#1671, #1683), and never by paying:
+   * a different payment under the id is `attempt_id_conflict`, checked before
+   * the state; a settled one is its ORIGINAL outcome with `idempotent_replay`;
+   * one still in flight is `psp_attempt_in_flight`; a failed one is
+   * `psp_attempt_conflict`, spent for good.
+   */
+  private repeat(attemptId: string, recorded: Omit<RailPayment, "actor">, outcome: Recorded, asked: Omit<RailPayment, "actor">): RailOutcome {
+    const mismatched = mismatchedFields(recorded, asked);
+    if (mismatched.length > 0) {
+      return { status: "failed", code: "attempt_id_conflict", message: `stub: attempt ${attemptId} was already used for a different payment (differs in: ${mismatched.join(", ")}); nothing was held or sent`, held: "conflict" };
+    }
+    switch (outcome.status) {
+      case "in_flight":
+        return { status: "uncertain", code: "psp_attempt_in_flight", message: `stub: attempt ${attemptId} is claimed and its outcome is not yet recorded` };
+      case "settled":
+        return { ...outcome, replayed: true, raw: { ...(outcome.raw as Record<string, unknown>), idempotent_replay: true } };
+      case "failed":
+        return { status: "failed", code: "psp_attempt_conflict", message: `stub: attempt ${attemptId} already failed and moved no money; use a fresh attempt_id`, spent: true };
+      default:
+        return outcome;
+    }
+  }
+
+  async lookup(attemptId: string, payment: RailPayment): Promise<RailLookup> {
+    const { actor: _actor, ...request } = payment;
+    const existing = this.store.stubRailGet(attemptId);
+    const recorded = existing?.outcome as Recorded | undefined;
+    // Looking up IS presenting again on the real rail, so a recorded attempt answers exactly what a repeat of it answers.
+    if (existing && recorded && recorded.status !== "in_flight") return this.repeat(attemptId, existing.request as Omit<RailPayment, "actor">, recorded, request);
+    if (this.options.inFlightThenSettled?.includes(attemptId) || recorded?.status === "in_flight") {
+      if (!this.inFlightSeen.has(attemptId)) {
+        this.inFlightSeen.add(attemptId);
+        return { status: "in_flight" };
+      }
+      // The provider finished on its own; the stub records the outcome as the rail would, without a new dispatch.
+      const outcome = settledOutcome(attemptId, { stub: true, attempt_id: attemptId, finished_in_background: true });
+      this.store.stubRailReplace(attemptId, existing?.request ?? request, outcome, this.clock().toISOString());
+      return outcome;
+    }
+    return undefined;
+  }
+
+  async receipt(receiptId: string, actor: Actor): Promise<RailReceipt | undefined> {
+    const sealed = this.store.stubRailFindByReceipt(receiptId);
+    if (!sealed) return undefined;
+    const req = sealed.request as Omit<RailPayment, "actor">;
+    const out = sealed.outcome as Extract<RailOutcome, { status: "settled" }>;
+    // Like the API: the payee on the receipt is the one the quote sealed, and none when the spend carried no quote.
+    const body = {
+      receipt_id: receiptId,
+      state: "paid",
+      mandate: { id: req.mandate_id },
+      // Like the API since ent#1670: the approval the spend carried is sealed and read back, batch_hash null when none was sent.
+      chain_version: req.approval ? 4 : 1,
+      approval: req.approval ? { items_hash: req.approval.items_hash, batch_hash: req.approval.batch_hash ?? null } : null,
+      payment: { amount_minor: req.amount_minor, payee: req.quote?.payee ?? null, attempt_id: req.attempt_id, money_moved: false, sandbox: true, at: sealed.at },
+    };
+    const chain = `sha256:${sha256Hex(JSON.stringify(req.quote ? { ...body, quote: req.quote } : body))}`;
+    return {
+      ...body,
+      chain,
+      receipt_sig: `stub:${sha256Hex(`sig:${chain}`).slice(0, 32)}`,
+      // The stub holds no CodeSpar key and must not look as though it did:
+      // `npm run verify` answers `unsigned` on a stub receipt, which is the
+      // truth about it.
+      receipt_sig_ed25519: null,
+      receipt_sig_kid: null,
+      actor,
+      raw: { stub: true, transaction_id: out.transaction_id },
+    };
+  }
+}
+
+function settledOutcome(attemptId: string, raw: Record<string, unknown>): RailOutcome {
+  return {
+    status: "settled",
+    transaction_id: `stubtx_${sha256Hex(attemptId).slice(0, 16)}`,
+    receipt_id: `rcpt_stub_${sha256Hex(`receipt:${attemptId}`).slice(0, 16)}`,
+    money_moved: false,
+    sandbox: true,
+    raw,
+  };
+}

package/templates/checkout-agent/packages/agent-core/src/tools.ts

@@ -0,0 +1,66 @@
+/**
+ * `tools.json`: the closed list of tools the model may call. Tool-level
+ * authority comes before mandate-level authority: a tool that is not in
+ * this file is refused before anything else looks at the call.
+ *
+ * Two kinds. `meta_tools` borrow a CodeSpar meta-tool's name for the job
+ * they do, but the input shape is the kit's own and the kit's handler runs it:
+ * a payment or charge becomes a `drafted` execution, and the core sends the
+ * real call over REST. It is not a copy of the MCP's schema and does not match
+ * it (OPEN_QUESTIONS section 8 has the comparison). `local_tools` are the
+ * agent's own helpers: reads, and state the agent keeps for itself.
+ */
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import type { ToolSpec } from "./providers/types.js";
+
+const ToolDefinitionSchema = z
+  .object({
+    name: z.string().regex(/^[a-z][a-z0-9_]*$/),
+    description: z.string().min(1),
+    input_schema: z.record(z.string(), z.unknown()),
+    /**
+     * `payment` and `charge` tools create a `drafted` execution and nothing
+     * else; `read` tools never touch money and change nothing. `charge` is the
+     * receivable side: the counterparty pays us. `state` changes durable local
+     * state (a cart in `state.db`) and moves no money — not a read, because
+     * calling it twice is not calling it once, and not a payment, because no
+     * execution comes out of it.
+     */
+    effect: z.enum(["payment", "charge", "read", "state"]),
+  })
+  .strict();
+
+export const ToolsFileSchema = z
+  .object({
+    meta_tools: z.array(ToolDefinitionSchema),
+    local_tools: z.array(ToolDefinitionSchema),
+  })
+  .strict()
+  .superRefine((t, ctx) => {
+    const names = new Set<string>();
+    for (const tool of [...t.meta_tools, ...t.local_tools]) {
+      if (names.has(tool.name)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate tool ${tool.name}` });
+      names.add(tool.name);
+    }
+    for (const [i, tool] of t.meta_tools.entries()) {
+      if (!tool.name.startsWith("codespar_")) ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["meta_tools", i, "name"], message: "meta-tools are named codespar_*" });
+      // A meta-tool borrows a CodeSpar name for a job CodeSpar does; the state the agent keeps for itself is not one.
+      if (tool.effect === "state") ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["meta_tools", i, "effect"], message: "a state tool is local: meta-tools move money or read" });
+    }
+  });
+
+export type ToolsFile = z.infer<typeof ToolsFileSchema>;
+export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+
+export function loadToolsFile(path: string): ToolsFile {
+  return ToolsFileSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+}
+
+export function toolSpecs(tools: ToolsFile): ToolSpec[] {
+  return [...tools.meta_tools, ...tools.local_tools].map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema }));
+}
+
+export function allowedToolNames(tools: ToolsFile): Set<string> {
+  return new Set([...tools.meta_tools, ...tools.local_tools].map((t) => t.name));
+}

package/templates/checkout-agent/packages/agent-core/src/types.ts

@@ -0,0 +1,187 @@
+/**
+ * Shared shapes of the core. Amounts are always integer minor units (BRL
+ * cents). Timestamps are ISO 8601 strings so they survive SQLite and JSON
+ * unchanged.
+ */
+
+export type ApprovalMode = "human" | "mandate";
+
+/** Section 4.5: who acted. Every API call and every receipt carries one. */
+export type Actor =
+  | { type: "agent"; agent: string; on_behalf_of: string }
+  | { type: "human"; id: string; channel: string };
+
+/** One line of an execution: a payee and an amount, resolved by the core. */
+export interface ExecutionItem {
+  /** The alias the model used (`escola`), when it used one. */
+  alias?: string;
+  /** Display name from the mandate's named payees, when known. */
+  beneficiary: string;
+  /** The pinned payee key (a Pix key for `pix-key` mandates). */
+  payee: string;
+  amount: number;
+  currency: string;
+  description?: string;
+  /** A receivable's due date (`YYYY-MM-DD`). Part of the `items_hash` when present: moving it after approval is a different charge. */
+  due_date?: string;
+}
+
+/**
+ * The SET a line belongs to, when the line is one execution of a batch.
+ *
+ * A batch of N lines is N executions, each attested by its own `items_hash`.
+ * That leaves the list itself unattested: a person who approved four lines
+ * while the agent ran three leaves a bundle that does not say a fourth
+ * existed. `batch_hash` binds the set — computed once over the ordered lines
+ * at the moment the list is presented for approval, and carried by every
+ * artifact of that batch together with the line's own position in it.
+ *
+ * Absent on an execution that is not part of a batch, and an artifact
+ * without it is the artifact of section 4.2 unchanged, byte for byte: the
+ * field is omitted rather than null, so the canonical payload it signs is
+ * the same payload it signed before this existed.
+ */
+export interface ExecutionBatch {
+  /** The batch's reference, as the kit names it (`folha-2026-10`). */
+  ref: string;
+  /** `batchHash` over the batch's ordered lines, as they were presented. */
+  batch_hash: string;
+  /** This line's position in that ordered list, counting from 0. */
+  index: number;
+  /** How many lines the presented list held. */
+  count: number;
+}
+
+/**
+ * One line of what an execution's amount is MADE OF, as the kit resolved it:
+ * a cart line (`ref` a SKU, a quantity, the unit price the catalog gave it)
+ * or a discount line (a negative `amount`). Only `compositionHash` reads it;
+ * the core never stores the lines, only their hash and their count.
+ */
+export interface CompositionLine {
+  ref: string;
+  quantity: number;
+  unit_amount: number;
+  amount: number;
+  currency: string;
+}
+
+/**
+ * What an execution's single amount was composed from, when it was composed
+ * from something: a sale is ONE charge, so ONE item whose amount is the
+ * order's total, and the lines of the cart behind that total are not items.
+ *
+ * That leaves the composition unattested by `items_hash`: two units at 100
+ * and one unit at 200 are the same item, the same amount, the same hash.
+ * `composition_hash` binds the lines — computed by the kit over the resolved
+ * lines in order, carried by the execution and by every artifact of it — so a
+ * cart recomposed at a constant total after approval is not the cart that was
+ * approved.
+ *
+ * Absent on an execution that is not composed from anything, and an artifact
+ * without it is the artifact of section 4.2 unchanged, byte for byte: the
+ * field is omitted rather than null, the same discipline as `batch`.
+ */
+export interface ExecutionComposition {
+  /** The kit's reference for what was composed (`cart_id`). */
+  ref: string;
+  /** `compositionHash` over the resolved lines, in order. */
+  composition_hash: string;
+  /** How many lines that hash covers. */
+  line_count: number;
+}
+
+/** The trigger of section 4.4 that sent a `mandate` execution to a human. */
+export type EscalationTrigger = "amount" | "new_beneficiary" | "outside_hours";
+
+/** Stable reasons a transition can carry. They are the readable-failure contract. */
+export type ExecutionReason =
+  | "mandate_revoked"
+  | "mandate_paused"
+  | "mandate_expired"
+  | "mandate_status_unavailable"
+  | "org_paused"
+  | "beneficiary_not_allowed"
+  | "per_tx_cap_exceeded"
+  | "window_cap_exceeded"
+  | "approval_expired"
+  | "items_hash_mismatch"
+  /** The quote a spend would present does not name the approved amount and payee; refused before the call. */
+  | "quote_mismatch"
+  | "mandate_changed"
+  | "denied_by_approver"
+  | "rail_failed"
+  | "rail_uncertain"
+  | "tool_not_allowed"
+  | "model_total_mismatch"
+  | "outside_hours"
+  | "escalated"
+  /** The agent's own envelope (guardrails) refused what the model proposed: a discount, an instalment count or a due date outside it. */
+  | "outside_envelope"
+  /** A receivable was issued and the rail is waiting for the payer; the execution stays `executing` until `commerce.charge.*` closes it. */
+  | "awaiting_settlement"
+  | "charge_expired"
+  | "charge_cancelled"
+  /**
+   * An ISSUED receivable whose read now answers that its reference matches more than one charge. Terminal for the
+   * execution, but not "nothing moved": the charge exists and may still be paid. Reconcile it by the charge id; never
+   * issue another to the same payee until that is done, which is why the core refuses one (`policy`).
+   */
+  | "charge_reference_ambiguous";
+
+export interface MandateRef {
+  id: string;
+  version: number;
+}
+
+/** Section 4.2. */
+export interface ApprovalArtifact {
+  approval_id: string;
+  execution_id: string;
+  mode: ApprovalMode;
+  approver:
+    | { type: "person"; id: string; channel: string }
+    | { type: "mandate"; id: string };
+  approved_at: string;
+  expires_at: string;
+  mandate: MandateRef;
+  items: ExecutionItem[];
+  items_hash: string;
+  /** Present when this execution is one line of a batch: what binds the SET this line was approved inside. */
+  batch?: ExecutionBatch;
+  /** Present when this execution's amount is composed of lines (a cart): what binds the composition that was approved. */
+  composition?: ExecutionComposition;
+  /** Present when a section 4.4 trigger sent the execution to a human first. */
+  escalation?: { trigger: EscalationTrigger; detail: string };
+  actor: Actor;
+  signature: { alg: "HMAC-SHA256"; key_id: string; value: string };
+}
+
+export interface ItemOutcome {
+  index: number;
+  attempt_id: string;
+  /** `accepted`: the rail took the attempt and the outcome comes later (a receivable waiting for its payer). Not terminal. */
+  status: "settled" | "failed" | "accepted";
+  receipt_id?: string;
+  transaction_id?: string;
+  /** The rail's code on a failed outcome (`charge_expired`, `charge_cancelled`, a provider code). */
+  code?: string;
+  /** A failed outcome because the attempt id is held for another payment or another project (`RailOutcome.held`). */
+  held?: "conflict" | "unavailable";
+  /** A settled outcome the rail answered from its record of an earlier presentation (`RailOutcome.replayed`). */
+  replayed?: true;
+  error?: string;
+  /** What the payer is shown for an accepted receivable, as the rail handed it back. Presentation only; nothing here decides money. */
+  instrument?: ChargeInstrument;
+}
+
+/** The payable legs of a receivable. Null until the issuer registers the instrument (a cobranca com vencimento answers PROCESSING first). */
+export interface ChargeInstrument {
+  payable: boolean;
+  pix_copy_paste: string | null;
+  boleto_bank_line: string | null;
+  boleto_bar_code: string | null;
+  due_date: string | null;
+  /** The issuer's normalized state as last read: PROCESSING, PENDING, CONFIRMED, EXPIRED, CANCELLED. */
+  status: string;
+}