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

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 declare const DEFAULT_BASE_URL = "https://app.dimepayments.com";
-declare const VERSION = "1.0.0";
+declare const VERSION = "1.3.0";
 interface ConfigOptions {
     /** Sanctum personal access token (sent as Bearer). */
     token: string;
@@ -28,7 +28,7 @@ declare class Config {
     baseUri(): string;
 }
 
-type Raw$m = Record<string, unknown>;
+type Raw$x = 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$m): Address;
+    static fromRaw(data: Raw$x): Address;
 }
 
-type Raw$l = Record<string, unknown>;
+type Raw$w = Record<string, unknown>;
 declare class MessageResult {
     readonly message?: string | undefined;
     constructor(message?: string | undefined);
-    static fromRaw(data: Raw$l): MessageResult;
+    static fromRaw(data: Raw$w): MessageResult;
 }
 
 type PageFetcher<T> = (cursor: string) => Promise<CursorPage<T>>;
@@ -66,7 +66,7 @@ declare class CursorPage<T> {
     get length(): number;
 }
 
-type Raw$k = Record<string, unknown>;
+type Raw$v = Record<string, unknown>;
 declare class Transport {
     private readonly config;
     private readonly fetchFn;
@@ -75,36 +75,38 @@ declare class Transport {
     /**
      * Execute a request and return the decoded JSON body.
      *
-     * The Dime API expects request parameters in the JSON body even for GET
-     * requests; this transport always sends the payload as a JSON body regardless
-     * of HTTP method, matching the server's expectation.
+     * The Dime API reads the same `{ data, filters }` envelope whether it arrives
+     * as a JSON body or as nested query parameters. The Fetch standard forbids a
+     * body on GET/HEAD (undici throws), so for those methods the envelope is
+     * 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$k, query?: Record<string, string>): Promise<Raw$k>;
+    request(method: string, path: string, body?: Raw$v, query?: Record<string, string>): Promise<Raw$v>;
     private attempt;
     private sleep;
 }
 
-type Raw$j = Record<string, unknown>;
+type Raw$u = 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$j, filters?: Raw$j): Raw$j;
-    protected paginate<T>(method: string, path: string, body: Raw$j, map: (item: Raw$j) => T, query?: Record<string, string>): Promise<CursorPage<T>>;
+    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>>;
 }
 
-type Raw$i = Record<string, unknown>;
+type Raw$t = 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$i): Promise<Address>;
-    update(sid: string, uuid: string, addressId: number | string, attributes: Raw$i): 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>;
     delete(sid: string, uuid: string, addressId: number | string): Promise<MessageResult>;
 }
 
-type Raw$h = Record<string, unknown>;
+type Raw$s = Record<string, unknown>;
 declare class Customer {
     readonly uuid?: string | undefined;
     readonly firstName?: string | undefined;
@@ -119,19 +121,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$h): Customer;
+    static fromRaw(data: Raw$s): Customer;
 }
 
-type Raw$g = Record<string, unknown>;
+type Raw$r = Record<string, unknown>;
 declare class Customers extends AbstractResource {
-    list(sid: string, filters?: Raw$g): Promise<CursorPage<Customer>>;
-    show(sid: string, filters: Raw$g): Promise<Customer>;
-    create(sid: string, attributes: Raw$g): Promise<Customer>;
-    update(sid: string, filters: Raw$g, attributes: Raw$g): Promise<Customer>;
-    delete(sid: string, filters: Raw$g): Promise<MessageResult>;
+    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>;
 }
 
-type Raw$f = Record<string, unknown>;
+type Raw$q = Record<string, unknown>;
 declare class Deposit {
     readonly transactionDate?: string | undefined;
     readonly fundDate?: string | undefined;
@@ -143,10 +145,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$f): Deposit;
+    static fromRaw(data: Raw$q): Deposit;
 }
 
-type Raw$e = Record<string, unknown>;
+type Raw$p = Record<string, unknown>;
 declare class TransactionAddress {
     readonly firstName?: string | undefined;
     readonly lastName?: string | undefined;
@@ -156,10 +158,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$e): TransactionAddress;
+    static fromRaw(data: Raw$p): TransactionAddress;
 }
 
-type Raw$d = Record<string, unknown>;
+type Raw$o = Record<string, unknown>;
 declare class Transaction {
     readonly transactionType?: string | undefined;
     readonly transactionStatus?: string | undefined;
@@ -182,10 +184,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$d): Transaction;
+    static fromRaw(data: Raw$o): Transaction;
 }
 
-type Raw$c = Record<string, unknown>;
+type Raw$n = Record<string, unknown>;
 declare class DepositWithTransactions {
     readonly sid?: string | undefined;
     readonly transactionInfoId?: string | undefined;
@@ -197,33 +199,265 @@ 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$c): DepositWithTransactions;
+    static fromRaw(data: Raw$n): DepositWithTransactions;
 }
 
-type Raw$b = Record<string, unknown>;
+type Raw$m = 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$b): DepositGroup;
+    static fromRaw(data: Raw$m): DepositGroup;
 }
 
-type Raw$a = Record<string, unknown>;
+type Raw$l = Record<string, unknown>;
 declare class Deposits extends AbstractResource {
-    list(sid: string, filters?: Raw$a): Promise<CursorPage<Deposit>>;
-    listWithTransactions(sid: string, filters: Raw$a): Promise<DepositGroup>;
-    show(sid: string, identifier: Raw$a): Promise<DepositWithTransactions>;
+    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>;
 }
 
-type Raw$9 = Record<string, unknown>;
+type Raw$k = Record<string, unknown>;
+/**
+ * The processing fee a cover-fee invoice adds on top of what the customer pays,
+ * quoted for both payment methods.
+ *
+ * Present on an {@link Invoice} only when `coverFeeRequired` is true. The fee is
+ * NOT a line item and is NOT part of the invoice's `total`: the merchant is owed
+ * `total`, and the customer is charged `total` plus this fee. Card and ACH rates
+ * differ, so the amount depends on how the customer chooses to pay — `ccTotal` is
+ * the higher of the two and what the invoice and its emails lead with.
+ *
+ * `basis` names what the quote was computed against — currently always `balance`,
+ * the amount still outstanding. Paying a partial amount re-quotes the fee against
+ * that amount, so treat these as a quote for settling in full today rather than a
+ * fixed charge.
+ *
+ * Monetary values are kept as strings to avoid float rounding.
+ */
+declare class CoverFeeQuote {
+    readonly basis?: string | undefined;
+    readonly base?: string | undefined;
+    readonly ccFee?: string | undefined;
+    readonly ccTotal?: string | undefined;
+    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;
+}
+
+type Raw$j = 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;
+}
+
+type Raw$i = 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;
+}
+
+type Raw$h = Record<string, unknown>;
+declare class InvoiceLineItem {
+    readonly id?: number | undefined;
+    readonly itemId?: number | undefined;
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly quantity?: string | undefined;
+    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;
+}
+
+type Raw$g = Record<string, unknown>;
+/**
+ * A payment recorded against an invoice.
+ *
+ * `amount` is what was credited to the invoice; `coverFee` is the processing fee
+ * charged on top of it, so `amount + coverFee` is what the customer actually paid.
+ * It is zero unless the invoice required the customer to cover fees.
+ */
+declare class InvoicePayment {
+    readonly amount?: string | undefined;
+    readonly paidAt?: string | undefined;
+    readonly method?: string | undefined;
+    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;
+}
+
+type Raw$f = Record<string, unknown>;
+declare class Invoice {
+    readonly id?: number | undefined;
+    readonly invoiceNumber?: string | undefined;
+    readonly status?: string | undefined;
+    readonly token?: string | undefined;
+    readonly paymentTerms?: string | undefined;
+    readonly issueDate?: string | undefined;
+    readonly dueDate?: string | undefined;
+    readonly isOverdue: boolean;
+    readonly subtotal?: string | undefined;
+    readonly total?: string | undefined;
+    readonly amountPaid?: string | undefined;
+    readonly balance?: string | undefined;
+    readonly allowPartialPayment: boolean;
+    readonly thankYouNote?: string | undefined;
+    readonly customerName?: string | undefined;
+    readonly customerEmail?: string | undefined;
+    readonly publicUrl?: string | undefined;
+    readonly customer: InvoiceCustomer;
+    readonly items: InvoiceLineItem[];
+    readonly payments: InvoicePayment[];
+    readonly events: InvoiceEvent[];
+    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;
+}
+
+type Raw$e = Record<string, unknown>;
+declare class InvoiceItem {
+    readonly id?: number | undefined;
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    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;
+}
+
+type Raw$d = 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;
+}
+
+type Raw$c = Record<string, unknown>;
+/**
+ * Invoice endpoints.
+ *
+ * Identify the customer with `customer_uuid` — the same identifier the customer,
+ * payment-method and address endpoints use, and the only one `Customer` exposes.
+ * `customer_id` remains accepted for integrations written against the original
+ * contract; supply exactly one.
+ *
+ * Line-item mutations return the refreshed invoice so the caller sees
+ * recalculated totals rather than a detached fragment.
+ */
+declare class Invoices extends AbstractResource {
+    /**
+     * List invoices for a merchant.
+     *
+     * @param filters `status` — draft | sent | paid | partial | void | overdue
+     */
+    list(sid: string, filters?: Raw$c): Promise<CursorPage<Invoice>>;
+    show(sid: string, invoiceId: number | string): Promise<Invoice>;
+    /**
+     * Create a draft invoice with its line items. Every line must reference a
+     * Merchant `item_id`; the line name and unit price are snapshotted.
+     *
+     * @param attributes
+     *   `customer_uuid` (or `customer_id`), `customer_name`, `customer_email`,
+     *   `payment_terms` (`due_on_receipt` | `net_15` | `net_30` | `net_60`) and
+     *   `lines` are required. `lines[]` takes `item_id`, `name`, `quantity`,
+     *   `unit_price` and optional `description`. Optional: `invoice_number`,
+     *   `issue_date` (Y-m-d, defaults to today — `due_date` is derived from
+     *   `payment_terms`), `thank_you_note`, `allow_partial_payment`,
+     *   `cover_fee_required`, `reminder_settings`.
+     *
+     *   Set `cover_fee_required` to make the customer pay the processing fee. The
+     *   fee is added on top of the invoice at payment time rather than becoming a
+     *   line item, so `total` stays the amount owed to the merchant — read
+     *   `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>;
+    /**
+     * 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>;
+    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>;
+    /** Activate a draft invoice for payment without emailing it. */
+    markSent(sid: string, invoiceId: number | string): Promise<Invoice>;
+    void(sid: string, invoiceId: number | string): Promise<Invoice>;
+    /** Clone any invoice into a new draft with a freshly allocated number. */
+    duplicate(sid: string, invoiceId: number | string): Promise<Invoice>;
+    /**
+     * Record a merchant-initiated (MOTO) card or ACH payment against an open
+     * invoice.
+     *
+     * @param attributes
+     *   `payment_type` is required and is `cc` or `ach`. For a card, pass a stored
+     *   `token` or raw `cardholder_name` / `card_number` / `expiration_date` (m/Y)
+     *   plus optional `cvv`; for ACH, pass `routing_number` / `account_number` /
+     *   `account_type` (Checking | Savings) / `account_name`. Omit `amount` to pay
+     *   the full balance — partial amounts require the invoice to allow them.
+     *   Optional: `memo`, `billing_address`.
+     *
+     *   On a cover-fee invoice the processing fee for `payment_type` is charged on
+     *   top of `amount`, so the card or bank account is debited more than the
+     *   invoice is credited. The fee lands as `coverFee` on the matching entry in
+     *   `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>;
+    /** Get the public pay link (and token) for an invoice. */
+    getLink(sid: string, invoiceId: number | string): Promise<InvoiceLink>;
+    /**
+     * Append a single line item to a draft invoice.
+     *
+     * @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>;
+    /**
+     * 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>;
+    /** 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. */
+    listItems(sid: string): Promise<InvoiceItem[]>;
+    /**
+     * Create an invoicing-only item (fund/designation) for the Merchant. The item
+     * is hidden from public giving pages and can be referenced as a line's
+     * `item_id`.
+     *
+     * @param attributes `name` is required; `description`, `price` and
+     *   `tax_deductible` are optional.
+     */
+    createItem(sid: string, attributes: Raw$c): Promise<InvoiceItem>;
+}
+
+type Raw$b = Record<string, unknown>;
 declare class FormLink {
     readonly link?: string | undefined;
     constructor(link?: string | undefined);
-    static fromRaw(data: Raw$9): FormLink;
+    static fromRaw(data: Raw$b): FormLink;
 }
 
-type Raw$8 = Record<string, unknown>;
+type Raw$a = Record<string, unknown>;
 declare class Merchant {
     readonly name?: string | undefined;
     readonly sid?: string | undefined;
@@ -247,19 +481,19 @@ 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$8): Merchant;
+    static fromRaw(data: Raw$a): Merchant;
 }
 
-type Raw$7 = Record<string, unknown>;
+type Raw$9 = Record<string, unknown>;
 declare class Merchants extends AbstractResource {
-    list(filters?: Raw$7): Promise<CursorPage<Merchant>>;
+    list(filters?: Raw$9): Promise<CursorPage<Merchant>>;
     show(sid: string): Promise<Merchant>;
-    create(attributes: Raw$7): Promise<Merchant>;
-    update(sid: string, attributes: Raw$7): Promise<Merchant>;
+    create(attributes: Raw$9): Promise<Merchant>;
+    update(sid: string, attributes: Raw$9): Promise<Merchant>;
     getFormLink(sid: string): Promise<FormLink>;
 }
 
-type Raw$6 = Record<string, unknown>;
+type Raw$8 = Record<string, unknown>;
 declare class PaymentMethod {
     readonly id?: number | undefined;
     readonly type?: string | undefined;
@@ -287,18 +521,72 @@ 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$6): PaymentMethod;
+    static fromRaw(data: Raw$8): PaymentMethod;
 }
 
-type Raw$5 = Record<string, unknown>;
+type Raw$7 = Record<string, unknown>;
 declare class PaymentMethods extends AbstractResource {
-    list(sid: string, filters: Raw$5): Promise<CursorPage<PaymentMethod>>;
-    show(sid: string, paymentMethodId: number | string, filters: Raw$5): Promise<PaymentMethod>;
-    create(sid: string, attributes: Raw$5): Promise<PaymentMethod>;
-    update(sid: string, attributes: Raw$5): Promise<PaymentMethod>;
+    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>;
     delete(sid: string, paymentMethodId: number | string, uuid: string): Promise<MessageResult>;
 }
 
+type Raw$6 = Record<string, unknown>;
+declare class RecurringInvoice {
+    readonly id?: number | undefined;
+    readonly status?: string | undefined;
+    readonly recurrenceSchedule?: string | undefined;
+    readonly paymentTerms?: string | undefined;
+    readonly startDate?: string | undefined;
+    readonly endDate?: string | undefined;
+    readonly nextRunDate?: string | undefined;
+    readonly lastRunDate?: string | undefined;
+    readonly customerName?: string | undefined;
+    readonly thankYouNote?: string | undefined;
+    readonly customer: InvoiceCustomer;
+    readonly items: InvoiceLineItem[];
+    readonly upcomingRunDates: string[];
+    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;
+}
+
+type Raw$5 = Record<string, unknown>;
+/**
+ * Recurring-invoice templates, which generate and send an invoice on a schedule.
+ *
+ * Identify the customer with `customer_uuid`; `customer_id` remains accepted.
+ */
+declare class RecurringInvoices extends AbstractResource {
+    /**
+     * List recurring-invoice templates.
+     *
+     * @param filters `status` — Active | Paused | Cancelled | Completed
+     */
+    list(sid: string, filters?: Raw$5): Promise<CursorPage<RecurringInvoice>>;
+    show(sid: string, recurringInvoiceId: number | string): Promise<RecurringInvoice>;
+    /**
+     * Create a recurring-invoice template. When `recurring_start_date` is today the
+     * first invoice is generated and sent immediately.
+     *
+     * @param attributes
+     *   `customer_uuid` (or `customer_id`), `payment_terms` (`due_on_receipt` |
+     *   `net_15` | `net_30` | `net_60`), `recurring_frequency` (`Weekly` |
+     *   `Biweekly` | `FirstFifteenth` | `Monthly` | `Yearly`),
+     *   `recurring_start_date` (Y-m-d) and `lines` are required. Optional:
+     *   `recurring_end_date` (Y-m-d, on or after the start date),
+     *   `thank_you_note`.
+     *
+     *   `cover_fee_required` makes the customer cover the processing fee on every
+     *   invoice this template generates.
+     */
+    create(sid: string, attributes: Raw$5): Promise<RecurringInvoice>;
+    cancel(sid: string, recurringInvoiceId: number | string): Promise<RecurringInvoice>;
+}
+
 type Raw$4 = Record<string, unknown>;
 declare class RecurringPaymentMethod {
     readonly id?: number | undefined;
@@ -391,6 +679,8 @@ declare class Client {
     readonly addresses: Addresses;
     readonly deposits: Deposits;
     readonly recurringPayments: RecurringPayments;
+    readonly invoices: Invoices;
+    readonly recurringInvoices: RecurringInvoices;
     private readonly _config;
     constructor(token: string | Config, baseUrl?: string);
     config(): Config;
@@ -435,4 +725,4 @@ declare class ServerException extends DimeException {
 declare class ConnectionException extends DimeException {
 }
 
-export { Address, ApiException, AuthenticationException, Client, Config, ConnectionException, CursorPage, Customer, DEFAULT_BASE_URL, Deposit, DepositGroup, DepositWithTransactions, DimeException, FormLink, Merchant, MessageResult, NotFoundException, PaymentMethod, PermissionDeniedException, RateLimitException, RecurringPayment, RecurringPaymentMethod, ServerException, TokenizeResult, Transaction, TransactionAddress, VERSION, ValidationException };
+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 };