Node SDK

constructor(opts?: PayoutsClientOptions);

corridors(): Promise<{
  corridors: Corridor[];
  capabilities: { exactOutput: boolean; indicativePricing: boolean };
}>;

requirements(currency: string): Promise<Corridor>;

quote(args: {
  amount: string;
  to: string;
  from?: string;
}): Promise<PreviewQuote>;

createBeneficiary(args: {
  name: string;
  currency: string;
  details: Record<string, string>;
  /** REQUIRED. The server rejects a create without it. */
  email: string;
  type?: 'individual' | 'business';
  country?: string;
  /** YOUR id for the person SENDING. Scopes the beneficiary to them. */
  endUserId?: string;
  /** YOUR id for this beneficiary. Makes a repeat create safe. */
  externalId?: string;
  idempotencyKey?: string;
}): Promise<Beneficiary>;

listBeneficiaries(args?: {
  endUserId?: string;
}): Promise<{
  /** 'organization' or the end user the list was scoped to. Undeclared previously. */
  scope: string;
  recipients: Beneficiary[];
  /**
   * This route is NOT paginated today — these never appear. Kept optional so
   * adding pagination later is not a breaking change.
   */
  hasMore?: boolean;
  nextCursor?: string | null;
}>;

eachEvent(args?: {
  since?: string;
  limit?: number;
  payoutId?: string;
}): AsyncIterableIterator<PayoutEvent>;

eachPayout(args?: {
  limit?: number;
  status?: string;
  endUserId?: string;
  reference?: string;
  updatedSince?: string;
}): AsyncIterableIterator<Payout>;

request(
  method: string,
  path: string,
  opts?: {
    body?: unknown;
    query?: Record<string, unknown>;
    idempotencyKey?: string;
    headers?: Record<string, string>;
  },
): Promise<unknown>;

cancelPayout(
  payoutId: string,
  opts?: { idempotencyKey?: string },
): Promise<Payout>;

pricePayout(args: {
  amount: string;
  destinationAccountId: string;
  purposeOfPayment?: string;
  // Deliberately loose: the snapshot is the rail's own quote object and its
  // shape varies by routing. Pass it straight back to `send()`.
}): Promise<{ id: string; best_quote_id?: string; [k: string]: unknown }>;

send(args: {
  snapshotId: string;
  quoteId?: string;
  endUser?: EndUser;
  reference?: string;
  idempotencyKey?: string;
}): Promise<Payout>;

payout(args: PayoutArgs): Promise<Payout>;

listEvents(args?: {
  /** The `nextSince` from your last page. */
  since?: string;
  limit?: number;
  /** Everything that ever happened to one payout. */
  payoutId?: string;
}): Promise<{
  data: PayoutEvent[];
  hasMore: boolean;
  nextSince: string | null;
}>;

getFunding(payoutId: string): Promise<{
  payoutId: string;
  amount: string;
  currency: string;
  depositAddress: string;
  network: string;
  expiresAt: string;
  /** Present when you can sign through this API instead of broadcasting. */
  signableOperations?: unknown[];
  instructions: string;
}>;

confirmFunding(
  payoutId: string,
  proof: {
    transactionHash?: string;
    signedOperations?: unknown[];
    tamperProofSignature?: string;
    idempotencyKey?: string;
  },
): Promise<Payout>;

getPayout(payoutId: string): Promise<Payout>;

listPayouts(args?: {
  limit?: number;
  cursor?: string;
  status?: string;
  endUserId?: string;
  reference?: string;
  /**
   * **The change feed.** Payouts whose state changed at or after this time,
   * oldest-changed first.
   *
   * Ordinary listing is newest-first by CREATION, which by construction can
   * never tell you an OLD payout changed — and `completed → failed` on a bank
   * return, days later, is exactly the change a ledger cannot afford to miss.
   * Page forward, carry the highest `updatedAt` you have seen as your
   * watermark, and you observe every revision at least once.
   *
   * `updatedSince` is INCLUSIVE, so resuming re-reads the row at your
   * watermark. Dedupe on payoutId + updatedAt.
   */
  updatedSince?: string;
}): Promise<{ data: Payout[]; hasMore: boolean; nextCursor: string | null }>;

fundingAccounts(): Promise<unknown>;

balance(): Promise<{ currency: string; amount: string }>;

balanceHistory(limit?: number): Promise<{
  currency: string;
  balance: string;
  entries: {
    id: string;
    /**
     * `reversal` is a returned payout crediting the balance back. It is a
     * SEPARATE appended entry, not a rewrite of the original debit — an entry
     * already emitted never changes.
     */
    type: 'funding' | 'payout' | 'reversal';
    /**
     * What this ENTRY records, frozen at the moment it was written — not the
     * payout's current status, which would make a historical row mutate.
     * `DEBITED` money left, `RETURNED` money came back, `COMPLETED` funding
     * landed. For a payout's live fate, read `getPayout()`.
     */
    status: 'DEBITED' | 'RETURNED' | 'COMPLETED' | (string & {});
    amount: string;
    balanceAfter: string;
    reference?: string;
    at: string;
  }[];
}>;

fund(amount?: string, idempotencyKey?: string): Promise<{ balance: string }>;

createPayoutLink(args: {
  amount: string;
  /** e.g. 'MXN'. `to` is accepted as an alias. */
  destinationCurrency?: string;
  to?: string;
  endUserId: string;
  reference?: string;
  /** Defaults to 60. Capped at 7 days. */
  expiresInMinutes?: number;
  idempotencyKey?: string;
}): Promise<{
  payoutLinkId: string;
  url: string;
  expiresAt: string;
  status: string;
}>;

createWebhookEndpoint(args: {
  url: string;
  events?: string[];
  idempotencyKey?: string;
}): Promise<{
  id: string;
  url: string;
  events: string[];
  secret: string;
  warning: string;
}>;

webhookDeliveries(endpointId: string): Promise<unknown>;