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

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/config.ts
 var DEFAULT_BASE_URL = "https://app.dimepayments.com";
-var VERSION = "1.3.1";
+var VERSION = "1.4.0";
 var Config = class {
   token;
   baseUrl;
@@ -184,11 +184,7 @@ var Transport = class {
       url += "?" + new URLSearchParams(params).toString();
     }
     const sendBody = !bodyless && Object.keys(body).length > 0;
-    const headers = {
-      Authorization: `Bearer ${this.config.token}`,
-      Accept: "application/json",
-      "X-Dime-Sdk": `dime-js-sdk/${VERSION}`
-    };
+    const headers = this.headers();
     if (sendBody) headers["Content-Type"] = "application/json";
     const init = {
       method,
@@ -197,6 +193,32 @@ var Transport = class {
     };
     return this.attempt(url, init, 0);
   }
+  /**
+   * 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.
+   */
+  async requestMultipart(method, path, body, files) {
+    const url = `${this.config.baseUri()}${path.replace(/^\//, "")}`;
+    const form = new FormData();
+    for (const [name, value] of Object.entries(flattenParams(body))) {
+      form.append(name, value);
+    }
+    for (const file of files) {
+      form.append(file.field, file.content, file.filename);
+    }
+    return this.attempt(url, { method, headers: this.headers(), body: form }, 0);
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.config.token}`,
+      Accept: "application/json",
+      "X-Dime-Sdk": `dime-js-sdk/${VERSION}`
+    };
+  }
   async attempt(url, init, attempt) {
     let response;
     try {
@@ -471,6 +493,103 @@ var Addresses = class extends AbstractResource {
   }
 };
 
+// src/data-objects/chargeback.ts
+var Chargeback = class _Chargeback {
+  constructor(transactionInfoId, parentTransactionInfoId, gatewayTransactionId, transactionNumber, invoiceNumber, chargebackDate, merchantChargebackDate, transactionAmount, chargebackAmount, cardBrand, ccLastFour, payeeName, daysToRepresent, representmentDate, merchantRepresentmentDate, representmentStatus, result, chargebackCode, chargebackResponseCode, resolved = false) {
+    this.transactionInfoId = transactionInfoId;
+    this.parentTransactionInfoId = parentTransactionInfoId;
+    this.gatewayTransactionId = gatewayTransactionId;
+    this.transactionNumber = transactionNumber;
+    this.invoiceNumber = invoiceNumber;
+    this.chargebackDate = chargebackDate;
+    this.merchantChargebackDate = merchantChargebackDate;
+    this.transactionAmount = transactionAmount;
+    this.chargebackAmount = chargebackAmount;
+    this.cardBrand = cardBrand;
+    this.ccLastFour = ccLastFour;
+    this.payeeName = payeeName;
+    this.daysToRepresent = daysToRepresent;
+    this.representmentDate = representmentDate;
+    this.merchantRepresentmentDate = merchantRepresentmentDate;
+    this.representmentStatus = representmentStatus;
+    this.result = result;
+    this.chargebackCode = chargebackCode;
+    this.chargebackResponseCode = chargebackResponseCode;
+    this.resolved = resolved;
+  }
+  transactionInfoId;
+  parentTransactionInfoId;
+  gatewayTransactionId;
+  transactionNumber;
+  invoiceNumber;
+  chargebackDate;
+  merchantChargebackDate;
+  transactionAmount;
+  chargebackAmount;
+  cardBrand;
+  ccLastFour;
+  payeeName;
+  daysToRepresent;
+  representmentDate;
+  merchantRepresentmentDate;
+  representmentStatus;
+  result;
+  chargebackCode;
+  chargebackResponseCode;
+  resolved;
+  static fromRaw(data) {
+    return new _Chargeback(
+      arrString(data, "transaction_info_id"),
+      arrString(data, "parent_transaction_info_id"),
+      arrString(data, "gateway_transaction_id"),
+      arrString(data, "transaction_number"),
+      arrString(data, "invoice_number"),
+      arrString(data, "chargeback_date"),
+      arrString(data, "merchant_chargeback_date"),
+      arrString(data, "transaction_amount"),
+      arrString(data, "chargeback_amount"),
+      arrString(data, "card_brand"),
+      arrString(data, "cc_last_four"),
+      arrString(data, "payee_name"),
+      arrInt(data, "days_to_represent"),
+      arrString(data, "representment_date"),
+      arrString(data, "merchant_representment_date"),
+      arrString(data, "representment_status"),
+      arrString(data, "result"),
+      arrString(data, "chargeback_code"),
+      arrString(data, "chargeback_response_code"),
+      arrBool(data, "resolved")
+    );
+  }
+};
+
+// src/resources/chargebacks.ts
+var Chargebacks = class 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`)
+   */
+  async list(sid, filters = {}) {
+    return this.paginate(
+      "GET",
+      "chargeback/list",
+      this.envelope({ sid }, filters),
+      Chargeback.fromRaw
+    );
+  }
+  async show(sid, transactionInfoId) {
+    const raw = await this.transport.request(
+      "GET",
+      "chargeback/show",
+      this.envelope({ sid, transaction_info_id: transactionInfoId })
+    );
+    return Chargeback.fromRaw(raw["data"] ?? {});
+  }
+};
+
 // src/data-objects/customer.ts
 var Customer = class _Customer {
   constructor(uuid, firstName, lastName, phone, email, addr1, addr2, addr3, city, state, zip, country) {
@@ -777,6 +896,343 @@ var Deposits = class extends AbstractResource {
   }
 };
 
+// src/data-objects/document-upload-failure.ts
+var DocumentUploadFailure = class _DocumentUploadFailure {
+  constructor(fileName, reason) {
+    this.fileName = fileName;
+    this.reason = reason;
+  }
+  fileName;
+  reason;
+  static fromRaw(data) {
+    return new _DocumentUploadFailure(arrString(data, "file_name"), arrString(data, "reason"));
+  }
+};
+
+// src/data-objects/merchant-document.ts
+var MerchantDocument = class _MerchantDocument {
+  constructor(uuid, fileName, docType, chargebackTransactionInfoId, size, uploadedAt, uploadedVia, sentToProcessorAt, processorResponse) {
+    this.uuid = uuid;
+    this.fileName = fileName;
+    this.docType = docType;
+    this.chargebackTransactionInfoId = chargebackTransactionInfoId;
+    this.size = size;
+    this.uploadedAt = uploadedAt;
+    this.uploadedVia = uploadedVia;
+    this.sentToProcessorAt = sentToProcessorAt;
+    this.processorResponse = processorResponse;
+  }
+  uuid;
+  fileName;
+  docType;
+  chargebackTransactionInfoId;
+  size;
+  uploadedAt;
+  uploadedVia;
+  sentToProcessorAt;
+  processorResponse;
+  static fromRaw(data) {
+    const sent = Array.isArray(data["sent_to_processor"]) ? data["sent_to_processor"] : [];
+    const [sentAt, processorResponse] = sent.map(
+      (value) => value === null || value === void 0 ? void 0 : String(value)
+    );
+    return new _MerchantDocument(
+      arrString(data, "uuid"),
+      arrString(data, "file_name"),
+      arrString(data, "doc_type"),
+      arrString(data, "chargeback_transaction_info_id"),
+      arrInt(data, "size"),
+      arrString(data, "uploaded_at"),
+      arrString(data, "uploaded_via"),
+      sentAt,
+      processorResponse
+    );
+  }
+};
+
+// src/data-objects/document-upload-result.ts
+var DocumentUploadResult = class _DocumentUploadResult {
+  constructor(message, documents = [], failed = []) {
+    this.message = message;
+    this.documents = documents;
+    this.failed = failed;
+  }
+  message;
+  documents;
+  failed;
+  static fromRaw(data) {
+    return new _DocumentUploadResult(
+      arrString(data, "message"),
+      arrArrayFrom(data, "documents").map(MerchantDocument.fromRaw),
+      arrArrayFrom(data, "failed").map(DocumentUploadFailure.fromRaw)
+    );
+  }
+};
+
+// src/resources/documents.ts
+var Documents = class 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`)
+   */
+  async upload(sid, docType, files, chargebackTransactionInfoId) {
+    const raw = await this.transport.requestMultipart(
+      "POST",
+      "document/upload",
+      this.envelope({
+        sid,
+        doc_type: docType,
+        chargeback_transaction_info_id: chargebackTransactionInfoId
+      }),
+      files.map((file) => ({ field: "files[]", ...toBlob(file) }))
+    );
+    return DocumentUploadResult.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * 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`
+   */
+  async list(sid, filters = {}) {
+    const raw = await this.transport.request(
+      "GET",
+      "document/list",
+      this.envelope({ sid }, filters)
+    );
+    const documents = Array.isArray(raw["data"]) ? raw["data"] : [];
+    return documents.map(MerchantDocument.fromRaw);
+  }
+};
+function toBlob(file) {
+  if (file instanceof Blob) {
+    const name = file.name;
+    return { content: file, filename: typeof name === "string" && name !== "" ? name : "document" };
+  }
+  const content = file.content instanceof Blob ? file.content : new Blob([file.content], file.contentType ? { type: file.contentType } : {});
+  return { content, filename: file.filename };
+}
+
+// src/data-objects/fund-release.ts
+var FundRelease = class _FundRelease {
+  constructor(id, amount, fee, status, statusLabel, idempotencyKey, transactionInfoIds = [], failureReason, requestedAt, completedAt) {
+    this.id = id;
+    this.amount = amount;
+    this.fee = fee;
+    this.status = status;
+    this.statusLabel = statusLabel;
+    this.idempotencyKey = idempotencyKey;
+    this.transactionInfoIds = transactionInfoIds;
+    this.failureReason = failureReason;
+    this.requestedAt = requestedAt;
+    this.completedAt = completedAt;
+  }
+  id;
+  amount;
+  fee;
+  status;
+  statusLabel;
+  idempotencyKey;
+  transactionInfoIds;
+  failureReason;
+  requestedAt;
+  completedAt;
+  static fromRaw(data) {
+    const ids = Array.isArray(data["transaction_info_ids"]) ? data["transaction_info_ids"].map(String) : [];
+    return new _FundRelease(
+      arrInt(data, "id"),
+      arrString(data, "amount"),
+      arrString(data, "fee"),
+      arrString(data, "status"),
+      arrString(data, "status_label"),
+      arrString(data, "idempotency_key"),
+      ids,
+      arrString(data, "failure_reason"),
+      arrString(data, "requested_at"),
+      arrString(data, "completed_at")
+    );
+  }
+};
+
+// src/data-objects/fund-release-result.ts
+var FundReleaseResult = class _FundReleaseResult {
+  constructor(sid, replayed = false, release = new FundRelease()) {
+    this.sid = sid;
+    this.replayed = replayed;
+    this.release = release;
+  }
+  sid;
+  replayed;
+  release;
+  static fromRaw(data) {
+    return new _FundReleaseResult(
+      arrString(data, "sid"),
+      arrBool(data, "replayed"),
+      FundRelease.fromRaw(arrObjectFrom(data, ["release"]))
+    );
+  }
+};
+
+// src/data-objects/held-balance.ts
+var HeldBalance = class _HeldBalance {
+  constructor(sid, available, pending, reserve, atRisk, owedToSplit, unresolved, releaseFee, releasable, achSettlementDays, achOutEnabled = false, achOutLimitRemaining) {
+    this.sid = sid;
+    this.available = available;
+    this.pending = pending;
+    this.reserve = reserve;
+    this.atRisk = atRisk;
+    this.owedToSplit = owedToSplit;
+    this.unresolved = unresolved;
+    this.releaseFee = releaseFee;
+    this.releasable = releasable;
+    this.achSettlementDays = achSettlementDays;
+    this.achOutEnabled = achOutEnabled;
+    this.achOutLimitRemaining = achOutLimitRemaining;
+  }
+  sid;
+  available;
+  pending;
+  reserve;
+  atRisk;
+  owedToSplit;
+  unresolved;
+  releaseFee;
+  releasable;
+  achSettlementDays;
+  achOutEnabled;
+  achOutLimitRemaining;
+  static fromRaw(data) {
+    return new _HeldBalance(
+      arrString(data, "sid"),
+      arrString(data, "available"),
+      arrString(data, "pending"),
+      arrString(data, "reserve"),
+      arrString(data, "at_risk"),
+      arrString(data, "owed_to_split"),
+      arrString(data, "unresolved"),
+      arrString(data, "release_fee"),
+      arrString(data, "releasable"),
+      arrInt(data, "ach_settlement_days"),
+      arrBool(data, "ach_out_enabled"),
+      arrString(data, "ach_out_limit_remaining")
+    );
+  }
+};
+
+// src/data-objects/releasable-transaction.ts
+var ReleasableTransaction = class _ReleasableTransaction {
+  constructor(transactionInfoId, type, transactionDate, grossAmount, netAmount, splitAmount, amount) {
+    this.transactionInfoId = transactionInfoId;
+    this.type = type;
+    this.transactionDate = transactionDate;
+    this.grossAmount = grossAmount;
+    this.netAmount = netAmount;
+    this.splitAmount = splitAmount;
+    this.amount = amount;
+  }
+  transactionInfoId;
+  type;
+  transactionDate;
+  grossAmount;
+  netAmount;
+  splitAmount;
+  amount;
+  static fromRaw(data) {
+    return new _ReleasableTransaction(
+      arrString(data, "transaction_info_id"),
+      arrString(data, "type"),
+      arrString(data, "transaction_date"),
+      arrString(data, "gross_amount"),
+      arrString(data, "net_amount"),
+      arrString(data, "split_amount"),
+      arrString(data, "amount")
+    );
+  }
+};
+
+// src/data-objects/releasable-transactions.ts
+var ReleasableTransactions = class _ReleasableTransactions {
+  constructor(sid, transactions = [], total, truncated = false) {
+    this.sid = sid;
+    this.transactions = transactions;
+    this.total = total;
+    this.truncated = truncated;
+  }
+  sid;
+  transactions;
+  total;
+  truncated;
+  static fromRaw(data) {
+    return new _ReleasableTransactions(
+      arrString(data, "sid"),
+      arrArrayFrom(data, "transactions").map(ReleasableTransaction.fromRaw),
+      arrString(data, "total"),
+      arrBool(data, "truncated")
+    );
+  }
+};
+
+// src/resources/funds.ts
+var Funds = class extends AbstractResource {
+  /** The merchant's balance at the processor, and how much is releasable today. */
+  async balance(sid) {
+    const raw = await this.transport.request("GET", "funds/balance", this.envelope({ sid }));
+    return HeldBalance.fromRaw(raw["data"] ?? {});
+  }
+  /** The payments that can be released right now — the list to release by `transaction_info_ids`. */
+  async transactions(sid) {
+    const raw = await this.transport.request("GET", "funds/transactions", this.envelope({ sid }));
+    return ReleasableTransactions.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * 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)
+   */
+  async release(sid, idempotencyKey, attributes) {
+    let raw;
+    try {
+      raw = await this.transport.request(
+        "POST",
+        "funds/release",
+        this.envelope({ sid, idempotency_key: idempotencyKey, ...attributes })
+      );
+    } catch (e) {
+      const data = e instanceof ApiException ? e.getResponseBody()["data"] : void 0;
+      if (data !== null && typeof data === "object" && "release" in data) {
+        return FundReleaseResult.fromRaw(data);
+      }
+      throw e;
+    }
+    return FundReleaseResult.fromRaw(raw["data"] ?? {});
+  }
+};
+
 // src/data-objects/cover-fee-quote.ts
 var CoverFeeQuote = class _CoverFeeQuote {
   constructor(basis, base, ccFee, ccTotal, achFee, achTotal) {
@@ -1219,6 +1675,34 @@ var Invoices = class extends AbstractResource {
   }
 };
 
+// src/data-objects/application-status.ts
+var ApplicationStatus = class _ApplicationStatus {
+  constructor(sid, name, status, applicationStatus, boarded = false, applicationSubmittedAt) {
+    this.sid = sid;
+    this.name = name;
+    this.status = status;
+    this.applicationStatus = applicationStatus;
+    this.boarded = boarded;
+    this.applicationSubmittedAt = applicationSubmittedAt;
+  }
+  sid;
+  name;
+  status;
+  applicationStatus;
+  boarded;
+  applicationSubmittedAt;
+  static fromRaw(data) {
+    return new _ApplicationStatus(
+      arrString(data, "sid"),
+      arrString(data, "name"),
+      arrString(data, "status"),
+      arrString(data, "application_status"),
+      arrBool(data, "boarded"),
+      arrString(data, "application_submitted_at")
+    );
+  }
+};
+
 // src/data-objects/form-link.ts
 var FormLink = class _FormLink {
   constructor(link) {
@@ -1332,6 +1816,19 @@ var Merchants = class extends AbstractResource {
     );
     return FormLink.fromRaw(raw["data"] ?? {});
   }
+  /**
+   * 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.
+   */
+  async applicationStatus(sid) {
+    const raw = await this.transport.request(
+      "GET",
+      "merchant/application-status",
+      this.envelope({ sid })
+    );
+    return ApplicationStatus.fromRaw(raw["data"] ?? {});
+  }
 };
 
 // src/data-objects/payment-method.ts
@@ -1754,6 +2251,342 @@ var RecurringPayments = class extends AbstractResource {
   }
 };
 
+// src/data-objects/subscribe-result.ts
+var SubscribeResult = class _SubscribeResult {
+  constructor(subscriptionId, status, nextRunDate, transactionNumber, amount) {
+    this.subscriptionId = subscriptionId;
+    this.status = status;
+    this.nextRunDate = nextRunDate;
+    this.transactionNumber = transactionNumber;
+    this.amount = amount;
+  }
+  subscriptionId;
+  status;
+  nextRunDate;
+  transactionNumber;
+  amount;
+  static fromRaw(data) {
+    return new _SubscribeResult(
+      arrInt(data, "subscription_id"),
+      arrString(data, "status"),
+      arrString(data, "next_run_date"),
+      arrString(data, "transaction_number"),
+      arrString(data, "amount")
+    );
+  }
+};
+
+// src/data-objects/subscription-item.ts
+var SubscriptionItem = class _SubscriptionItem {
+  constructor(name, description, quantity, unitPrice, amount) {
+    this.name = name;
+    this.description = description;
+    this.quantity = quantity;
+    this.unitPrice = unitPrice;
+    this.amount = amount;
+  }
+  name;
+  description;
+  quantity;
+  unitPrice;
+  amount;
+  static fromRaw(data) {
+    return new _SubscriptionItem(
+      arrString(data, "name"),
+      arrString(data, "description"),
+      arrString(data, "quantity"),
+      arrString(data, "unit_price"),
+      arrString(data, "amount")
+    );
+  }
+};
+
+// src/data-objects/subscription-plan.ts
+var SubscriptionPlan = class _SubscriptionPlan {
+  constructor(id, name, description, recurrenceSchedule, status, subtotal, total, token, publicUrl, allowPublic = false, createdAt, items = []) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+    this.recurrenceSchedule = recurrenceSchedule;
+    this.status = status;
+    this.subtotal = subtotal;
+    this.total = total;
+    this.token = token;
+    this.publicUrl = publicUrl;
+    this.allowPublic = allowPublic;
+    this.createdAt = createdAt;
+    this.items = items;
+  }
+  id;
+  name;
+  description;
+  recurrenceSchedule;
+  status;
+  subtotal;
+  total;
+  token;
+  publicUrl;
+  allowPublic;
+  createdAt;
+  items;
+  static fromRaw(data) {
+    return new _SubscriptionPlan(
+      arrInt(data, "id"),
+      arrString(data, "name"),
+      arrString(data, "description"),
+      arrString(data, "recurrence_schedule"),
+      arrString(data, "status"),
+      arrString(data, "subtotal"),
+      arrString(data, "total"),
+      arrString(data, "token"),
+      arrString(data, "public_url"),
+      arrBool(data, "allow_public"),
+      arrString(data, "created_at"),
+      arrArrayFrom(data, "items").map(SubscriptionItem.fromRaw)
+    );
+  }
+};
+
+// src/resources/subscription-plans.ts
+var SubscriptionPlans = class extends AbstractResource {
+  /**
+   * List a merchant's plans, newest first.
+   *
+   * @param status `draft`, `active` or `archived`
+   */
+  async list(sid, status) {
+    return this.paginate(
+      "GET",
+      "subscription-plan/list",
+      this.envelope({ sid, status }),
+      SubscriptionPlan.fromRaw
+    );
+  }
+  async show(sid, subscriptionPlanId) {
+    const raw = await this.transport.request(
+      "GET",
+      "subscription-plan/show",
+      this.envelope({ sid, subscription_plan_id: subscriptionPlanId })
+    );
+    return SubscriptionPlan.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * 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).
+   */
+  async create(sid, attributes) {
+    const raw = await this.transport.request(
+      "POST",
+      "subscription-plan/create",
+      this.envelope({ sid, ...attributes })
+    );
+    return SubscriptionPlan.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * 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}
+   */
+  async edit(sid, subscriptionPlanId, attributes) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription-plan/edit",
+      this.envelope({ sid, subscription_plan_id: subscriptionPlanId, ...attributes })
+    );
+    return SubscriptionPlan.fromRaw(raw["data"] ?? {});
+  }
+  /** Delete a plan with no subscribers. A plan that has any must be archived instead. */
+  async delete(sid, subscriptionPlanId) {
+    const raw = await this.transport.request(
+      "POST",
+      "subscription-plan/delete",
+      this.envelope({ sid, subscription_plan_id: subscriptionPlanId })
+    );
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+  /** Move a draft plan with at least one line item to active, so customers can subscribe. */
+  async publish(sid, subscriptionPlanId) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription-plan/publish",
+      this.envelope({ sid, subscription_plan_id: subscriptionPlanId })
+    );
+    return SubscriptionPlan.fromRaw(raw["data"] ?? {});
+  }
+  /** Stop new subscriptions and hide the plan from the public catalog. */
+  async archive(sid, subscriptionPlanId) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription-plan/archive",
+      this.envelope({ sid, subscription_plan_id: subscriptionPlanId })
+    );
+    return SubscriptionPlan.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * Move an archived plan back to draft, to review and re-publish.
+   * `allowPublic` stays off until the merchant opts back into the catalog.
+   */
+  async unarchive(sid, subscriptionPlanId) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription-plan/unarchive",
+      this.envelope({ sid, subscription_plan_id: subscriptionPlanId })
+    );
+    return SubscriptionPlan.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * Subscribe a customer to an active plan: charges the first payment to one
+   * of the customer's saved payment methods and enrolls them.
+   */
+  async subscribe(sid, subscriptionPlanId, customerUuid, paymentMethodId) {
+    const raw = await this.transport.request(
+      "POST",
+      "subscription-plan/subscribe",
+      this.envelope({
+        sid,
+        subscription_plan_id: subscriptionPlanId,
+        customer_uuid: customerUuid,
+        payment_method: paymentMethodId
+      })
+    );
+    return SubscribeResult.fromRaw(raw["data"] ?? {});
+  }
+};
+
+// src/data-objects/subscription.ts
+var Subscription = class _Subscription {
+  constructor(id, subscriptionPlanId, planName, amount, recurrenceSchedule, startDate, endDate, lastRunDate, lastRunStatus, lastRunFailedCount, nextRunDate, status, pausedUntilDate, cancelledAt, cancelledBy, customerUuid, error, paymentMethod = new RecurringPaymentMethod(), items = []) {
+    this.id = id;
+    this.subscriptionPlanId = subscriptionPlanId;
+    this.planName = planName;
+    this.amount = amount;
+    this.recurrenceSchedule = recurrenceSchedule;
+    this.startDate = startDate;
+    this.endDate = endDate;
+    this.lastRunDate = lastRunDate;
+    this.lastRunStatus = lastRunStatus;
+    this.lastRunFailedCount = lastRunFailedCount;
+    this.nextRunDate = nextRunDate;
+    this.status = status;
+    this.pausedUntilDate = pausedUntilDate;
+    this.cancelledAt = cancelledAt;
+    this.cancelledBy = cancelledBy;
+    this.customerUuid = customerUuid;
+    this.error = error;
+    this.paymentMethod = paymentMethod;
+    this.items = items;
+  }
+  id;
+  subscriptionPlanId;
+  planName;
+  amount;
+  recurrenceSchedule;
+  startDate;
+  endDate;
+  lastRunDate;
+  lastRunStatus;
+  lastRunFailedCount;
+  nextRunDate;
+  status;
+  pausedUntilDate;
+  cancelledAt;
+  cancelledBy;
+  customerUuid;
+  error;
+  paymentMethod;
+  items;
+  static fromRaw(data) {
+    return new _Subscription(
+      arrInt(data, "id"),
+      arrInt(data, "subscription_plan_id"),
+      arrString(data, "plan_name"),
+      arrString(data, "amount"),
+      arrString(data, "recurrence_schedule"),
+      arrString(data, "start_date"),
+      arrString(data, "end_date"),
+      arrString(data, "last_run_date"),
+      arrString(data, "last_run_status"),
+      arrInt(data, "last_run_failed_count"),
+      arrString(data, "next_run_date"),
+      arrString(data, "status"),
+      arrString(data, "paused_until_date"),
+      arrString(data, "cancelled_at"),
+      arrString(data, "cancelled_by"),
+      arrString(data, "customer_uuid"),
+      arrString(data, "error"),
+      RecurringPaymentMethod.fromRaw(arrObjectFrom(data, ["payment_method"])),
+      arrArrayFrom(data, "items").map(SubscriptionItem.fromRaw)
+    );
+  }
+};
+
+// src/resources/subscriptions.ts
+var Subscriptions = class extends AbstractResource {
+  /**
+   * List a merchant's subscriptions, newest first.
+   *
+   * @param filters `status` — Active | Failed | Paused | Cancelled | Ended;
+   *   `customer_uuid`
+   */
+  async list(sid, filters = {}) {
+    return this.paginate(
+      "GET",
+      "subscription/list",
+      this.envelope({ sid }, filters),
+      Subscription.fromRaw
+    );
+  }
+  async show(sid, subscriptionId) {
+    const raw = await this.transport.request(
+      "GET",
+      "subscription/show",
+      this.envelope({ sid, subscription_id: subscriptionId })
+    );
+    return Subscription.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * Pause a subscription until `pauseUntilDate` (Y-m-d, in the future), or
+   * indefinitely when it is omitted.
+   */
+  async pause(sid, subscriptionId, pauseUntilDate) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription/pause",
+      this.envelope({
+        sid,
+        subscription_id: subscriptionId,
+        pause_until_date: pauseUntilDate
+      })
+    );
+    return Subscription.fromRaw(raw["data"] ?? {});
+  }
+  /** Reactivate a paused subscription and recompute its next charge date. */
+  async resume(sid, subscriptionId) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription/resume",
+      this.envelope({ sid, subscription_id: subscriptionId })
+    );
+    return Subscription.fromRaw(raw["data"] ?? {});
+  }
+  /** Cancel a subscription permanently; no further charges are made. */
+  async cancel(sid, subscriptionId) {
+    const raw = await this.transport.request(
+      "PATCH",
+      "subscription/cancel",
+      this.envelope({ sid, subscription_id: subscriptionId })
+    );
+    return Subscription.fromRaw(raw["data"] ?? {});
+  }
+};
+
 // src/data-objects/tokenize-result.ts
 var TokenizeResult = class _TokenizeResult {
   constructor(token) {
@@ -1816,6 +2649,40 @@ var Transactions = class extends AbstractResource {
     );
     return TokenizeResult.fromRaw(raw["data"] ?? {});
   }
+  /**
+   * 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.
+   */
+  async authorize(sid, attributes) {
+    const raw = await this.transport.request(
+      "POST",
+      "transaction/authorize",
+      this.envelope({ sid, ...attributes })
+    );
+    return Transaction.fromRaw(raw["data"] ?? {});
+  }
+  /**
+   * 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}
+   */
+  async capture(sid, transactionId, amount) {
+    const raw = await this.transport.request(
+      "POST",
+      "transaction/capture",
+      this.envelope({ sid, transaction_id: transactionId, amount })
+    );
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
   async refund(sid, attributes) {
     const raw = await this.transport.request(
       "POST",
@@ -1845,6 +2712,11 @@ var Client = class {
   recurringPayments;
   invoices;
   recurringInvoices;
+  chargebacks;
+  documents;
+  funds;
+  subscriptionPlans;
+  subscriptions;
   _config;
   constructor(token, baseUrl = DEFAULT_BASE_URL) {
     this._config = token instanceof Config ? token : new Config(token, baseUrl);
@@ -1858,6 +2730,11 @@ var Client = class {
     this.recurringPayments = new RecurringPayments(transport);
     this.invoices = new Invoices(transport);
     this.recurringInvoices = new RecurringInvoices(transport);
+    this.chargebacks = new Chargebacks(transport);
+    this.documents = new Documents(transport);
+    this.funds = new Funds(transport);
+    this.subscriptionPlans = new SubscriptionPlans(transport);
+    this.subscriptions = new Subscriptions(transport);
   }
   config() {
     return this._config;
@@ -1866,7 +2743,9 @@ var Client = class {
 export {
   Address,
   ApiException,
+  ApplicationStatus,
   AuthenticationException,
+  Chargeback,
   Client,
   Config,
   ConnectionException,
@@ -1878,7 +2757,12 @@ export {
   DepositGroup,
   DepositWithTransactions,
   DimeException,
+  DocumentUploadFailure,
+  DocumentUploadResult,
   FormLink,
+  FundRelease,
+  FundReleaseResult,
+  HeldBalance,
   Invoice,
   InvoiceCustomer,
   InvoiceEvent,
@@ -1887,6 +2771,7 @@ export {
   InvoiceLink,
   InvoicePayment,
   Merchant,
+  MerchantDocument,
   MessageResult,
   NotFoundException,
   PaymentMethod,
@@ -1895,7 +2780,13 @@ export {
   RecurringInvoice,
   RecurringPayment,
   RecurringPaymentMethod,
+  ReleasableTransaction,
+  ReleasableTransactions,
   ServerException,
+  SubscribeResult,
+  Subscription,
+  SubscriptionItem,
+  SubscriptionPlan,
   TokenizeResult,
   Transaction,
   TransactionAddress,