@dime-technology/dime-js-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1227 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Address: () => Address,
+  ApiException: () => ApiException,
+  AuthenticationException: () => AuthenticationException,
+  Client: () => Client,
+  Config: () => Config,
+  ConnectionException: () => ConnectionException,
+  CursorPage: () => CursorPage,
+  Customer: () => Customer,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  Deposit: () => Deposit,
+  DepositGroup: () => DepositGroup,
+  DepositWithTransactions: () => DepositWithTransactions,
+  DimeException: () => DimeException,
+  FormLink: () => FormLink,
+  Merchant: () => Merchant,
+  MessageResult: () => MessageResult,
+  NotFoundException: () => NotFoundException,
+  PaymentMethod: () => PaymentMethod,
+  PermissionDeniedException: () => PermissionDeniedException,
+  RateLimitException: () => RateLimitException,
+  RecurringPayment: () => RecurringPayment,
+  RecurringPaymentMethod: () => RecurringPaymentMethod,
+  ServerException: () => ServerException,
+  TokenizeResult: () => TokenizeResult,
+  Transaction: () => Transaction,
+  TransactionAddress: () => TransactionAddress,
+  VERSION: () => VERSION,
+  ValidationException: () => ValidationException
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://app.dimepayments.com";
+var VERSION = "1.0.0";
+var Config = class {
+  token;
+  baseUrl;
+  timeout;
+  maxRetries;
+  retryBaseDelay;
+  fetch;
+  sleep;
+  constructor(options, baseUrl) {
+    if (typeof options === "string") {
+      this.token = options;
+      this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+      this.timeout = 30;
+      this.maxRetries = 2;
+      this.retryBaseDelay = 0.5;
+    } else {
+      this.token = options.token;
+      this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+      this.timeout = options.timeout ?? 30;
+      this.maxRetries = options.maxRetries ?? 2;
+      this.retryBaseDelay = options.retryBaseDelay ?? 0.5;
+      this.fetch = options.fetch;
+      this.sleep = options.sleep;
+    }
+  }
+  baseUri() {
+    return `${this.baseUrl.replace(/\/$/, "")}/api/`;
+  }
+};
+
+// src/exceptions/dime-exception.ts
+var DimeException = class extends Error {
+  constructor(message, statusCode, responseBody = {}, cause) {
+    super(message, { cause });
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  statusCode;
+  responseBody;
+  getStatusCode() {
+    return this.statusCode;
+  }
+  getResponseBody() {
+    return this.responseBody;
+  }
+};
+
+// src/exceptions/validation-exception.ts
+var ValidationException = class extends DimeException {
+  constructor(message, errors = {}, statusCode, responseBody = {}, cause) {
+    super(message, statusCode, responseBody, cause);
+    this.errors = errors;
+  }
+  errors;
+  getErrors() {
+    return this.errors;
+  }
+  firstError() {
+    for (const messages of Object.values(this.errors)) {
+      if (messages.length > 0) return messages[0];
+    }
+    return void 0;
+  }
+};
+
+// src/exceptions/rate-limit-exception.ts
+var RateLimitException = class extends DimeException {
+  constructor(message, retryAfter, statusCode = 429, responseBody = {}, cause) {
+    super(message, statusCode, responseBody, cause);
+    this.retryAfter = retryAfter;
+  }
+  retryAfter;
+  getRetryAfter() {
+    return this.retryAfter;
+  }
+};
+
+// src/exceptions/api-exception.ts
+var ApiException = class extends DimeException {
+};
+
+// src/exceptions/authentication-exception.ts
+var AuthenticationException = class extends DimeException {
+};
+
+// src/exceptions/permission-denied-exception.ts
+var PermissionDeniedException = class extends DimeException {
+};
+
+// src/exceptions/not-found-exception.ts
+var NotFoundException = class extends DimeException {
+};
+
+// src/exceptions/server-exception.ts
+var ServerException = class extends DimeException {
+};
+
+// src/exceptions/connection-exception.ts
+var ConnectionException = class extends DimeException {
+};
+
+// src/http/error-handler.ts
+function looksLikeValidation(status, body) {
+  if (body["errors"] !== void 0 && typeof body["errors"] === "object" && !Array.isArray(body["errors"])) {
+    return true;
+  }
+  return (status === 400 || status === 422) && body["message"] !== void 0 && typeof body["message"] === "object" && !Array.isArray(body["message"]);
+}
+function extractErrors(body) {
+  const raw = body["errors"] ?? body["message"];
+  if (raw === null || raw === void 0 || typeof raw !== "object" || Array.isArray(raw)) {
+    return {};
+  }
+  const errors = {};
+  for (const [field, messages] of Object.entries(raw)) {
+    errors[field] = Array.isArray(messages) ? messages.map(String) : [String(messages)];
+  }
+  return errors;
+}
+function extractMessage(body) {
+  const data = body["data"];
+  if (data !== null && data !== void 0 && typeof data === "object" && !Array.isArray(data)) {
+    const msg = data["message"];
+    if (typeof msg === "string") return msg;
+  }
+  if (typeof body["message"] === "string") return body["message"];
+  return void 0;
+}
+function firstMessage(errors) {
+  for (const messages of Object.values(errors)) {
+    if (messages.length > 0) return messages[0];
+  }
+  return void 0;
+}
+function handleError(status, body, retryAfter) {
+  if (looksLikeValidation(status, body)) {
+    const errors = extractErrors(body);
+    throw new ValidationException(
+      firstMessage(errors) ?? "The given data was invalid.",
+      errors,
+      status,
+      body
+    );
+  }
+  const message = extractMessage(body) ?? `Dime API request failed with status ${status}.`;
+  if (status === 401) throw new AuthenticationException(message, status, body);
+  if (status === 403) throw new PermissionDeniedException(message, status, body);
+  if (status === 404) throw new NotFoundException(message, status, body);
+  if (status === 429) throw new RateLimitException(message, retryAfter, status, body);
+  if (status >= 500) throw new ServerException(message, status, body);
+  throw new ApiException(message, status, body);
+}
+
+// src/http/transport.ts
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+    this.sleepFn = config.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  }
+  config;
+  fetchFn;
+  sleepFn;
+  /**
+   * 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.
+   */
+  async request(method, path, body = {}, query = {}) {
+    let url = `${this.config.baseUri()}${path.replace(/^\//, "")}`;
+    if (Object.keys(query).length > 0) {
+      url += "?" + new URLSearchParams(query).toString();
+    }
+    const hasBody = Object.keys(body).length > 0;
+    const init = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.config.token}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-Dime-Sdk": `dime-js-sdk/${VERSION}`
+      },
+      ...hasBody ? { body: JSON.stringify(body) } : {}
+    };
+    return this.attempt(url, init, 0);
+  }
+  async attempt(url, init, attempt) {
+    let response;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.config.timeout * 1e3);
+      try {
+        response = await this.fetchFn(url, { ...init, signal: controller.signal });
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (err) {
+      const isAbort = err instanceof Error && err.name === "AbortError";
+      const label = isAbort ? `Request timed out after ${this.config.timeout}s` : `Could not reach the Dime API: ${err instanceof Error ? err.message : String(err)}`;
+      if (attempt < this.config.maxRetries) {
+        await this.sleep(attempt, void 0);
+        return this.attempt(url, init, attempt + 1);
+      }
+      throw new ConnectionException(label, void 0, {}, err instanceof Error ? err : void 0);
+    }
+    const status = response.status;
+    if ((status === 429 || status >= 500) && attempt < this.config.maxRetries) {
+      const retryAfter = parseRetryAfter(response);
+      await this.sleep(attempt, retryAfter);
+      return this.attempt(url, init, attempt + 1);
+    }
+    const decoded = await decode(response);
+    if (status < 200 || status >= 300) {
+      handleError(status, decoded, parseRetryAfter(response));
+    }
+    return decoded;
+  }
+  async sleep(attempt, retryAfter) {
+    const ms = retryAfter !== void 0 ? retryAfter * 1e3 : Math.min(2 ** attempt * this.config.retryBaseDelay * 1e3, 3e4);
+    await this.sleepFn(ms);
+  }
+};
+function parseRetryAfter(response) {
+  const header = response.headers.get("Retry-After");
+  if (header !== null && /^\d+$/.test(header)) return parseInt(header, 10);
+  return void 0;
+}
+async function decode(response) {
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return { message: text };
+  } catch {
+    return { message: text };
+  }
+}
+
+// src/support/arr.ts
+function arrString(data, key) {
+  const value = data[key];
+  if (value === null || value === void 0 || Array.isArray(value)) return void 0;
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return String(value);
+}
+function arrInt(data, key) {
+  const value = data[key];
+  if (value === null || value === void 0) return void 0;
+  const n = Number(value);
+  return Number.isNaN(n) ? void 0 : Math.trunc(n);
+}
+function arrBool(data, key, defaultValue = false) {
+  const value = data[key];
+  return value === null || value === void 0 ? defaultValue : Boolean(value);
+}
+function arrObjectFrom(data, keys) {
+  for (const key of keys) {
+    const value = data[key];
+    if (value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+  }
+  return {};
+}
+
+// src/data-objects/address.ts
+var Address = class _Address {
+  constructor(id, recipient, lineOne, lineTwo, lineThree, city, state, zip) {
+    this.id = id;
+    this.recipient = recipient;
+    this.lineOne = lineOne;
+    this.lineTwo = lineTwo;
+    this.lineThree = lineThree;
+    this.city = city;
+    this.state = state;
+    this.zip = zip;
+  }
+  id;
+  recipient;
+  lineOne;
+  lineTwo;
+  lineThree;
+  city;
+  state;
+  zip;
+  static fromRaw(data) {
+    return new _Address(
+      // show returns address_id; list returns id
+      arrInt(data, "address_id") ?? arrInt(data, "id"),
+      arrString(data, "recipient"),
+      arrString(data, "line_one"),
+      arrString(data, "line_two"),
+      arrString(data, "line_three"),
+      arrString(data, "city"),
+      arrString(data, "state"),
+      arrString(data, "zip")
+    );
+  }
+};
+
+// src/data-objects/message-result.ts
+var MessageResult = class _MessageResult {
+  constructor(message) {
+    this.message = message;
+  }
+  message;
+  static fromRaw(data) {
+    return new _MessageResult(arrString(data, "message"));
+  }
+};
+
+// src/pagination/cursor-page.ts
+var CursorPage = class {
+  constructor(data, nextCursor, prevCursor, perPage, path, fetcher) {
+    this.data = data;
+    this.nextCursor = nextCursor;
+    this.prevCursor = prevCursor;
+    this.perPage = perPage;
+    this.path = path;
+    this.fetcher = fetcher;
+  }
+  data;
+  nextCursor;
+  prevCursor;
+  perPage;
+  path;
+  fetcher;
+  hasMore() {
+    return this.nextCursor !== void 0 && this.fetcher !== void 0;
+  }
+  async next() {
+    if (!this.hasMore() || this.nextCursor === void 0 || this.fetcher === void 0) {
+      return null;
+    }
+    return this.fetcher(this.nextCursor);
+  }
+  /** Lazily iterate every item across all remaining pages. */
+  async *autoPaging() {
+    let page = this;
+    while (page !== null) {
+      for (const item of page.data) {
+        yield item;
+      }
+      page = await page.next();
+    }
+  }
+  [Symbol.iterator]() {
+    return this.data[Symbol.iterator]();
+  }
+  get length() {
+    return this.data.length;
+  }
+};
+
+// src/resources/abstract-resource.ts
+var AbstractResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Build the standard Dime request envelope, dropping null/undefined values.
+   */
+  envelope(data = {}, filters = {}) {
+    const body = {};
+    const prunedData = pruneNulls(data);
+    if (Object.keys(prunedData).length > 0) body["data"] = prunedData;
+    const prunedFilters = pruneNulls(filters);
+    if (Object.keys(prunedFilters).length > 0) body["filters"] = prunedFilters;
+    return body;
+  }
+  async paginate(method, path, body, map, query = {}) {
+    const raw = await this.transport.request(method, path, body, query);
+    const items = Array.isArray(raw["data"]) ? raw["data"] : [];
+    const meta = raw["meta"] !== null && typeof raw["meta"] === "object" && !Array.isArray(raw["meta"]) ? raw["meta"] : {};
+    const nextCursor = extractCursor(meta, "next_cursor");
+    const prevCursor = extractCursor(meta, "prev_cursor");
+    const fetcher = (cursor) => this.paginate(method, path, body, map, { cursor });
+    return new CursorPage(
+      items.map(map),
+      nextCursor,
+      prevCursor,
+      typeof meta["per_page"] === "number" ? meta["per_page"] : void 0,
+      typeof meta["path"] === "string" ? meta["path"] : void 0,
+      nextCursor !== void 0 ? fetcher : void 0
+    );
+  }
+};
+function extractCursor(meta, key) {
+  const v = meta[key];
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function pruneNulls(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== null && v !== void 0)
+  );
+}
+
+// src/resources/addresses.ts
+var Addresses = class extends AbstractResource {
+  async list(sid, uuid) {
+    return this.paginate("GET", "address/list", this.envelope({ sid, uuid }), Address.fromRaw);
+  }
+  async show(sid, uuid, addressId) {
+    const raw = await this.transport.request("GET", "address/show", this.envelope({ sid, uuid, address_id: addressId }));
+    return Address.fromRaw(raw["data"] ?? {});
+  }
+  async create(sid, uuid, attributes) {
+    const raw = await this.transport.request("POST", "address/create", this.envelope({ sid, uuid, ...attributes }));
+    return Address.fromRaw(raw["data"] ?? {});
+  }
+  async update(sid, uuid, addressId, attributes) {
+    const raw = await this.transport.request("PATCH", "address/update", this.envelope({ sid, uuid, address_id: addressId, ...attributes }));
+    return Address.fromRaw(raw["data"] ?? {});
+  }
+  async delete(sid, uuid, addressId) {
+    const raw = await this.transport.request("POST", "address/delete", this.envelope({ sid, uuid, address_id: addressId }));
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+};
+
+// src/data-objects/customer.ts
+var Customer = class _Customer {
+  constructor(uuid, firstName, lastName, phone, email, addr1, addr2, addr3, city, state, zip, country) {
+    this.uuid = uuid;
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.phone = phone;
+    this.email = email;
+    this.addr1 = addr1;
+    this.addr2 = addr2;
+    this.addr3 = addr3;
+    this.city = city;
+    this.state = state;
+    this.zip = zip;
+    this.country = country;
+  }
+  uuid;
+  firstName;
+  lastName;
+  phone;
+  email;
+  addr1;
+  addr2;
+  addr3;
+  city;
+  state;
+  zip;
+  country;
+  static fromRaw(data) {
+    return new _Customer(
+      arrString(data, "uuid"),
+      arrString(data, "first_name"),
+      arrString(data, "last_name"),
+      arrString(data, "phone"),
+      arrString(data, "email"),
+      arrString(data, "addr1"),
+      arrString(data, "addr2"),
+      arrString(data, "addr3"),
+      arrString(data, "city"),
+      arrString(data, "state"),
+      arrString(data, "zip"),
+      arrString(data, "country")
+    );
+  }
+};
+
+// src/resources/customers.ts
+var Customers = class extends AbstractResource {
+  async list(sid, filters = {}) {
+    return this.paginate("GET", "customer/list", this.envelope({ sid }, filters), Customer.fromRaw);
+  }
+  async show(sid, filters) {
+    const raw = await this.transport.request("GET", "customer/show", this.envelope({ sid }, filters));
+    return Customer.fromRaw(raw["data"] ?? {});
+  }
+  async create(sid, attributes) {
+    const raw = await this.transport.request("POST", "customer/create", this.envelope({ sid, ...attributes }));
+    return Customer.fromRaw(raw["data"] ?? {});
+  }
+  async update(sid, filters, attributes) {
+    const raw = await this.transport.request("PATCH", "customer/update", this.envelope({ sid, ...attributes }, filters));
+    return Customer.fromRaw(raw["data"] ?? {});
+  }
+  async delete(sid, filters) {
+    const raw = await this.transport.request("POST", "customer/delete", this.envelope({ sid }, filters));
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+};
+
+// src/data-objects/deposit.ts
+var Deposit = class _Deposit {
+  constructor(transactionDate, fundDate, transactionInfoId, transactionId, transactionDetailAccount, authorizationAmount, netAmount, sweepId, type) {
+    this.transactionDate = transactionDate;
+    this.fundDate = fundDate;
+    this.transactionInfoId = transactionInfoId;
+    this.transactionId = transactionId;
+    this.transactionDetailAccount = transactionDetailAccount;
+    this.authorizationAmount = authorizationAmount;
+    this.netAmount = netAmount;
+    this.sweepId = sweepId;
+    this.type = type;
+  }
+  transactionDate;
+  fundDate;
+  transactionInfoId;
+  transactionId;
+  transactionDetailAccount;
+  authorizationAmount;
+  netAmount;
+  sweepId;
+  type;
+  static fromRaw(data) {
+    return new _Deposit(
+      arrString(data, "transaction_date"),
+      arrString(data, "fund_date"),
+      arrString(data, "transaction_info_id"),
+      arrString(data, "transaction_id"),
+      arrString(data, "transaction_detail_account"),
+      arrString(data, "authorization_amount"),
+      arrString(data, "net_amount"),
+      arrString(data, "sweep_id"),
+      arrString(data, "type")
+    );
+  }
+};
+
+// src/data-objects/transaction-address.ts
+var TransactionAddress = class _TransactionAddress {
+  constructor(firstName, lastName, addr1, addr2, city, state, zip) {
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.addr1 = addr1;
+    this.addr2 = addr2;
+    this.city = city;
+    this.state = state;
+    this.zip = zip;
+  }
+  firstName;
+  lastName;
+  addr1;
+  addr2;
+  city;
+  state;
+  zip;
+  static fromRaw(data) {
+    return new _TransactionAddress(
+      arrString(data, "first_name"),
+      arrString(data, "last_name"),
+      arrString(data, "addr1"),
+      arrString(data, "addr2"),
+      arrString(data, "city"),
+      arrString(data, "state"),
+      arrString(data, "zip")
+    );
+  }
+};
+
+// src/data-objects/transaction.ts
+var Transaction = class _Transaction {
+  constructor(transactionType, transactionStatus, transactionStatusDescription, transactionNumber, transactionDate, fundDate, settleDate, amount, description, statusCode, statusText, email, phone, customerUuid, multiUseToken, pending = false, transactionInfoId, parentTransactionInfoId, billingAddress = new TransactionAddress(), shippingAddress = new TransactionAddress()) {
+    this.transactionType = transactionType;
+    this.transactionStatus = transactionStatus;
+    this.transactionStatusDescription = transactionStatusDescription;
+    this.transactionNumber = transactionNumber;
+    this.transactionDate = transactionDate;
+    this.fundDate = fundDate;
+    this.settleDate = settleDate;
+    this.amount = amount;
+    this.description = description;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.email = email;
+    this.phone = phone;
+    this.customerUuid = customerUuid;
+    this.multiUseToken = multiUseToken;
+    this.pending = pending;
+    this.transactionInfoId = transactionInfoId;
+    this.parentTransactionInfoId = parentTransactionInfoId;
+    this.billingAddress = billingAddress;
+    this.shippingAddress = shippingAddress;
+  }
+  transactionType;
+  transactionStatus;
+  transactionStatusDescription;
+  transactionNumber;
+  transactionDate;
+  fundDate;
+  settleDate;
+  amount;
+  description;
+  statusCode;
+  statusText;
+  email;
+  phone;
+  customerUuid;
+  multiUseToken;
+  pending;
+  transactionInfoId;
+  parentTransactionInfoId;
+  billingAddress;
+  shippingAddress;
+  static fromRaw(data) {
+    return new _Transaction(
+      arrString(data, "transaction_type"),
+      arrString(data, "transaction_status"),
+      arrString(data, "transaction_status_description"),
+      arrString(data, "transaction_number"),
+      arrString(data, "transaction_date"),
+      arrString(data, "fund_date"),
+      arrString(data, "settle_date"),
+      arrString(data, "amount"),
+      arrString(data, "description"),
+      arrString(data, "status_code"),
+      arrString(data, "status_text"),
+      arrString(data, "email"),
+      arrString(data, "phone"),
+      arrString(data, "customer_uuid"),
+      arrString(data, "multi_use_token"),
+      arrBool(data, "pending"),
+      arrString(data, "transaction_info_id"),
+      arrString(data, "parent_transaction_info_id"),
+      TransactionAddress.fromRaw(arrObjectFrom(data, ["billing_address"])),
+      // The API returns shipping under the camelCase key `shippingAddress`; accept
+      // snake_case too in case that is ever corrected server-side.
+      TransactionAddress.fromRaw(arrObjectFrom(data, ["shippingAddress", "shipping_address"]))
+    );
+  }
+};
+
+// src/data-objects/deposit-with-transactions.ts
+var DepositWithTransactions = class _DepositWithTransactions {
+  constructor(sid, transactionInfoId, transactionId, transactionDate, fundDate, type, countOfTransactions, transTotal, transactions = []) {
+    this.sid = sid;
+    this.transactionInfoId = transactionInfoId;
+    this.transactionId = transactionId;
+    this.transactionDate = transactionDate;
+    this.fundDate = fundDate;
+    this.type = type;
+    this.countOfTransactions = countOfTransactions;
+    this.transTotal = transTotal;
+    this.transactions = transactions;
+  }
+  sid;
+  transactionInfoId;
+  transactionId;
+  transactionDate;
+  fundDate;
+  type;
+  countOfTransactions;
+  transTotal;
+  transactions;
+  static fromRaw(data) {
+    const txRaw = data["transactions"];
+    const transactions = Array.isArray(txRaw) ? txRaw.map((t) => Transaction.fromRaw(t)) : typeof txRaw === "object" && txRaw !== null ? Object.values(txRaw).map((t) => Transaction.fromRaw(t)) : [];
+    return new _DepositWithTransactions(
+      arrString(data, "sid"),
+      arrString(data, "transaction_info_id"),
+      arrString(data, "transaction_id"),
+      arrString(data, "transaction_date"),
+      arrString(data, "fund_date"),
+      arrString(data, "type"),
+      arrInt(data, "countOfTransactions"),
+      arrString(data, "transTotal"),
+      transactions
+    );
+  }
+};
+
+// src/data-objects/deposit-group.ts
+var DepositGroup = class _DepositGroup {
+  constructor(sid, count, deposits = []) {
+    this.sid = sid;
+    this.count = count;
+    this.deposits = deposits;
+  }
+  sid;
+  count;
+  deposits;
+  static fromRaw(data) {
+    const depositsRaw = data["deposits"];
+    const deposits = typeof depositsRaw === "object" && depositsRaw !== null && !Array.isArray(depositsRaw) ? Object.values(depositsRaw).map(
+      (d) => DepositWithTransactions.fromRaw(d)
+    ) : [];
+    return new _DepositGroup(arrString(data, "sid"), arrInt(data, "count"), deposits);
+  }
+};
+
+// src/resources/deposits.ts
+var Deposits = class extends AbstractResource {
+  async list(sid, filters = {}) {
+    return this.paginate("GET", "deposit/list", this.envelope({ sid }, filters), Deposit.fromRaw);
+  }
+  async listWithTransactions(sid, filters) {
+    const raw = await this.transport.request("GET", "deposit/list-with-trans", this.envelope({ sid }, filters));
+    return DepositGroup.fromRaw(raw["data"] ?? {});
+  }
+  async show(sid, identifier) {
+    const raw = await this.transport.request("GET", "deposit/show", this.envelope({ sid, ...identifier }));
+    return DepositWithTransactions.fromRaw(raw["data"] ?? {});
+  }
+};
+
+// src/data-objects/form-link.ts
+var FormLink = class _FormLink {
+  constructor(link) {
+    this.link = link;
+  }
+  link;
+  static fromRaw(data) {
+    return new _FormLink(arrString(data, "link"));
+  }
+};
+
+// src/data-objects/merchant.ts
+var Merchant = class _Merchant {
+  constructor(name, sid, mcc, slug, pubApiKey, processorMid, active = false, activeAt, gPay = false, aPay = false, pciCompliance = false, website, addr1, addr2, city, state, zip, phone, primaryPhone, primaryEmail, primaryName) {
+    this.name = name;
+    this.sid = sid;
+    this.mcc = mcc;
+    this.slug = slug;
+    this.pubApiKey = pubApiKey;
+    this.processorMid = processorMid;
+    this.active = active;
+    this.activeAt = activeAt;
+    this.gPay = gPay;
+    this.aPay = aPay;
+    this.pciCompliance = pciCompliance;
+    this.website = website;
+    this.addr1 = addr1;
+    this.addr2 = addr2;
+    this.city = city;
+    this.state = state;
+    this.zip = zip;
+    this.phone = phone;
+    this.primaryPhone = primaryPhone;
+    this.primaryEmail = primaryEmail;
+    this.primaryName = primaryName;
+  }
+  name;
+  sid;
+  mcc;
+  slug;
+  pubApiKey;
+  processorMid;
+  active;
+  activeAt;
+  gPay;
+  aPay;
+  pciCompliance;
+  website;
+  addr1;
+  addr2;
+  city;
+  state;
+  zip;
+  phone;
+  primaryPhone;
+  primaryEmail;
+  primaryName;
+  static fromRaw(data) {
+    return new _Merchant(
+      arrString(data, "name"),
+      arrString(data, "sid"),
+      arrString(data, "mcc"),
+      arrString(data, "slug"),
+      arrString(data, "pub_api_key"),
+      arrString(data, "processor_mid"),
+      arrBool(data, "active"),
+      arrString(data, "active_at"),
+      arrBool(data, "g_pay"),
+      arrBool(data, "a_pay"),
+      arrBool(data, "pci_compliance"),
+      arrString(data, "website"),
+      arrString(data, "addr1"),
+      arrString(data, "addr2"),
+      arrString(data, "city"),
+      arrString(data, "state"),
+      arrString(data, "zip"),
+      arrString(data, "phone"),
+      arrString(data, "primary_phone"),
+      arrString(data, "primary_email"),
+      arrString(data, "primary_name")
+    );
+  }
+};
+
+// src/resources/merchants.ts
+var Merchants = class extends AbstractResource {
+  async list(filters = {}) {
+    return this.paginate("GET", "merchant/list", this.envelope({}, filters), Merchant.fromRaw);
+  }
+  async show(sid) {
+    const raw = await this.transport.request("GET", "merchant/show", this.envelope({ sid }));
+    return Merchant.fromRaw(raw["data"] ?? {});
+  }
+  async create(attributes) {
+    const raw = await this.transport.request("POST", "merchant/create", this.envelope(attributes));
+    return Merchant.fromRaw(raw["data"] ?? {});
+  }
+  async update(sid, attributes) {
+    const raw = await this.transport.request("PATCH", "merchant/update", this.envelope({ sid, ...attributes }));
+    return Merchant.fromRaw(raw["data"] ?? {});
+  }
+  async getFormLink(sid) {
+    const raw = await this.transport.request("GET", "merchant/get-form-link", this.envelope({ sid }));
+    return FormLink.fromRaw(raw["data"] ?? {});
+  }
+};
+
+// src/data-objects/payment-method.ts
+var PaymentMethod = class _PaymentMethod {
+  constructor(id, type, token, firstName, lastName, ccNameOnCard, ccLastFour, ccExpirationDate, ccBrand, achBankAccountName, achRoutingNumber, achAccountNumber, achOwnershipType, achAccountType, achBankName, status, statusDate, enabled = false, isDefault = false, addr1, addr2, addr3, city, state, zip) {
+    this.id = id;
+    this.type = type;
+    this.token = token;
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.ccNameOnCard = ccNameOnCard;
+    this.ccLastFour = ccLastFour;
+    this.ccExpirationDate = ccExpirationDate;
+    this.ccBrand = ccBrand;
+    this.achBankAccountName = achBankAccountName;
+    this.achRoutingNumber = achRoutingNumber;
+    this.achAccountNumber = achAccountNumber;
+    this.achOwnershipType = achOwnershipType;
+    this.achAccountType = achAccountType;
+    this.achBankName = achBankName;
+    this.status = status;
+    this.statusDate = statusDate;
+    this.enabled = enabled;
+    this.isDefault = isDefault;
+    this.addr1 = addr1;
+    this.addr2 = addr2;
+    this.addr3 = addr3;
+    this.city = city;
+    this.state = state;
+    this.zip = zip;
+  }
+  id;
+  type;
+  token;
+  firstName;
+  lastName;
+  ccNameOnCard;
+  ccLastFour;
+  ccExpirationDate;
+  ccBrand;
+  achBankAccountName;
+  achRoutingNumber;
+  achAccountNumber;
+  achOwnershipType;
+  achAccountType;
+  achBankName;
+  status;
+  statusDate;
+  enabled;
+  isDefault;
+  addr1;
+  addr2;
+  addr3;
+  city;
+  state;
+  zip;
+  static fromRaw(data) {
+    return new _PaymentMethod(
+      arrInt(data, "id"),
+      arrString(data, "type"),
+      arrString(data, "token"),
+      arrString(data, "first_name"),
+      arrString(data, "last_name"),
+      arrString(data, "cc_name_on_card"),
+      arrString(data, "cc_last_four"),
+      arrString(data, "cc_expiration_date"),
+      arrString(data, "cc_brand"),
+      arrString(data, "ach_bank_account_name"),
+      arrString(data, "ach_routing_number"),
+      arrString(data, "ach_account_number"),
+      arrString(data, "ach_ownership_type"),
+      arrString(data, "ach_account_type"),
+      arrString(data, "ach_bank_name"),
+      arrString(data, "status"),
+      arrString(data, "status_date"),
+      arrBool(data, "enabled"),
+      arrBool(data, "default"),
+      arrString(data, "addr1"),
+      arrString(data, "addr2"),
+      arrString(data, "addr3"),
+      arrString(data, "city"),
+      arrString(data, "state"),
+      arrString(data, "zip")
+    );
+  }
+};
+
+// src/resources/payment-methods.ts
+var PaymentMethods = class extends AbstractResource {
+  async list(sid, filters) {
+    return this.paginate("GET", "payment-method/list", this.envelope({ sid }, filters), PaymentMethod.fromRaw);
+  }
+  async show(sid, paymentMethodId, filters) {
+    const raw = await this.transport.request("GET", "payment-method/show", this.envelope({ sid, payment_method_id: paymentMethodId }, filters));
+    return PaymentMethod.fromRaw(raw["data"] ?? {});
+  }
+  async create(sid, attributes) {
+    const raw = await this.transport.request("POST", "payment-method/create", this.envelope({ sid, ...attributes }));
+    return PaymentMethod.fromRaw(raw["data"] ?? {});
+  }
+  async update(sid, attributes) {
+    const raw = await this.transport.request("PATCH", "payment-method/update", this.envelope({ sid, ...attributes }));
+    return PaymentMethod.fromRaw(raw["data"] ?? {});
+  }
+  async delete(sid, paymentMethodId, uuid) {
+    const raw = await this.transport.request("POST", "payment-method/delete", this.envelope({ sid, payment_method_id: paymentMethodId, uuid }));
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+};
+
+// src/data-objects/recurring-payment-method.ts
+var RecurringPaymentMethod = class _RecurringPaymentMethod {
+  constructor(id, type, lastFour, expiration, zip, nameOnCard, bankAccountName, routingNumber, accountNumber, ownershipType, accountType, bankName) {
+    this.id = id;
+    this.type = type;
+    this.lastFour = lastFour;
+    this.expiration = expiration;
+    this.zip = zip;
+    this.nameOnCard = nameOnCard;
+    this.bankAccountName = bankAccountName;
+    this.routingNumber = routingNumber;
+    this.accountNumber = accountNumber;
+    this.ownershipType = ownershipType;
+    this.accountType = accountType;
+    this.bankName = bankName;
+  }
+  id;
+  type;
+  lastFour;
+  expiration;
+  zip;
+  nameOnCard;
+  bankAccountName;
+  routingNumber;
+  accountNumber;
+  ownershipType;
+  accountType;
+  bankName;
+  static fromRaw(data) {
+    return new _RecurringPaymentMethod(
+      arrInt(data, "id"),
+      arrString(data, "type"),
+      arrString(data, "last_four"),
+      arrString(data, "expiration"),
+      arrString(data, "zip"),
+      arrString(data, "name_on_card"),
+      arrString(data, "bank_account_name"),
+      arrString(data, "routing_number"),
+      arrString(data, "account_number"),
+      arrString(data, "ownership_type"),
+      arrString(data, "account_type"),
+      arrString(data, "bank_name")
+    );
+  }
+};
+
+// src/data-objects/recurring-payment.ts
+var RecurringPayment = class _RecurringPayment {
+  constructor(id, name, amount, startDate, endDate, recurrenceSchedule, lastRunDate, lastRunStatus, lastRunFailedCount, nextRunDate, status, pausedUntilDate, customerUuid, cancelledAt, error, paymentMethod = new RecurringPaymentMethod(), shippingAddress = new TransactionAddress()) {
+    this.id = id;
+    this.name = name;
+    this.amount = amount;
+    this.startDate = startDate;
+    this.endDate = endDate;
+    this.recurrenceSchedule = recurrenceSchedule;
+    this.lastRunDate = lastRunDate;
+    this.lastRunStatus = lastRunStatus;
+    this.lastRunFailedCount = lastRunFailedCount;
+    this.nextRunDate = nextRunDate;
+    this.status = status;
+    this.pausedUntilDate = pausedUntilDate;
+    this.customerUuid = customerUuid;
+    this.cancelledAt = cancelledAt;
+    this.error = error;
+    this.paymentMethod = paymentMethod;
+    this.shippingAddress = shippingAddress;
+  }
+  id;
+  name;
+  amount;
+  startDate;
+  endDate;
+  recurrenceSchedule;
+  lastRunDate;
+  lastRunStatus;
+  lastRunFailedCount;
+  nextRunDate;
+  status;
+  pausedUntilDate;
+  customerUuid;
+  cancelledAt;
+  error;
+  paymentMethod;
+  shippingAddress;
+  static fromRaw(data) {
+    return new _RecurringPayment(
+      arrInt(data, "id"),
+      arrString(data, "name"),
+      arrString(data, "amount"),
+      arrString(data, "start_date"),
+      arrString(data, "end_date"),
+      arrString(data, "recurrence_schedule"),
+      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, "customer_uuid"),
+      arrString(data, "cancelled_at"),
+      arrString(data, "error"),
+      RecurringPaymentMethod.fromRaw(arrObjectFrom(data, ["payment_method"])),
+      TransactionAddress.fromRaw(arrObjectFrom(data, ["shipping_address"]))
+    );
+  }
+};
+
+// src/resources/recurring-payments.ts
+var RecurringPayments = class extends AbstractResource {
+  async list(sid, filters = {}) {
+    return this.paginate("GET", "recurring-payment/list", this.envelope({ sid }, filters), RecurringPayment.fromRaw);
+  }
+  async show(sid, recurringPaymentId) {
+    const raw = await this.transport.request("GET", "recurring-payment/show", this.envelope({ sid, recurring_payment_id: recurringPaymentId }));
+    return RecurringPayment.fromRaw(raw["data"] ?? {});
+  }
+  async create(sid, attributes) {
+    const raw = await this.transport.request("POST", "recurring-payment/create", this.envelope({ sid, ...attributes }));
+    return RecurringPayment.fromRaw(raw["data"] ?? {});
+  }
+  async edit(sid, recurringPaymentId, attributes) {
+    const raw = await this.transport.request("PATCH", "recurring-payment/edit", this.envelope({ sid, recurring_payment_id: recurringPaymentId, ...attributes }));
+    return RecurringPayment.fromRaw(raw["data"] ?? {});
+  }
+  async pause(sid, recurringPaymentId, pauseUntilDate) {
+    const raw = await this.transport.request("PATCH", "recurring-payment/pause", this.envelope({ sid, recurring_payment_id: recurringPaymentId, pause_until_date: pauseUntilDate }));
+    return RecurringPayment.fromRaw(raw["data"] ?? {});
+  }
+  async cancel(sid, recurringPaymentId) {
+    const raw = await this.transport.request("PATCH", "recurring-payment/cancel", this.envelope({ sid, recurring_payment_id: recurringPaymentId }));
+    return RecurringPayment.fromRaw(raw["data"] ?? {});
+  }
+  async activate(sid, recurringPaymentId) {
+    const raw = await this.transport.request("PATCH", "recurring-payment/activate", this.envelope({ sid, recurring_payment_id: recurringPaymentId }));
+    return RecurringPayment.fromRaw(raw["data"] ?? {});
+  }
+  async delete(sid, recurringPaymentId) {
+    const raw = await this.transport.request("POST", "recurring-payment/delete", this.envelope({ sid, recurring_payment_id: recurringPaymentId }));
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+};
+
+// src/data-objects/tokenize-result.ts
+var TokenizeResult = class _TokenizeResult {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  static fromRaw(data) {
+    return new _TokenizeResult(arrString(data, "token"));
+  }
+};
+
+// src/resources/transactions.ts
+var Transactions = class extends AbstractResource {
+  async list(sid, filters = {}) {
+    return this.paginate("GET", "transactions", this.envelope({ sid }, filters), Transaction.fromRaw);
+  }
+  async show(sid, identifier) {
+    const raw = await this.transport.request("GET", "transaction", this.envelope({ sid, ...identifier }));
+    return Transaction.fromRaw(raw["data"] ?? {});
+  }
+  async chargeCard(sid, attributes) {
+    const raw = await this.transport.request("POST", "transaction/charge-card", this.envelope({ sid, ...attributes }));
+    return Transaction.fromRaw(raw["data"] ?? {});
+  }
+  /** @deprecated The API marks this deprecated; prefer chargeCard() with a token. */
+  async chargeCardToken(sid, attributes) {
+    const raw = await this.transport.request("POST", "transaction/charge-card-token", this.envelope({ sid, ...attributes }));
+    return Transaction.fromRaw(raw["data"] ?? {});
+  }
+  async chargeAch(sid, attributes) {
+    const raw = await this.transport.request("POST", "transaction/charge-ach", this.envelope({ sid, ...attributes }));
+    return Transaction.fromRaw(raw["data"] ?? {});
+  }
+  async tokenizeCard(sid, attributes) {
+    const raw = await this.transport.request("POST", "transaction/tokenize-card", this.envelope({ sid, ...attributes }));
+    return TokenizeResult.fromRaw(raw["data"] ?? {});
+  }
+  async refund(sid, attributes) {
+    const raw = await this.transport.request("POST", "transaction/refund", this.envelope({ sid, ...attributes }));
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+  async void(sid, transactionType, transactionId) {
+    const raw = await this.transport.request("PATCH", "transaction/void", this.envelope({ sid, transaction_type: transactionType, transaction_id: transactionId }));
+    return MessageResult.fromRaw(raw["data"] ?? raw);
+  }
+};
+
+// src/client.ts
+var Client = class {
+  transactions;
+  customers;
+  paymentMethods;
+  merchants;
+  addresses;
+  deposits;
+  recurringPayments;
+  _config;
+  constructor(token, baseUrl = DEFAULT_BASE_URL) {
+    this._config = token instanceof Config ? token : new Config(token, baseUrl);
+    const transport = new Transport(this._config);
+    this.transactions = new Transactions(transport);
+    this.customers = new Customers(transport);
+    this.paymentMethods = new PaymentMethods(transport);
+    this.merchants = new Merchants(transport);
+    this.addresses = new Addresses(transport);
+    this.deposits = new Deposits(transport);
+    this.recurringPayments = new RecurringPayments(transport);
+  }
+  config() {
+    return this._config;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});
+//# sourceMappingURL=index.cjs.map