@dime-technology/dime-js-sdk 1.3.0 → 1.4.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 declare const DEFAULT_BASE_URL = "https://app.dimepayments.com";
-declare const VERSION = "1.3.0";
+declare const VERSION = "1.4.0";
 interface ConfigOptions {
     /** Sanctum personal access token (sent as Bearer). */
     token: string;
@@ -28,7 +28,7 @@ declare class Config {
     baseUri(): string;
 }
 
-type Raw$x = Record<string, unknown>;
+type Raw$Q = Record<string, unknown>;
 declare class Address {
     readonly id?: number | undefined;
     readonly recipient?: string | undefined;
@@ -39,14 +39,14 @@ declare class Address {
     readonly state?: string | undefined;
     readonly zip?: string | undefined;
     constructor(id?: number | undefined, recipient?: string | undefined, lineOne?: string | undefined, lineTwo?: string | undefined, lineThree?: string | undefined, city?: string | undefined, state?: string | undefined, zip?: string | undefined);
-    static fromRaw(data: Raw$x): Address;
+    static fromRaw(data: Raw$Q): Address;
 }
 
-type Raw$w = Record<string, unknown>;
+type Raw$P = Record<string, unknown>;
 declare class MessageResult {
     readonly message?: string | undefined;
     constructor(message?: string | undefined);
-    static fromRaw(data: Raw$w): MessageResult;
+    static fromRaw(data: Raw$P): MessageResult;
 }
 
 type PageFetcher<T> = (cursor: string) => Promise<CursorPage<T>>;
@@ -66,7 +66,13 @@ declare class CursorPage<T> {
     get length(): number;
 }
 
-type Raw$v = Record<string, unknown>;
+type Raw$O = Record<string, unknown>;
+interface MultipartFile {
+    /** The form field name, e.g. `files[]`. */
+    field: string;
+    content: Blob;
+    filename: string;
+}
 declare class Transport {
     private readonly config;
     private readonly fetchFn;
@@ -81,32 +87,96 @@ declare class Transport {
      * serialised into the query string (`data[sid]=…&filters[status]=…`) and no
      * body is sent; every other method sends the envelope as a JSON body.
      */
-    request(method: string, path: string, body?: Raw$v, query?: Record<string, string>): Promise<Raw$v>;
+    request(method: string, path: string, body?: Raw$O, query?: Record<string, string>): Promise<Raw$O>;
+    /**
+     * Execute a `multipart/form-data` request and return the decoded JSON body.
+     *
+     * Multipart has no JSON parsing, so the envelope is sent as bracketed form
+     * fields (`data[sid]=…`) — a single `data` field holding JSON would be read
+     * as a plain string. No Content-Type is set here: fetch derives it, boundary
+     * included, from the FormData body.
+     */
+    requestMultipart(method: string, path: string, body: Raw$O, files: MultipartFile[]): Promise<Raw$O>;
+    private headers;
     private attempt;
     private sleep;
 }
 
-type Raw$u = Record<string, unknown>;
+type Raw$N = Record<string, unknown>;
 declare abstract class AbstractResource {
     protected readonly transport: Transport;
     constructor(transport: Transport);
     /**
      * Build the standard Dime request envelope, dropping null/undefined values.
      */
-    protected envelope(data?: Raw$u, filters?: Raw$u): Raw$u;
-    protected paginate<T>(method: string, path: string, body: Raw$u, map: (item: Raw$u) => T, query?: Record<string, string>): Promise<CursorPage<T>>;
+    protected envelope(data?: Raw$N, filters?: Raw$N): Raw$N;
+    protected paginate<T>(method: string, path: string, body: Raw$N, map: (item: Raw$N) => T, query?: Record<string, string>): Promise<CursorPage<T>>;
 }
 
-type Raw$t = Record<string, unknown>;
+type Raw$M = Record<string, unknown>;
 declare class Addresses extends AbstractResource {
     list(sid: string, uuid: string): Promise<CursorPage<Address>>;
     show(sid: string, uuid: string, addressId: number | string): Promise<Address>;
-    create(sid: string, uuid: string, attributes: Raw$t): Promise<Address>;
-    update(sid: string, uuid: string, addressId: number | string, attributes: Raw$t): Promise<Address>;
+    create(sid: string, uuid: string, attributes: Raw$M): Promise<Address>;
+    update(sid: string, uuid: string, addressId: number | string, attributes: Raw$M): Promise<Address>;
     delete(sid: string, uuid: string, addressId: number | string): Promise<MessageResult>;
 }
 
-type Raw$s = Record<string, unknown>;
+type Raw$L = Record<string, unknown>;
+/**
+ * A chargeback raised against a merchant, as of the processor's most recent
+ * daily file. The same shape the `chargeback_*` webhooks carry.
+ *
+ * `transactionInfoId` identifies the chargeback itself; the disputed payment is
+ * `parentTransactionInfoId`. Amounts are kept as strings to avoid float rounding.
+ */
+declare class Chargeback {
+    readonly transactionInfoId?: string | undefined;
+    readonly parentTransactionInfoId?: string | undefined;
+    readonly gatewayTransactionId?: string | undefined;
+    readonly transactionNumber?: string | undefined;
+    readonly invoiceNumber?: string | undefined;
+    readonly chargebackDate?: string | undefined;
+    readonly merchantChargebackDate?: string | undefined;
+    readonly transactionAmount?: string | undefined;
+    readonly chargebackAmount?: string | undefined;
+    readonly cardBrand?: string | undefined;
+    readonly ccLastFour?: string | undefined;
+    readonly payeeName?: string | undefined;
+    readonly daysToRepresent?: number | undefined;
+    readonly representmentDate?: string | undefined;
+    readonly merchantRepresentmentDate?: string | undefined;
+    readonly representmentStatus?: string | undefined;
+    readonly result?: string | undefined;
+    readonly chargebackCode?: string | undefined;
+    readonly chargebackResponseCode?: string | undefined;
+    readonly resolved: boolean;
+    constructor(transactionInfoId?: string | undefined, parentTransactionInfoId?: string | undefined, gatewayTransactionId?: string | undefined, transactionNumber?: string | undefined, invoiceNumber?: string | undefined, chargebackDate?: string | undefined, merchantChargebackDate?: string | undefined, transactionAmount?: string | undefined, chargebackAmount?: string | undefined, cardBrand?: string | undefined, ccLastFour?: string | undefined, payeeName?: string | undefined, daysToRepresent?: number | undefined, representmentDate?: string | undefined, merchantRepresentmentDate?: string | undefined, representmentStatus?: string | undefined, result?: string | undefined, chargebackCode?: string | undefined, chargebackResponseCode?: string | undefined, resolved?: boolean);
+    static fromRaw(data: Raw$L): Chargeback;
+}
+
+type Raw$K = Record<string, unknown>;
+/**
+ * Chargebacks raised against a merchant. Needs the `chargeback:read` ability.
+ *
+ * The data arrives in a once-daily file from the processor, so it reflects the
+ * latest import rather than live dispute activity. Pair it with the
+ * `chargeback_opened` / `chargeback_updated` / `chargeback_resolved` webhooks
+ * and use these endpoints to reconcile or backfill.
+ */
+declare class Chargebacks extends AbstractResource {
+    /**
+     * List a merchant's chargebacks.
+     *
+     * @param filters `start_date` and `end_date` (UTC, `Y-m-d H:i:s`, sent
+     *   together), `representment_status` (free text from the processor, e.g.
+     *   `New` or `Resolved`)
+     */
+    list(sid: string, filters?: Raw$K): Promise<CursorPage<Chargeback>>;
+    show(sid: string, transactionInfoId: string): Promise<Chargeback>;
+}
+
+type Raw$J = Record<string, unknown>;
 declare class Customer {
     readonly uuid?: string | undefined;
     readonly firstName?: string | undefined;
@@ -121,19 +191,19 @@ declare class Customer {
     readonly zip?: string | undefined;
     readonly country?: string | undefined;
     constructor(uuid?: string | undefined, firstName?: string | undefined, lastName?: string | undefined, phone?: string | undefined, email?: string | undefined, addr1?: string | undefined, addr2?: string | undefined, addr3?: string | undefined, city?: string | undefined, state?: string | undefined, zip?: string | undefined, country?: string | undefined);
-    static fromRaw(data: Raw$s): Customer;
+    static fromRaw(data: Raw$J): Customer;
 }
 
-type Raw$r = Record<string, unknown>;
+type Raw$I = Record<string, unknown>;
 declare class Customers extends AbstractResource {
-    list(sid: string, filters?: Raw$r): Promise<CursorPage<Customer>>;
-    show(sid: string, filters: Raw$r): Promise<Customer>;
-    create(sid: string, attributes: Raw$r): Promise<Customer>;
-    update(sid: string, filters: Raw$r, attributes: Raw$r): Promise<Customer>;
-    delete(sid: string, filters: Raw$r): Promise<MessageResult>;
+    list(sid: string, filters?: Raw$I): Promise<CursorPage<Customer>>;
+    show(sid: string, filters: Raw$I): Promise<Customer>;
+    create(sid: string, attributes: Raw$I): Promise<Customer>;
+    update(sid: string, filters: Raw$I, attributes: Raw$I): Promise<Customer>;
+    delete(sid: string, filters: Raw$I): Promise<MessageResult>;
 }
 
-type Raw$q = Record<string, unknown>;
+type Raw$H = Record<string, unknown>;
 declare class Deposit {
     readonly transactionDate?: string | undefined;
     readonly fundDate?: string | undefined;
@@ -145,10 +215,10 @@ declare class Deposit {
     readonly sweepId?: string | undefined;
     readonly type?: string | undefined;
     constructor(transactionDate?: string | undefined, fundDate?: string | undefined, transactionInfoId?: string | undefined, transactionId?: string | undefined, transactionDetailAccount?: string | undefined, authorizationAmount?: string | undefined, netAmount?: string | undefined, sweepId?: string | undefined, type?: string | undefined);
-    static fromRaw(data: Raw$q): Deposit;
+    static fromRaw(data: Raw$H): Deposit;
 }
 
-type Raw$p = Record<string, unknown>;
+type Raw$G = Record<string, unknown>;
 declare class TransactionAddress {
     readonly firstName?: string | undefined;
     readonly lastName?: string | undefined;
@@ -158,10 +228,10 @@ declare class TransactionAddress {
     readonly state?: string | undefined;
     readonly zip?: string | undefined;
     constructor(firstName?: string | undefined, lastName?: string | undefined, addr1?: string | undefined, addr2?: string | undefined, city?: string | undefined, state?: string | undefined, zip?: string | undefined);
-    static fromRaw(data: Raw$p): TransactionAddress;
+    static fromRaw(data: Raw$G): TransactionAddress;
 }
 
-type Raw$o = Record<string, unknown>;
+type Raw$F = Record<string, unknown>;
 declare class Transaction {
     readonly transactionType?: string | undefined;
     readonly transactionStatus?: string | undefined;
@@ -184,10 +254,10 @@ declare class Transaction {
     readonly billingAddress: TransactionAddress;
     readonly shippingAddress: TransactionAddress;
     constructor(transactionType?: string | undefined, transactionStatus?: string | undefined, transactionStatusDescription?: string | undefined, transactionNumber?: string | undefined, transactionDate?: string | undefined, fundDate?: string | undefined, settleDate?: string | undefined, amount?: string | undefined, description?: string | undefined, statusCode?: string | undefined, statusText?: string | undefined, email?: string | undefined, phone?: string | undefined, customerUuid?: string | undefined, multiUseToken?: string | undefined, pending?: boolean, transactionInfoId?: string | undefined, parentTransactionInfoId?: string | undefined, billingAddress?: TransactionAddress, shippingAddress?: TransactionAddress);
-    static fromRaw(data: Raw$o): Transaction;
+    static fromRaw(data: Raw$F): Transaction;
 }
 
-type Raw$n = Record<string, unknown>;
+type Raw$E = Record<string, unknown>;
 declare class DepositWithTransactions {
     readonly sid?: string | undefined;
     readonly transactionInfoId?: string | undefined;
@@ -199,26 +269,245 @@ declare class DepositWithTransactions {
     readonly transTotal?: string | undefined;
     readonly transactions: Transaction[];
     constructor(sid?: string | undefined, transactionInfoId?: string | undefined, transactionId?: string | undefined, transactionDate?: string | undefined, fundDate?: string | undefined, type?: string | undefined, countOfTransactions?: number | undefined, transTotal?: string | undefined, transactions?: Transaction[]);
-    static fromRaw(data: Raw$n): DepositWithTransactions;
+    static fromRaw(data: Raw$E): DepositWithTransactions;
 }
 
-type Raw$m = Record<string, unknown>;
+type Raw$D = Record<string, unknown>;
 declare class DepositGroup {
     readonly sid?: string | undefined;
     readonly count?: number | undefined;
     readonly deposits: DepositWithTransactions[];
     constructor(sid?: string | undefined, count?: number | undefined, deposits?: DepositWithTransactions[]);
-    static fromRaw(data: Raw$m): DepositGroup;
+    static fromRaw(data: Raw$D): DepositGroup;
 }
 
-type Raw$l = Record<string, unknown>;
+type Raw$C = Record<string, unknown>;
 declare class Deposits extends AbstractResource {
-    list(sid: string, filters?: Raw$l): Promise<CursorPage<Deposit>>;
-    listWithTransactions(sid: string, filters: Raw$l): Promise<DepositGroup>;
-    show(sid: string, identifier: Raw$l): Promise<DepositWithTransactions>;
+    list(sid: string, filters?: Raw$C): Promise<CursorPage<Deposit>>;
+    listWithTransactions(sid: string, filters: Raw$C): Promise<DepositGroup>;
+    show(sid: string, identifier: Raw$C): Promise<DepositWithTransactions>;
 }
 
-type Raw$k = Record<string, unknown>;
+type Raw$B = Record<string, unknown>;
+declare class DocumentUploadFailure {
+    readonly fileName?: string | undefined;
+    readonly reason?: string | undefined;
+    constructor(fileName?: string | undefined, reason?: string | undefined);
+    static fromRaw(data: Raw$B): DocumentUploadFailure;
+}
+
+type Raw$A = Record<string, unknown>;
+/**
+ * A document held for a merchant. Named `MerchantDocument` rather than
+ * `Document` so it does not shadow the DOM's global `Document` type.
+ *
+ * The upload response carries only `uuid`, `fileName`, `docType` and `size`;
+ * the list response fills in the rest. `sentToProcessorAt` and
+ * `processorResponse` stay undefined until our team forwards the document.
+ */
+declare class MerchantDocument {
+    readonly uuid?: string | undefined;
+    readonly fileName?: string | undefined;
+    readonly docType?: string | undefined;
+    readonly chargebackTransactionInfoId?: string | undefined;
+    readonly size?: number | undefined;
+    readonly uploadedAt?: string | undefined;
+    readonly uploadedVia?: string | undefined;
+    readonly sentToProcessorAt?: string | undefined;
+    readonly processorResponse?: string | undefined;
+    constructor(uuid?: string | undefined, fileName?: string | undefined, docType?: string | undefined, chargebackTransactionInfoId?: string | undefined, size?: number | undefined, uploadedAt?: string | undefined, uploadedVia?: string | undefined, sentToProcessorAt?: string | undefined, processorResponse?: string | undefined);
+    static fromRaw(data: Raw$A): MerchantDocument;
+}
+
+type Raw$z = Record<string, unknown>;
+/**
+ * The outcome of a document upload. Files are stored independently, so a
+ * request can partly succeed: `documents` lists what was stored and `failed`
+ * what was not, so only the failures need re-sending.
+ */
+declare class DocumentUploadResult {
+    readonly message?: string | undefined;
+    readonly documents: MerchantDocument[];
+    readonly failed: DocumentUploadFailure[];
+    constructor(message?: string | undefined, documents?: MerchantDocument[], failed?: DocumentUploadFailure[]);
+    static fromRaw(data: Raw$z): DocumentUploadResult;
+}
+
+type Raw$y = Record<string, unknown>;
+/**
+ * A file to upload: a `Blob` or `File`, or raw bytes (a Node `Buffer` from
+ * `fs.readFile`, say) with a file name. A bare `Blob` without a name is sent
+ * as `document`. The server identifies the type from the content, so
+ * `contentType` is optional.
+ */
+type DocumentFile = Blob | {
+    content: Blob | ArrayBuffer | Uint8Array;
+    filename: string;
+    contentType?: string;
+};
+/**
+ * Documents held for a merchant: underwriting paperwork, identity
+ * verification, and evidence contesting a chargeback.
+ */
+declare class Documents extends AbstractResource {
+    /**
+     * Upload up to 10 documents for a merchant (PDF, JPG, PNG, DOC, DOCX or RTF,
+     * each 9 MB or smaller). Sent as `multipart/form-data`.
+     *
+     * Files are stored independently: check `failed` on the result and re-send
+     * only those. A 413 means the request as a whole was too large — send fewer
+     * files per request.
+     *
+     * Uploading does not forward the document to the processor; our team
+     * reviews it and does that.
+     *
+     * @param docType `Verification`, `FraudHolds`, `Underwriting` or
+     *   `RetrievalRequest` (evidence for a chargeback or retrieval request)
+     * @param chargebackTransactionInfoId attach the files as evidence to this
+     *   chargeback (its `transactionInfoId`)
+     */
+    upload(sid: string, docType: string, files: DocumentFile[], chargebackTransactionInfoId?: string): Promise<DocumentUploadResult>;
+    /**
+     * List the documents held for a merchant, whether uploaded through the API,
+     * by our team, or through the merchant application.
+     *
+     * @param filters `doc_type`, `chargeback_transaction_info_id`
+     */
+    list(sid: string, filters?: Raw$y): Promise<MerchantDocument[]>;
+}
+
+type Raw$x = Record<string, unknown>;
+/**
+ * A release of held funds to the merchant's bank account.
+ *
+ * `status` is `released`, `failed` (declined, nothing moved — see
+ * `failureReason`) or `unknown` (no confirmation came back; it may have gone
+ * through, and its amount is held back from `releasable` until reconciled).
+ * `transactionInfoIds` is empty for a release requested by amount.
+ */
+declare class FundRelease {
+    readonly id?: number | undefined;
+    readonly amount?: string | undefined;
+    readonly fee?: string | undefined;
+    readonly status?: string | undefined;
+    readonly statusLabel?: string | undefined;
+    readonly idempotencyKey?: string | undefined;
+    readonly transactionInfoIds: string[];
+    readonly failureReason?: string | undefined;
+    readonly requestedAt?: string | undefined;
+    readonly completedAt?: string | undefined;
+    constructor(id?: number | undefined, amount?: string | undefined, fee?: string | undefined, status?: string | undefined, statusLabel?: string | undefined, idempotencyKey?: string | undefined, transactionInfoIds?: string[], failureReason?: string | undefined, requestedAt?: string | undefined, completedAt?: string | undefined);
+    static fromRaw(data: Raw$x): FundRelease;
+}
+
+type Raw$w = Record<string, unknown>;
+/**
+ * The response to a release request. `replayed` is true when the idempotency
+ * key had been used before and the original release is being returned rather
+ * than a new one sent.
+ */
+declare class FundReleaseResult {
+    readonly sid?: string | undefined;
+    readonly replayed: boolean;
+    readonly release: FundRelease;
+    constructor(sid?: string | undefined, replayed?: boolean, release?: FundRelease);
+    static fromRaw(data: Raw$w): FundReleaseResult;
+}
+
+type Raw$v = Record<string, unknown>;
+/**
+ * A held-funds merchant's balance at the processor, in dollars.
+ *
+ * `releasable` is the figure that matters, and the one a release is checked
+ * against: `available` less `atRisk`, `owedToSplit`, `unresolved` and
+ * `releaseFee`, never below zero and never above `achOutLimitRemaining`.
+ *
+ * Monetary values are kept as strings to avoid float rounding.
+ */
+declare class HeldBalance {
+    readonly sid?: string | undefined;
+    readonly available?: string | undefined;
+    readonly pending?: string | undefined;
+    readonly reserve?: string | undefined;
+    readonly atRisk?: string | undefined;
+    readonly owedToSplit?: string | undefined;
+    readonly unresolved?: string | undefined;
+    readonly releaseFee?: string | undefined;
+    readonly releasable?: string | undefined;
+    readonly achSettlementDays?: number | undefined;
+    readonly achOutEnabled: boolean;
+    readonly achOutLimitRemaining?: string | undefined;
+    constructor(sid?: string | undefined, available?: string | undefined, pending?: string | undefined, reserve?: string | undefined, atRisk?: string | undefined, owedToSplit?: string | undefined, unresolved?: string | undefined, releaseFee?: string | undefined, releasable?: string | undefined, achSettlementDays?: number | undefined, achOutEnabled?: boolean, achOutLimitRemaining?: string | undefined);
+    static fromRaw(data: Raw$v): HeldBalance;
+}
+
+type Raw$u = Record<string, unknown>;
+/**
+ * A payment that can be released from a held balance. `amount` is what
+ * releasing it pays the merchant: `netAmount` less `splitAmount`.
+ */
+declare class ReleasableTransaction {
+    readonly transactionInfoId?: string | undefined;
+    readonly type?: string | undefined;
+    readonly transactionDate?: string | undefined;
+    readonly grossAmount?: string | undefined;
+    readonly netAmount?: string | undefined;
+    readonly splitAmount?: string | undefined;
+    readonly amount?: string | undefined;
+    constructor(transactionInfoId?: string | undefined, type?: string | undefined, transactionDate?: string | undefined, grossAmount?: string | undefined, netAmount?: string | undefined, splitAmount?: string | undefined, amount?: string | undefined);
+    static fromRaw(data: Raw$u): ReleasableTransaction;
+}
+
+type Raw$t = Record<string, unknown>;
+/**
+ * The payments releasable right now, newest first and capped at 500 —
+ * `truncated` says whether there were more.
+ */
+declare class ReleasableTransactions {
+    readonly sid?: string | undefined;
+    readonly transactions: ReleasableTransaction[];
+    readonly total?: string | undefined;
+    readonly truncated: boolean;
+    constructor(sid?: string | undefined, transactions?: ReleasableTransaction[], total?: string | undefined, truncated?: boolean);
+    static fromRaw(data: Raw$t): ReleasableTransactions;
+}
+
+type Raw$s = Record<string, unknown>;
+/**
+ * Held funds, for merchants on a tier that does not sweep their balance to
+ * their bank automatically. Every other merchant gets a 422 from these
+ * endpoints rather than a misleading zero.
+ *
+ * Reading needs `funds:read`. Releasing needs `funds:release`, a separate
+ * ability, and is open to affiliate keys only.
+ */
+declare class Funds extends AbstractResource {
+    /** The merchant's balance at the processor, and how much is releasable today. */
+    balance(sid: string): Promise<HeldBalance>;
+    /** The payments that can be released right now — the list to release by `transaction_info_ids`. */
+    transactions(sid: string): Promise<ReleasableTransactions>;
+    /**
+     * Send part of a merchant's held balance to the bank account on file.
+     *
+     * Use a fresh `idempotencyKey` per intended release and reuse it when
+     * retrying: a retry with the same key and request returns the original
+     * release instead of sending the money again. The SDK's own retries of
+     * timeouts and 5xx responses resend the same key, so they are safe.
+     *
+     * Check `release.status`, not only whether this resolved. A declined release
+     * (`failed`) is returned rather than thrown, alongside `released` and
+     * `unknown`. Refusals that create no release — a transaction that does not
+     * qualify, more than is releasable, a key reused for a different request, a
+     * release already in flight — throw an {@link ApiException} whose response
+     * body carries the detail (`data.ineligible`, `data.releasable`).
+     *
+     * @param attributes exactly one of `amount` (dollars, at most two decimal
+     *   places) or `transaction_info_ids` (up to 100, all or nothing)
+     */
+    release(sid: string, idempotencyKey: string, attributes: Raw$s): Promise<FundReleaseResult>;
+}
+
+type Raw$r = Record<string, unknown>;
 /**
  * The processing fee a cover-fee invoice adds on top of what the customer pays,
  * quoted for both payment methods.
@@ -244,29 +533,29 @@ declare class CoverFeeQuote {
     readonly achFee?: string | undefined;
     readonly achTotal?: string | undefined;
     constructor(basis?: string | undefined, base?: string | undefined, ccFee?: string | undefined, ccTotal?: string | undefined, achFee?: string | undefined, achTotal?: string | undefined);
-    static fromRaw(data: Raw$k): CoverFeeQuote;
+    static fromRaw(data: Raw$r): CoverFeeQuote;
 }
 
-type Raw$j = Record<string, unknown>;
+type Raw$q = Record<string, unknown>;
 declare class InvoiceCustomer {
     readonly id?: number | undefined;
     readonly name?: string | undefined;
     readonly email?: string | undefined;
     constructor(id?: number | undefined, name?: string | undefined, email?: string | undefined);
-    static fromRaw(data: Raw$j): InvoiceCustomer;
+    static fromRaw(data: Raw$q): InvoiceCustomer;
 }
 
-type Raw$i = Record<string, unknown>;
+type Raw$p = Record<string, unknown>;
 declare class InvoiceEvent {
     readonly type?: string | undefined;
     readonly label?: string | undefined;
     readonly description?: string | undefined;
     readonly createdAt?: string | undefined;
     constructor(type?: string | undefined, label?: string | undefined, description?: string | undefined, createdAt?: string | undefined);
-    static fromRaw(data: Raw$i): InvoiceEvent;
+    static fromRaw(data: Raw$p): InvoiceEvent;
 }
 
-type Raw$h = Record<string, unknown>;
+type Raw$o = Record<string, unknown>;
 declare class InvoiceLineItem {
     readonly id?: number | undefined;
     readonly itemId?: number | undefined;
@@ -276,10 +565,10 @@ declare class InvoiceLineItem {
     readonly unitPrice?: string | undefined;
     readonly amount?: string | undefined;
     constructor(id?: number | undefined, itemId?: number | undefined, name?: string | undefined, description?: string | undefined, quantity?: string | undefined, unitPrice?: string | undefined, amount?: string | undefined);
-    static fromRaw(data: Raw$h): InvoiceLineItem;
+    static fromRaw(data: Raw$o): InvoiceLineItem;
 }
 
-type Raw$g = Record<string, unknown>;
+type Raw$n = Record<string, unknown>;
 /**
  * A payment recorded against an invoice.
  *
@@ -294,10 +583,10 @@ declare class InvoicePayment {
     readonly transactionId?: string | undefined;
     readonly coverFee?: string | undefined;
     constructor(amount?: string | undefined, paidAt?: string | undefined, method?: string | undefined, transactionId?: string | undefined, coverFee?: string | undefined);
-    static fromRaw(data: Raw$g): InvoicePayment;
+    static fromRaw(data: Raw$n): InvoicePayment;
 }
 
-type Raw$f = Record<string, unknown>;
+type Raw$m = Record<string, unknown>;
 declare class Invoice {
     readonly id?: number | undefined;
     readonly invoiceNumber?: string | undefined;
@@ -323,10 +612,10 @@ declare class Invoice {
     readonly coverFeeRequired: boolean;
     readonly coverFeeQuote?: CoverFeeQuote | undefined;
     constructor(id?: number | undefined, invoiceNumber?: string | undefined, status?: string | undefined, token?: string | undefined, paymentTerms?: string | undefined, issueDate?: string | undefined, dueDate?: string | undefined, isOverdue?: boolean, subtotal?: string | undefined, total?: string | undefined, amountPaid?: string | undefined, balance?: string | undefined, allowPartialPayment?: boolean, thankYouNote?: string | undefined, customerName?: string | undefined, customerEmail?: string | undefined, publicUrl?: string | undefined, customer?: InvoiceCustomer, items?: InvoiceLineItem[], payments?: InvoicePayment[], events?: InvoiceEvent[], coverFeeRequired?: boolean, coverFeeQuote?: CoverFeeQuote | undefined);
-    static fromRaw(data: Raw$f): Invoice;
+    static fromRaw(data: Raw$m): Invoice;
 }
 
-type Raw$e = Record<string, unknown>;
+type Raw$l = Record<string, unknown>;
 declare class InvoiceItem {
     readonly id?: number | undefined;
     readonly name?: string | undefined;
@@ -334,18 +623,18 @@ declare class InvoiceItem {
     readonly price?: string | undefined;
     readonly taxDeductible: boolean;
     constructor(id?: number | undefined, name?: string | undefined, description?: string | undefined, price?: string | undefined, taxDeductible?: boolean);
-    static fromRaw(data: Raw$e): InvoiceItem;
+    static fromRaw(data: Raw$l): InvoiceItem;
 }
 
-type Raw$d = Record<string, unknown>;
+type Raw$k = Record<string, unknown>;
 declare class InvoiceLink {
     readonly publicUrl?: string | undefined;
     readonly token?: string | undefined;
     constructor(publicUrl?: string | undefined, token?: string | undefined);
-    static fromRaw(data: Raw$d): InvoiceLink;
+    static fromRaw(data: Raw$k): InvoiceLink;
 }
 
-type Raw$c = Record<string, unknown>;
+type Raw$j = Record<string, unknown>;
 /**
  * Invoice endpoints.
  *
@@ -361,9 +650,9 @@ declare class Invoices extends AbstractResource {
     /**
      * List invoices for a merchant.
      *
-     * @param filters `status` — draft | sent | paid | partial | void | overdue
+     * @param filters `status` — draft | sent | viewed | partially_paid | paid | void | refunded | overdue | all
      */
-    list(sid: string, filters?: Raw$c): Promise<CursorPage<Invoice>>;
+    list(sid: string, filters?: Raw$j): Promise<CursorPage<Invoice>>;
     show(sid: string, invoiceId: number | string): Promise<Invoice>;
     /**
      * Create a draft invoice with its line items. Every line must reference a
@@ -384,14 +673,14 @@ declare class Invoices extends AbstractResource {
      *   `invoice.coverFeeQuote` for what the customer will actually be charged.
      *   Omitting the field inherits the merchant's invoice setting.
      */
-    create(sid: string, attributes: Raw$c): Promise<Invoice>;
+    create(sid: string, attributes: Raw$j): Promise<Invoice>;
     /**
      * Update a draft invoice. Only drafts can be edited, and passing `lines`
      * replaces the existing line items.
      *
      * @param attributes same shape as {@link Invoices.create}
      */
-    update(sid: string, invoiceId: number | string, attributes: Raw$c): Promise<Invoice>;
+    update(sid: string, invoiceId: number | string, attributes: Raw$j): Promise<Invoice>;
     delete(sid: string, invoiceId: number | string): Promise<MessageResult>;
     /** Email the invoice to the customer and advance it to Sent. */
     send(sid: string, invoiceId: number | string): Promise<Invoice>;
@@ -418,7 +707,7 @@ declare class Invoices extends AbstractResource {
      *   `invoice.payments`. Card and ACH rates differ, so the same `amount` settles
      *   differently per `payment_type`.
      */
-    pay(sid: string, invoiceId: number | string, attributes: Raw$c): Promise<Invoice>;
+    pay(sid: string, invoiceId: number | string, attributes: Raw$j): Promise<Invoice>;
     /** Get the public pay link (and token) for an invoice. */
     getLink(sid: string, invoiceId: number | string): Promise<InvoiceLink>;
     /**
@@ -427,14 +716,14 @@ declare class Invoices extends AbstractResource {
      * @param attributes `item_id`, `name`, `quantity` and `unit_price` are
      *   required; `description` is optional.
      */
-    addLineItem(sid: string, invoiceId: number | string, attributes: Raw$c): Promise<Invoice>;
+    addLineItem(sid: string, invoiceId: number | string, attributes: Raw$j): Promise<Invoice>;
     /**
      * Update a single line item on a draft invoice.
      *
      * @param attributes any of `item_id`, `name`, `description`, `quantity`,
      *   `unit_price`
      */
-    updateLineItem(sid: string, invoiceId: number | string, lineItemId: number | string, attributes: Raw$c): Promise<Invoice>;
+    updateLineItem(sid: string, invoiceId: number | string, lineItemId: number | string, attributes: Raw$j): Promise<Invoice>;
     /** Remove a single line item from a draft invoice. */
     deleteLineItem(sid: string, invoiceId: number | string, lineItemId: number | string): Promise<Invoice>;
     /** List the Merchant's items (funds/designations) available as invoice line items. */
@@ -447,17 +736,43 @@ declare class Invoices extends AbstractResource {
      * @param attributes `name` is required; `description`, `price` and
      *   `tax_deductible` are optional.
      */
-    createItem(sid: string, attributes: Raw$c): Promise<InvoiceItem>;
+    createItem(sid: string, attributes: Raw$j): Promise<InvoiceItem>;
 }
 
-type Raw$b = Record<string, unknown>;
+type Raw$i = Record<string, unknown>;
+/**
+ * Where a merchant sits in onboarding.
+ *
+ * `status` is the headline: `lead`, `discovery`, `proposal`,
+ * `application_in_progress`, `underwriting`, `live`, `cancellation_pending`,
+ * `churned` or `declined`, or undefined for a merchant that has not started.
+ * `applicationStatus` is the application record's own state — `draft`,
+ * `pending_review`, `submitted`, `approved`, `needs_documents` or `failed` —
+ * and is the field to read while `status` is `underwriting`, since only
+ * `needs_documents` asks anything of the merchant.
+ *
+ * `boarded` is the ground truth for "can they take money": a merchant can be
+ * `live` without the application ever reading `approved`.
+ */
+declare class ApplicationStatus {
+    readonly sid?: string | undefined;
+    readonly name?: string | undefined;
+    readonly status?: string | undefined;
+    readonly applicationStatus?: string | undefined;
+    readonly boarded: boolean;
+    readonly applicationSubmittedAt?: string | undefined;
+    constructor(sid?: string | undefined, name?: string | undefined, status?: string | undefined, applicationStatus?: string | undefined, boarded?: boolean, applicationSubmittedAt?: string | undefined);
+    static fromRaw(data: Raw$i): ApplicationStatus;
+}
+
+type Raw$h = Record<string, unknown>;
 declare class FormLink {
     readonly link?: string | undefined;
     constructor(link?: string | undefined);
-    static fromRaw(data: Raw$b): FormLink;
+    static fromRaw(data: Raw$h): FormLink;
 }
 
-type Raw$a = Record<string, unknown>;
+type Raw$g = Record<string, unknown>;
 declare class Merchant {
     readonly name?: string | undefined;
     readonly sid?: string | undefined;
@@ -481,19 +796,25 @@ declare class Merchant {
     readonly primaryEmail?: string | undefined;
     readonly primaryName?: string | undefined;
     constructor(name?: string | undefined, sid?: string | undefined, mcc?: string | undefined, slug?: string | undefined, pubApiKey?: string | undefined, processorMid?: string | undefined, active?: boolean, activeAt?: string | undefined, gPay?: boolean, aPay?: boolean, pciCompliance?: boolean, website?: string | undefined, addr1?: string | undefined, addr2?: string | undefined, city?: string | undefined, state?: string | undefined, zip?: string | undefined, phone?: string | undefined, primaryPhone?: string | undefined, primaryEmail?: string | undefined, primaryName?: string | undefined);
-    static fromRaw(data: Raw$a): Merchant;
+    static fromRaw(data: Raw$g): Merchant;
 }
 
-type Raw$9 = Record<string, unknown>;
+type Raw$f = Record<string, unknown>;
 declare class Merchants extends AbstractResource {
-    list(filters?: Raw$9): Promise<CursorPage<Merchant>>;
+    list(filters?: Raw$f): Promise<CursorPage<Merchant>>;
     show(sid: string): Promise<Merchant>;
-    create(attributes: Raw$9): Promise<Merchant>;
-    update(sid: string, attributes: Raw$9): Promise<Merchant>;
+    create(attributes: Raw$f): Promise<Merchant>;
+    update(sid: string, attributes: Raw$f): Promise<Merchant>;
     getFormLink(sid: string): Promise<FormLink>;
+    /**
+     * Where the merchant sits in onboarding — follow up an application sent with
+     * {@link Merchants.getFormLink}. Prefer the `application_status_changed`
+     * webhook to polling; poll only to reconcile after an outage.
+     */
+    applicationStatus(sid: string): Promise<ApplicationStatus>;
 }
 
-type Raw$8 = Record<string, unknown>;
+type Raw$e = Record<string, unknown>;
 declare class PaymentMethod {
     readonly id?: number | undefined;
     readonly type?: string | undefined;
@@ -521,19 +842,19 @@ declare class PaymentMethod {
     readonly state?: string | undefined;
     readonly zip?: string | undefined;
     constructor(id?: number | undefined, type?: string | undefined, token?: string | undefined, firstName?: string | undefined, lastName?: string | undefined, ccNameOnCard?: string | undefined, ccLastFour?: string | undefined, ccExpirationDate?: string | undefined, ccBrand?: string | undefined, achBankAccountName?: string | undefined, achRoutingNumber?: string | undefined, achAccountNumber?: string | undefined, achOwnershipType?: string | undefined, achAccountType?: string | undefined, achBankName?: string | undefined, status?: string | undefined, statusDate?: string | undefined, enabled?: boolean, isDefault?: boolean, addr1?: string | undefined, addr2?: string | undefined, addr3?: string | undefined, city?: string | undefined, state?: string | undefined, zip?: string | undefined);
-    static fromRaw(data: Raw$8): PaymentMethod;
+    static fromRaw(data: Raw$e): PaymentMethod;
 }
 
-type Raw$7 = Record<string, unknown>;
+type Raw$d = Record<string, unknown>;
 declare class PaymentMethods extends AbstractResource {
-    list(sid: string, filters: Raw$7): Promise<CursorPage<PaymentMethod>>;
-    show(sid: string, paymentMethodId: number | string, filters: Raw$7): Promise<PaymentMethod>;
-    create(sid: string, attributes: Raw$7): Promise<PaymentMethod>;
-    update(sid: string, attributes: Raw$7): Promise<PaymentMethod>;
+    list(sid: string, filters: Raw$d): Promise<CursorPage<PaymentMethod>>;
+    show(sid: string, paymentMethodId: number | string, filters: Raw$d): Promise<PaymentMethod>;
+    create(sid: string, attributes: Raw$d): Promise<PaymentMethod>;
+    update(sid: string, attributes: Raw$d): Promise<PaymentMethod>;
     delete(sid: string, paymentMethodId: number | string, uuid: string): Promise<MessageResult>;
 }
 
-type Raw$6 = Record<string, unknown>;
+type Raw$c = Record<string, unknown>;
 declare class RecurringInvoice {
     readonly id?: number | undefined;
     readonly status?: string | undefined;
@@ -551,10 +872,10 @@ declare class RecurringInvoice {
     readonly invoices: Invoice[];
     readonly coverFeeRequired: boolean;
     constructor(id?: number | undefined, status?: string | undefined, recurrenceSchedule?: string | undefined, paymentTerms?: string | undefined, startDate?: string | undefined, endDate?: string | undefined, nextRunDate?: string | undefined, lastRunDate?: string | undefined, customerName?: string | undefined, thankYouNote?: string | undefined, customer?: InvoiceCustomer, items?: InvoiceLineItem[], upcomingRunDates?: string[], invoices?: Invoice[], coverFeeRequired?: boolean);
-    static fromRaw(data: Raw$6): RecurringInvoice;
+    static fromRaw(data: Raw$c): RecurringInvoice;
 }
 
-type Raw$5 = Record<string, unknown>;
+type Raw$b = Record<string, unknown>;
 /**
  * Recurring-invoice templates, which generate and send an invoice on a schedule.
  *
@@ -566,7 +887,7 @@ declare class RecurringInvoices extends AbstractResource {
      *
      * @param filters `status` — Active | Paused | Cancelled | Completed
      */
-    list(sid: string, filters?: Raw$5): Promise<CursorPage<RecurringInvoice>>;
+    list(sid: string, filters?: Raw$b): Promise<CursorPage<RecurringInvoice>>;
     show(sid: string, recurringInvoiceId: number | string): Promise<RecurringInvoice>;
     /**
      * Create a recurring-invoice template. When `recurring_start_date` is today the
@@ -583,11 +904,11 @@ declare class RecurringInvoices extends AbstractResource {
      *   `cover_fee_required` makes the customer cover the processing fee on every
      *   invoice this template generates.
      */
-    create(sid: string, attributes: Raw$5): Promise<RecurringInvoice>;
+    create(sid: string, attributes: Raw$b): Promise<RecurringInvoice>;
     cancel(sid: string, recurringInvoiceId: number | string): Promise<RecurringInvoice>;
 }
 
-type Raw$4 = Record<string, unknown>;
+type Raw$a = Record<string, unknown>;
 declare class RecurringPaymentMethod {
     readonly id?: number | undefined;
     readonly type?: string | undefined;
@@ -602,10 +923,10 @@ declare class RecurringPaymentMethod {
     readonly accountType?: string | undefined;
     readonly bankName?: string | undefined;
     constructor(id?: number | undefined, type?: string | undefined, lastFour?: string | undefined, expiration?: string | undefined, zip?: string | undefined, nameOnCard?: string | undefined, bankAccountName?: string | undefined, routingNumber?: string | undefined, accountNumber?: string | undefined, ownershipType?: string | undefined, accountType?: string | undefined, bankName?: string | undefined);
-    static fromRaw(data: Raw$4): RecurringPaymentMethod;
+    static fromRaw(data: Raw$a): RecurringPaymentMethod;
 }
 
-type Raw$3 = Record<string, unknown>;
+type Raw$9 = Record<string, unknown>;
 declare class RecurringPayment {
     readonly id?: number | undefined;
     readonly name?: string | undefined;
@@ -625,21 +946,174 @@ declare class RecurringPayment {
     readonly paymentMethod: RecurringPaymentMethod;
     readonly shippingAddress: TransactionAddress;
     constructor(id?: number | undefined, name?: string | undefined, amount?: string | undefined, startDate?: string | undefined, endDate?: string | undefined, recurrenceSchedule?: string | undefined, lastRunDate?: string | undefined, lastRunStatus?: string | undefined, lastRunFailedCount?: number | undefined, nextRunDate?: string | undefined, status?: string | undefined, pausedUntilDate?: string | undefined, customerUuid?: string | undefined, cancelledAt?: string | undefined, error?: string | undefined, paymentMethod?: RecurringPaymentMethod, shippingAddress?: TransactionAddress);
-    static fromRaw(data: Raw$3): RecurringPayment;
+    static fromRaw(data: Raw$9): RecurringPayment;
 }
 
-type Raw$2 = Record<string, unknown>;
+type Raw$8 = Record<string, unknown>;
 declare class RecurringPayments extends AbstractResource {
-    list(sid: string, filters?: Raw$2): Promise<CursorPage<RecurringPayment>>;
+    list(sid: string, filters?: Raw$8): Promise<CursorPage<RecurringPayment>>;
     show(sid: string, recurringPaymentId: number | string): Promise<RecurringPayment>;
-    create(sid: string, attributes: Raw$2): Promise<RecurringPayment>;
-    edit(sid: string, recurringPaymentId: number | string, attributes: Raw$2): Promise<RecurringPayment>;
+    create(sid: string, attributes: Raw$8): Promise<RecurringPayment>;
+    edit(sid: string, recurringPaymentId: number | string, attributes: Raw$8): Promise<RecurringPayment>;
     pause(sid: string, recurringPaymentId: number | string, pauseUntilDate?: string): Promise<RecurringPayment>;
     cancel(sid: string, recurringPaymentId: number | string): Promise<RecurringPayment>;
     activate(sid: string, recurringPaymentId: number | string): Promise<RecurringPayment>;
     delete(sid: string, recurringPaymentId: number | string): Promise<MessageResult>;
 }
 
+type Raw$7 = Record<string, unknown>;
+/** The subscription created by subscribing a customer, and its first charge. */
+declare class SubscribeResult {
+    readonly subscriptionId?: number | undefined;
+    readonly status?: string | undefined;
+    readonly nextRunDate?: string | undefined;
+    readonly transactionNumber?: string | undefined;
+    readonly amount?: string | undefined;
+    constructor(subscriptionId?: number | undefined, status?: string | undefined, nextRunDate?: string | undefined, transactionNumber?: string | undefined, amount?: string | undefined);
+    static fromRaw(data: Raw$7): SubscribeResult;
+}
+
+type Raw$6 = Record<string, unknown>;
+/**
+ * A line item on a subscription plan, or the snapshot a subscription took of
+ * it when the customer subscribed. `amount` is present on subscriptions only.
+ */
+declare class SubscriptionItem {
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly quantity?: string | undefined;
+    readonly unitPrice?: string | undefined;
+    readonly amount?: string | undefined;
+    constructor(name?: string | undefined, description?: string | undefined, quantity?: string | undefined, unitPrice?: string | undefined, amount?: string | undefined);
+    static fromRaw(data: Raw$6): SubscriptionItem;
+}
+
+type Raw$5 = Record<string, unknown>;
+/**
+ * A subscription plan. `status` is `draft`, `active` or `archived`; only an
+ * active plan takes new subscribers. `publicUrl` is the plan's hosted
+ * subscribe page.
+ */
+declare class SubscriptionPlan {
+    readonly id?: number | undefined;
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly recurrenceSchedule?: string | undefined;
+    readonly status?: string | undefined;
+    readonly subtotal?: string | undefined;
+    readonly total?: string | undefined;
+    readonly token?: string | undefined;
+    readonly publicUrl?: string | undefined;
+    readonly allowPublic: boolean;
+    readonly createdAt?: string | undefined;
+    readonly items: SubscriptionItem[];
+    constructor(id?: number | undefined, name?: string | undefined, description?: string | undefined, recurrenceSchedule?: string | undefined, status?: string | undefined, subtotal?: string | undefined, total?: string | undefined, token?: string | undefined, publicUrl?: string | undefined, allowPublic?: boolean, createdAt?: string | undefined, items?: SubscriptionItem[]);
+    static fromRaw(data: Raw$5): SubscriptionPlan;
+}
+
+type Raw$4 = Record<string, unknown>;
+/**
+ * Subscription plans: a recurring bundle of line items customers subscribe to.
+ *
+ * A plan is created as a `draft`, published to `active` to take subscribers,
+ * and archived to stop new ones. Existing subscribers keep the snapshot they
+ * subscribed to, so editing or archiving a plan never changes them.
+ */
+declare class SubscriptionPlans extends AbstractResource {
+    /**
+     * List a merchant's plans, newest first.
+     *
+     * @param status `draft`, `active` or `archived`
+     */
+    list(sid: string, status?: string): Promise<CursorPage<SubscriptionPlan>>;
+    show(sid: string, subscriptionPlanId: number | string): Promise<SubscriptionPlan>;
+    /**
+     * Create a plan as a draft. Publish it before customers can subscribe.
+     *
+     * @param attributes
+     *   `name`, `recurrence_schedule` (`Weekly` | `Biweekly` | `FirstFifteenth` |
+     *   `Monthly` | `Yearly`) and `lines` are required. `lines[]` takes
+     *   `item_id` (a Merchant item), `name`, `quantity`, `unit_price` and
+     *   optional `description`. Optional: `description`, `allow_public` (list
+     *   the plan in the public catalog).
+     */
+    create(sid: string, attributes: Raw$4): Promise<SubscriptionPlan>;
+    /**
+     * Replace a plan's fields and line items wholesale — send the full plan, not
+     * just what changed. Existing subscribers are unaffected.
+     *
+     * @param attributes same shape as {@link SubscriptionPlans.create}
+     */
+    edit(sid: string, subscriptionPlanId: number | string, attributes: Raw$4): Promise<SubscriptionPlan>;
+    /** Delete a plan with no subscribers. A plan that has any must be archived instead. */
+    delete(sid: string, subscriptionPlanId: number | string): Promise<MessageResult>;
+    /** Move a draft plan with at least one line item to active, so customers can subscribe. */
+    publish(sid: string, subscriptionPlanId: number | string): Promise<SubscriptionPlan>;
+    /** Stop new subscriptions and hide the plan from the public catalog. */
+    archive(sid: string, subscriptionPlanId: number | string): Promise<SubscriptionPlan>;
+    /**
+     * Move an archived plan back to draft, to review and re-publish.
+     * `allowPublic` stays off until the merchant opts back into the catalog.
+     */
+    unarchive(sid: string, subscriptionPlanId: number | string): Promise<SubscriptionPlan>;
+    /**
+     * Subscribe a customer to an active plan: charges the first payment to one
+     * of the customer's saved payment methods and enrolls them.
+     */
+    subscribe(sid: string, subscriptionPlanId: number | string, customerUuid: string, paymentMethodId: number | string): Promise<SubscribeResult>;
+}
+
+type Raw$3 = Record<string, unknown>;
+/**
+ * A customer's subscription to a plan. `status` is `Active`, `Failed`,
+ * `Paused`, `Cancelled` or `Ended`.
+ */
+declare class Subscription {
+    readonly id?: number | undefined;
+    readonly subscriptionPlanId?: number | undefined;
+    readonly planName?: string | undefined;
+    readonly amount?: string | undefined;
+    readonly recurrenceSchedule?: string | undefined;
+    readonly startDate?: string | undefined;
+    readonly endDate?: string | undefined;
+    readonly lastRunDate?: string | undefined;
+    readonly lastRunStatus?: string | undefined;
+    readonly lastRunFailedCount?: number | undefined;
+    readonly nextRunDate?: string | undefined;
+    readonly status?: string | undefined;
+    readonly pausedUntilDate?: string | undefined;
+    readonly cancelledAt?: string | undefined;
+    readonly cancelledBy?: string | undefined;
+    readonly customerUuid?: string | undefined;
+    readonly error?: string | undefined;
+    readonly paymentMethod: RecurringPaymentMethod;
+    readonly items: SubscriptionItem[];
+    constructor(id?: number | undefined, subscriptionPlanId?: number | undefined, planName?: string | undefined, amount?: string | undefined, recurrenceSchedule?: string | undefined, startDate?: string | undefined, endDate?: string | undefined, lastRunDate?: string | undefined, lastRunStatus?: string | undefined, lastRunFailedCount?: number | undefined, nextRunDate?: string | undefined, status?: string | undefined, pausedUntilDate?: string | undefined, cancelledAt?: string | undefined, cancelledBy?: string | undefined, customerUuid?: string | undefined, error?: string | undefined, paymentMethod?: RecurringPaymentMethod, items?: SubscriptionItem[]);
+    static fromRaw(data: Raw$3): Subscription;
+}
+
+type Raw$2 = Record<string, unknown>;
+/** Customers' subscriptions to subscription plans. */
+declare class Subscriptions extends AbstractResource {
+    /**
+     * List a merchant's subscriptions, newest first.
+     *
+     * @param filters `status` — Active | Failed | Paused | Cancelled | Ended;
+     *   `customer_uuid`
+     */
+    list(sid: string, filters?: Raw$2): Promise<CursorPage<Subscription>>;
+    show(sid: string, subscriptionId: number | string): Promise<Subscription>;
+    /**
+     * Pause a subscription until `pauseUntilDate` (Y-m-d, in the future), or
+     * indefinitely when it is omitted.
+     */
+    pause(sid: string, subscriptionId: number | string, pauseUntilDate?: string): Promise<Subscription>;
+    /** Reactivate a paused subscription and recompute its next charge date. */
+    resume(sid: string, subscriptionId: number | string): Promise<Subscription>;
+    /** Cancel a subscription permanently; no further charges are made. */
+    cancel(sid: string, subscriptionId: number | string): Promise<Subscription>;
+}
+
 type Raw$1 = Record<string, unknown>;
 declare class TokenizeResult {
     readonly token?: string | undefined;
@@ -656,6 +1130,26 @@ declare class Transactions extends AbstractResource {
     chargeCardToken(sid: string, attributes: Raw): Promise<Transaction>;
     chargeAch(sid: string, attributes: Raw): Promise<Transaction>;
     tokenizeCard(sid: string, attributes: Raw): Promise<TokenizeResult>;
+    /**
+     * Place a hold on a card without moving money. Pass a `token` or the raw
+     * card fields, as for {@link Transactions.chargeCard}.
+     *
+     * The returned `transactionNumber` is the handle on the authorization:
+     * collect it with {@link Transactions.capture}, or release the hold with
+     * {@link Transactions.void} (type `CC`). Capture promptly — the issuer
+     * releases an uncaptured hold on its own schedule.
+     */
+    authorize(sid: string, attributes: Raw): Promise<Transaction>;
+    /**
+     * Capture an authorization. Omit `amount` to capture the full authorized
+     * amount, or pass less to capture part of it.
+     *
+     * An authorization is captured once: a partial capture settles that amount
+     * and releases the rest to the cardholder.
+     *
+     * @param transactionId the `transactionNumber` returned by {@link Transactions.authorize}
+     */
+    capture(sid: string, transactionId: number | string, amount?: number | string): Promise<MessageResult>;
     refund(sid: string, attributes: Raw): Promise<MessageResult>;
     void(sid: string, transactionType: string, transactionId: number | string): Promise<MessageResult>;
 }
@@ -681,6 +1175,11 @@ declare class Client {
     readonly recurringPayments: RecurringPayments;
     readonly invoices: Invoices;
     readonly recurringInvoices: RecurringInvoices;
+    readonly chargebacks: Chargebacks;
+    readonly documents: Documents;
+    readonly funds: Funds;
+    readonly subscriptionPlans: SubscriptionPlans;
+    readonly subscriptions: Subscriptions;
     private readonly _config;
     constructor(token: string | Config, baseUrl?: string);
     config(): Config;
@@ -725,4 +1224,4 @@ declare class ServerException extends DimeException {
 declare class ConnectionException extends DimeException {
 }
 
-export { Address, ApiException, AuthenticationException, Client, Config, ConnectionException, CoverFeeQuote, CursorPage, Customer, DEFAULT_BASE_URL, Deposit, DepositGroup, DepositWithTransactions, DimeException, FormLink, Invoice, InvoiceCustomer, InvoiceEvent, InvoiceItem, InvoiceLineItem, InvoiceLink, InvoicePayment, Merchant, MessageResult, NotFoundException, PaymentMethod, PermissionDeniedException, RateLimitException, RecurringInvoice, RecurringPayment, RecurringPaymentMethod, ServerException, TokenizeResult, Transaction, TransactionAddress, VERSION, ValidationException };
+export { Address, ApiException, ApplicationStatus, AuthenticationException, Chargeback, Client, Config, ConnectionException, CoverFeeQuote, CursorPage, Customer, DEFAULT_BASE_URL, Deposit, DepositGroup, DepositWithTransactions, DimeException, type DocumentFile, DocumentUploadFailure, DocumentUploadResult, FormLink, FundRelease, FundReleaseResult, HeldBalance, Invoice, InvoiceCustomer, InvoiceEvent, InvoiceItem, InvoiceLineItem, InvoiceLink, InvoicePayment, Merchant, MerchantDocument, MessageResult, NotFoundException, PaymentMethod, PermissionDeniedException, RateLimitException, RecurringInvoice, RecurringPayment, RecurringPaymentMethod, ReleasableTransaction, ReleasableTransactions, ServerException, SubscribeResult, Subscription, SubscriptionItem, SubscriptionPlan, TokenizeResult, Transaction, TransactionAddress, VERSION, ValidationException };