@soledgic/sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,2227 @@
+"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, {
+  AuthenticationError: () => AuthenticationError,
+  ConflictError: () => ConflictError,
+  DEFAULT_API_VERSION: () => DEFAULT_API_VERSION,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  NotFoundError: () => NotFoundError,
+  Soledgic: () => Soledgic,
+  SoledgicError: () => SoledgicError,
+  ValidationError: () => ValidationError,
+  default: () => client_default,
+  hmacHex: () => hmacHex,
+  isArrayBufferView: () => isArrayBufferView,
+  mapWebhookDelivery: () => mapWebhookDelivery,
+  mapWebhookEndpoint: () => mapWebhookEndpoint,
+  parseWebhookEvent: () => parseWebhookEvent,
+  parseWebhookSignatureHeader: () => parseWebhookSignatureHeader,
+  resolveWebhookEndpointUrl: () => resolveWebhookEndpointUrl,
+  timingSafeEqual: () => timingSafeEqual,
+  verifyWebhookSignature: () => verifyWebhookSignature,
+  webhookPayloadToString: () => webhookPayloadToString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SoledgicError = class extends Error {
+  constructor(message, status, details, code) {
+    super(message);
+    this.status = status;
+    this.details = details;
+    this.code = code;
+    this.name = "SoledgicError";
+  }
+};
+var ValidationError = class extends SoledgicError {
+  constructor(message, details, code = "VALIDATION_ERROR") {
+    super(message, 400, details, code);
+    this.name = "ValidationError";
+  }
+};
+var AuthenticationError = class extends SoledgicError {
+  constructor(message = "Invalid API key", details, code = "AUTHENTICATION_ERROR") {
+    super(message, 401, details, code);
+    this.name = "AuthenticationError";
+  }
+};
+var NotFoundError = class extends SoledgicError {
+  constructor(message, details, code = "NOT_FOUND") {
+    super(message, 404, details, code);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends SoledgicError {
+  constructor(message, details, code = "CONFLICT") {
+    super(message, 409, details, code);
+    this.name = "ConflictError";
+  }
+};
+
+// src/webhooks.ts
+function isArrayBufferView(value) {
+  return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+}
+function webhookPayloadToString(payload) {
+  if (typeof payload === "string") {
+    return payload;
+  }
+  if (payload instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(payload));
+  }
+  if (isArrayBufferView(payload)) {
+    return new TextDecoder().decode(payload);
+  }
+  return JSON.stringify(payload);
+}
+function timingSafeEqual(a, b) {
+  const aLen = a.length;
+  const bLen = b.length;
+  const maxLen = Math.max(aLen, bLen);
+  let result = aLen ^ bLen;
+  for (let i = 0; i < maxLen; i++) {
+    const aChar = i < aLen ? a.charCodeAt(i) : 0;
+    const bChar = i < bLen ? b.charCodeAt(i) : 0;
+    result |= aChar ^ bChar;
+  }
+  return result === 0;
+}
+async function hmacHex(secret, payload) {
+  if (!globalThis.crypto?.subtle) {
+    throw new Error("Web Crypto API is not available in this runtime");
+  }
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await globalThis.crypto.subtle.sign("HMAC", key, new TextEncoder().encode(payload));
+  return Array.from(new Uint8Array(signature)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function parseWebhookSignatureHeader(signatureHeader) {
+  if (!signatureHeader) {
+    return { timestamp: null, v1Signatures: [] };
+  }
+  let timestamp = null;
+  const v1Signatures = [];
+  for (const part of signatureHeader.split(",")) {
+    const [key, value] = part.trim().split("=");
+    if (!key || !value) continue;
+    if (key === "t") {
+      const numeric = Number(value);
+      timestamp = Number.isFinite(numeric) ? numeric : null;
+    } else if (key === "v1") {
+      v1Signatures.push(value);
+    }
+  }
+  return { timestamp, v1Signatures };
+}
+function toEpochSeconds(value) {
+  if (value instanceof Date) {
+    return Math.floor(value.getTime() / 1e3);
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.floor(value);
+  }
+  return Math.floor(Date.now() / 1e3);
+}
+async function verifyWebhookSignature(payload, signatureHeader, secret, options = {}) {
+  const payloadString = webhookPayloadToString(payload);
+  const parsed = parseWebhookSignatureHeader(signatureHeader);
+  if (parsed.timestamp === null || parsed.v1Signatures.length === 0) {
+    return false;
+  }
+  const toleranceSeconds = options.toleranceSeconds ?? 300;
+  if (toleranceSeconds > 0) {
+    const nowSeconds = toEpochSeconds(options.now);
+    if (Math.abs(nowSeconds - parsed.timestamp) > toleranceSeconds) {
+      return false;
+    }
+  }
+  const expected = await hmacHex(secret, `${parsed.timestamp}.${payloadString}`);
+  return parsed.v1Signatures.some((signature) => timingSafeEqual(signature, expected));
+}
+function parseWebhookEvent(payload) {
+  const payloadString = webhookPayloadToString(payload);
+  const parsed = JSON.parse(payloadString);
+  const type = typeof parsed.type === "string" ? parsed.type : typeof parsed.event === "string" ? parsed.event : "unknown";
+  return {
+    id: typeof parsed.id === "string" ? parsed.id : null,
+    type,
+    createdAt: typeof parsed.created_at === "string" ? parsed.created_at : null,
+    livemode: typeof parsed.livemode === "boolean" ? parsed.livemode : null,
+    data: parsed.data ?? null,
+    raw: parsed
+  };
+}
+
+// src/helpers.ts
+function mapWebhookEndpoint(endpoint) {
+  return {
+    id: String(endpoint?.id ?? ""),
+    url: typeof endpoint?.url === "string" ? endpoint.url : "",
+    description: typeof endpoint?.description === "string" ? endpoint.description : null,
+    events: Array.isArray(endpoint?.events) ? endpoint.events.filter((event) => typeof event === "string") : [],
+    isActive: Boolean(endpoint?.is_active),
+    createdAt: typeof endpoint?.created_at === "string" ? endpoint.created_at : "",
+    secretRotatedAt: typeof endpoint?.secret_rotated_at === "string" ? endpoint.secret_rotated_at : null
+  };
+}
+function resolveWebhookEndpointUrl(webhookEndpoints, endpointUrl) {
+  if (typeof endpointUrl === "string") {
+    return endpointUrl;
+  }
+  if (Array.isArray(webhookEndpoints)) {
+    const first = webhookEndpoints[0];
+    return typeof first?.url === "string" ? first.url : null;
+  }
+  if (webhookEndpoints && typeof webhookEndpoints === "object" && typeof webhookEndpoints.url === "string") {
+    return webhookEndpoints.url;
+  }
+  return null;
+}
+function mapWebhookDelivery(delivery) {
+  return {
+    id: String(delivery?.id ?? ""),
+    endpointId: typeof delivery?.endpoint_id === "string" ? delivery.endpoint_id : null,
+    endpointUrl: resolveWebhookEndpointUrl(delivery?.webhook_endpoints, delivery?.endpoint_url),
+    eventType: typeof delivery?.event_type === "string" ? delivery.event_type : "unknown",
+    status: typeof delivery?.status === "string" ? delivery.status : "unknown",
+    attempts: Number(delivery?.attempts || 0),
+    maxAttempts: typeof delivery?.max_attempts === "number" ? delivery.max_attempts : null,
+    responseStatus: typeof delivery?.response_status === "number" ? delivery.response_status : null,
+    responseBody: typeof delivery?.response_body === "string" ? delivery.response_body : null,
+    responseTimeMs: typeof delivery?.response_time_ms === "number" ? delivery.response_time_ms : null,
+    createdAt: typeof delivery?.created_at === "string" ? delivery.created_at : "",
+    deliveredAt: typeof delivery?.delivered_at === "string" ? delivery.delivered_at : null,
+    nextRetryAt: typeof delivery?.next_retry_at === "string" ? delivery.next_retry_at : null,
+    payload: delivery?.payload && typeof delivery.payload === "object" ? delivery.payload : null
+  };
+}
+
+// src/client.ts
+var DEFAULT_API_VERSION = "2026-03-01";
+var DEFAULT_BASE_URL = "https://api.soledgic.com/v1";
+var Soledgic = class {
+  constructor(config) {
+    this.webhooks = {
+      verifySignature: (payload, signatureHeader, secret, options) => verifyWebhookSignature(payload, signatureHeader, secret, options),
+      parseEvent: (payload) => parseWebhookEvent(payload)
+    };
+    if (!config.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    let key = config.apiKey;
+    this._getKey = () => {
+      if (!key) throw new Error("Client has been destroyed");
+      return key;
+    };
+    this._destroyKey = () => {
+      key = null;
+    };
+    this.baseUrl = (config.baseUrl?.trim() || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeoutMs = config.timeout ?? 3e4;
+    this.apiVersion = (config.apiVersion || "").trim() || DEFAULT_API_VERSION;
+  }
+  /** Clear the API key from memory. After calling destroy(), all requests will throw. */
+  destroy() {
+    this._destroyKey?.();
+  }
+  throwTypedError(message, status, data) {
+    const apiCode = typeof data?.error_code === "string" ? data.error_code : typeof data?.code === "string" ? data.code : void 0;
+    switch (status) {
+      case 400:
+        throw new ValidationError(message, data, apiCode);
+      case 401:
+        throw new AuthenticationError(message, data, apiCode);
+      case 404:
+        throw new NotFoundError(message, data, apiCode);
+      case 409:
+        throw new ConflictError(message, data, apiCode);
+      default:
+        throw new SoledgicError(message, status, data, apiCode);
+    }
+  }
+  async request(endpoint, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}/${endpoint}`, {
+        method: "POST",
+        headers: {
+          "x-api-key": this._getKey(),
+          "Content-Type": "application/json",
+          "Soledgic-Version": this.apiVersion
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        this.throwTypedError(
+          data.error || `Request failed: ${response.status}`,
+          response.status,
+          data
+        );
+      }
+      return data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async requestGet(endpoint, params) {
+    const url = new URL(`${this.baseUrl}/${endpoint}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          "x-api-key": this._getKey(),
+          "Soledgic-Version": this.apiVersion
+        },
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        this.throwTypedError(
+          data.error || `Request failed: ${response.status}`,
+          response.status,
+          data
+        );
+      }
+      return data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async requestRaw(endpoint, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}/${endpoint}`, {
+        method: "POST",
+        headers: {
+          "x-api-key": this._getKey(),
+          "Content-Type": "application/json",
+          "Soledgic-Version": this.apiVersion
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        let parsed;
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          parsed = { error: text };
+        }
+        this.throwTypedError(
+          parsed.error || `Request failed: ${response.status}`,
+          response.status,
+          parsed
+        );
+      }
+      return response;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async requestGetRaw(endpoint, params) {
+    const url = new URL(`${this.baseUrl}/${endpoint}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          "x-api-key": this._getKey(),
+          "Soledgic-Version": this.apiVersion
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        let parsed;
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          parsed = { error: text };
+        }
+        this.throwTypedError(
+          parsed.error || `Request failed: ${response.status}`,
+          response.status,
+          parsed
+        );
+      }
+      return response;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async requestDelete(endpoint) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}/${endpoint}`, {
+        method: "DELETE",
+        headers: {
+          "x-api-key": this._getKey(),
+          "Soledgic-Version": this.apiVersion
+        },
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        this.throwTypedError(
+          data.error || `Request failed: ${response.status}`,
+          response.status,
+          data
+        );
+      }
+      return data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // === STANDARD MODE - INCOME & EXPENSES ===
+  async recordIncome(req) {
+    return this.request("record-income", {
+      reference_id: req.referenceId,
+      amount: req.amount,
+      description: req.description,
+      category: req.category,
+      customer_id: req.customerId,
+      customer_name: req.customerName,
+      received_to: req.receivedTo,
+      invoice_id: req.invoiceId,
+      transaction_date: req.transactionDate,
+      metadata: req.metadata
+    });
+  }
+  async recordExpense(req) {
+    return this.request("record-expense", {
+      reference_id: req.referenceId,
+      amount: req.amount,
+      description: req.description,
+      category: req.category,
+      vendor_id: req.vendorId,
+      vendor_name: req.vendorName,
+      paid_from: req.paidFrom,
+      receipt_url: req.receiptUrl,
+      tax_deductible: req.taxDeductible,
+      transaction_date: req.transactionDate,
+      metadata: req.metadata,
+      authorizing_instrument_id: req.authorizingInstrumentId,
+      risk_evaluation_id: req.riskEvaluationId,
+      authorization_decision_id: req.authorizationDecisionId
+    });
+  }
+  async recordBill(req) {
+    return this.request("record-bill", {
+      amount: req.amount,
+      description: req.description,
+      vendor_name: req.vendorName,
+      vendor_id: req.vendorId,
+      reference_id: req.referenceId,
+      due_date: req.dueDate,
+      expense_category: req.expenseCategory,
+      paid: req.paid,
+      metadata: req.metadata,
+      authorizing_instrument_id: req.authorizingInstrumentId,
+      risk_evaluation_id: req.riskEvaluationId,
+      authorization_decision_id: req.authorizationDecisionId
+    });
+  }
+  // === AUTHORIZING INSTRUMENTS ===
+  // Register financial authorization instruments for transaction validation
+  // Instruments are immutable and ledger-adjacent - they explain WHY money moved
+  async registerInstrument(req) {
+    return this.request("register-instrument", {
+      external_ref: req.externalRef,
+      extracted_terms: {
+        amount: req.extractedTerms.amount,
+        currency: req.extractedTerms.currency,
+        cadence: req.extractedTerms.cadence,
+        counterparty_name: req.extractedTerms.counterpartyName
+      }
+    });
+  }
+  // === SHADOW LEDGER (GHOST ENTRIES) ===
+  // Project future obligations based on authorizing instrument terms.
+  // Ghost entries NEVER affect balances or entries - only express future intent.
+  async projectIntent(req) {
+    const response = await this.request("project-intent", {
+      authorizing_instrument_id: req.authorizingInstrumentId,
+      until_date: req.untilDate,
+      horizon_count: req.horizonCount
+    });
+    return {
+      success: response.success,
+      instrumentId: response.instrument_id,
+      externalRef: response.external_ref,
+      cadence: response.cadence,
+      projectionsCreated: response.projections_created,
+      projectionsRequested: response.projections_requested,
+      duplicatesSkipped: response.duplicates_skipped,
+      dateRange: response.date_range,
+      projectedDates: response.projected_dates
+    };
+  }
+  // === REVERSALS & CORRECTIONS ===
+  async reverseTransaction(req) {
+    const response = await this.request("reverse-transaction", {
+      transaction_id: req.transactionId,
+      reason: req.reason,
+      partial_amount: req.partialAmount,
+      idempotency_key: req.idempotencyKey,
+      metadata: req.metadata
+    });
+    return {
+      success: response.success,
+      voidType: response.void_type,
+      message: response.message,
+      transactionId: response.transaction_id ?? response.original_transaction_id ?? req.transactionId,
+      reversalId: response.reversal_id ?? null,
+      reversedAmount: response.reversed_amount ?? null,
+      isPartial: response.is_partial ?? null,
+      voidedAt: response.voided_at ?? null,
+      reversedAt: response.reversed_at ?? null,
+      warning: response.warning ?? null
+    };
+  }
+  // === PERIOD MANAGEMENT ===
+  async listPeriods() {
+    return this.request("close-period", { action: "list" });
+  }
+  async createPeriod(req) {
+    return this.request("close-period", {
+      action: "create",
+      start_date: req.startDate,
+      end_date: req.endDate,
+      name: req.name
+    });
+  }
+  async closePeriod(year, month, quarter) {
+    return this.request("close-period", { year, month, quarter });
+  }
+  // === RECONCILIATION ===
+  async matchTransaction(req) {
+    const response = await this.request("reconciliations/matches", {
+      transaction_id: req.transactionId,
+      bank_transaction_id: req.bankTransactionId
+    });
+    return {
+      success: response.success,
+      match: {
+        id: response.match.id,
+        transactionId: response.match.transaction_id,
+        bankTransactionId: response.match.bank_transaction_id,
+        status: response.match.status,
+        matchedAt: response.match.matched_at
+      }
+    };
+  }
+  async unmatchTransaction(transactionId) {
+    const response = await this.requestDelete(`reconciliations/matches/${transactionId}`);
+    return {
+      success: response.success,
+      deleted: Boolean(response.deleted),
+      transactionId: response.transaction_id
+    };
+  }
+  async listUnmatchedTransactions() {
+    const response = await this.requestGet("reconciliations/unmatched");
+    return {
+      success: response.success,
+      unmatchedCount: response.unmatched_count ?? 0,
+      transactions: (response.transactions || []).map((transaction) => ({
+        id: transaction.id,
+        referenceId: transaction.reference_id ?? null,
+        description: transaction.description ?? null,
+        amount: transaction.amount,
+        currency: transaction.currency || "USD",
+        createdAt: transaction.created_at,
+        status: transaction.status,
+        metadata: transaction.metadata || {}
+      }))
+    };
+  }
+  async createReconciliationSnapshot(req) {
+    const response = await this.request("reconciliations/snapshots", {
+      period_id: req.periodId,
+      as_of_date: req.asOfDate
+    });
+    return {
+      success: response.success,
+      snapshot_id: response.snapshot.id,
+      integrity_hash: response.snapshot.integrity_hash
+    };
+  }
+  async getReconciliationSnapshot(periodId) {
+    const response = await this.requestGet(`reconciliations/snapshots/${periodId}`);
+    return {
+      success: response.success,
+      snapshot: {
+        id: response.snapshot.id,
+        periodStart: response.snapshot.period_start,
+        periodEnd: response.snapshot.period_end,
+        integrityHash: response.snapshot.integrity_hash,
+        integrityValid: Boolean(response.snapshot.integrity_valid),
+        summary: {
+          totalMatched: response.snapshot.summary?.total_matched ?? 0,
+          totalUnmatched: response.snapshot.summary?.total_unmatched ?? 0,
+          matchedAmount: response.snapshot.summary?.matched_amount ?? 0,
+          unmatchedAmount: response.snapshot.summary?.unmatched_amount ?? 0
+        }
+      }
+    };
+  }
+  async autoMatchBankTransaction(bankAggregatorTransactionId) {
+    const response = await this.request("reconciliations/auto-match", {
+      bank_aggregator_transaction_id: bankAggregatorTransactionId
+    });
+    return {
+      success: response.success,
+      result: {
+        matched: Boolean(response.result?.matched),
+        matchType: response.result?.match_type ?? null,
+        matchedTransactionId: response.result?.matched_transaction_id ?? null,
+        bankAggregatorTransactionId: response.result?.bank_aggregator_transaction_id ?? bankAggregatorTransactionId
+      }
+    };
+  }
+  // === FROZEN STATEMENTS ===
+  async generateFrozenStatements(periodId) {
+    return this.request("frozen-statements", {
+      action: "generate",
+      period_id: periodId
+    });
+  }
+  async getFrozenStatement(periodId, statementType) {
+    return this.request("frozen-statements", {
+      action: "get",
+      period_id: periodId,
+      statement_type: statementType
+    });
+  }
+  async listFrozenStatements(periodId) {
+    return this.request("frozen-statements", {
+      action: "list",
+      period_id: periodId
+    });
+  }
+  async verifyFrozenStatements(periodId) {
+    return this.request("frozen-statements", {
+      action: "verify",
+      period_id: periodId
+    });
+  }
+  // === SPLITS MANAGEMENT ===
+  async listTiers() {
+    return this.request("manage-splits", { action: "list_tiers" });
+  }
+  async getEffectiveSplit(creatorId) {
+    return this.request("manage-splits", { action: "get_effective_split", creator_id: creatorId });
+  }
+  async setCreatorSplit(creatorId, splitPercent) {
+    return this.request("manage-splits", { action: "set_creator_split", creator_id: creatorId, split_percent: splitPercent });
+  }
+  async clearCreatorSplit(creatorId) {
+    return this.request("manage-splits", { action: "clear_creator_split", creator_id: creatorId });
+  }
+  async autoPromoteCreators() {
+    return this.request("manage-splits", { action: "auto_promote" });
+  }
+  async getSummary() {
+    const response = await this.requestGet("participants");
+    const participants = Array.isArray(response.participants) ? response.participants : [];
+    const summary = participants.reduce((totals, participant) => ({
+      total_ledger_balance: totals.total_ledger_balance + Number(participant.ledger_balance || 0),
+      total_held_amount: totals.total_held_amount + Number(participant.held_amount || 0),
+      total_available_balance: totals.total_available_balance + Number(participant.available_balance || 0)
+    }), {
+      total_ledger_balance: 0,
+      total_held_amount: 0,
+      total_available_balance: 0
+    });
+    return {
+      success: response.success,
+      data: {
+        ...summary,
+        participant_count: participants.length
+      }
+    };
+  }
+  // === REPORTS ===
+  async getProfitLoss(startDate, endDate) {
+    return this.request("generate-report", { report_type: "profit_loss", start_date: startDate, end_date: endDate });
+  }
+  async getTrialBalance(asOf) {
+    return this.request("generate-report", { report_type: "trial_balance", as_of: asOf });
+  }
+  async get1099Summary(year) {
+    return this.request("generate-report", { report_type: "1099_summary", tax_year: year });
+  }
+  async getCreatorEarnings(startDate, endDate) {
+    return this.request("generate-report", { report_type: "creator_earnings", start_date: startDate, end_date: endDate });
+  }
+  async getHistoricalEarnings(options = {}) {
+    return this.requestGet("earnings", {
+      start_date: options.startDate,
+      end_date: options.endDate,
+      creator_id: options.creatorId,
+      granularity: options.granularity
+    });
+  }
+  async getTransactions(startDate, endDate, creatorId) {
+    return this.request("generate-report", { report_type: "transaction_history", start_date: startDate, end_date: endDate, creator_id: creatorId });
+  }
+  // === CREDITS ===
+  /** Issue credits to a user. 1000 credits = $1 USD (Soledgic standard rate). */
+  async issueCredits(userId, credits, options = {}) {
+    return this.request("credits", {
+      action: "issue",
+      user_id: userId,
+      credits,
+      reason: options.reason,
+      reference_id: options.referenceId
+    });
+  }
+  /** Convert earned credits to spendable balance. Minimum 5000 credits ($5). */
+  async convertCredits(userId, credits) {
+    return this.request("credits", {
+      action: "convert",
+      user_id: userId,
+      credits
+    });
+  }
+  /** Spend spendable balance on creator content. Amount in cents. Split applies. */
+  async redeemCredits(userId, creatorId, amountCents, referenceId, options = {}) {
+    return this.request("credits", {
+      action: "redeem",
+      user_id: userId,
+      creator_id: creatorId,
+      amount: amountCents,
+      reference_id: referenceId,
+      description: options.description,
+      split_percent: options.splitPercent
+    });
+  }
+  /** Get user's credit balance (unconverted) and spendable balance (converted). */
+  async getCreditBalance(userId) {
+    return this.request("credits", { action: "balance", user_id: userId });
+  }
+  // === PDF EXPORTS ===
+  async generatePDF(reportType, options = {}) {
+    return this.request("generate-pdf", {
+      report_type: reportType,
+      creator_id: options.creatorId,
+      start_date: options.startDate,
+      end_date: options.endDate,
+      tax_year: options.taxYear,
+      period_id: options.periodId
+    });
+  }
+  async getCreatorStatement(creatorId, startDate, endDate) {
+    return this.generatePDF("creator_statement", { creatorId, startDate, endDate });
+  }
+  async getProfitLossPDF(startDate, endDate, periodId) {
+    return this.generatePDF("profit_loss", { startDate, endDate, periodId });
+  }
+  async getTrialBalancePDF() {
+    return this.generatePDF("trial_balance", {});
+  }
+  async get1099PDF(taxYear) {
+    return this.generatePDF("1099", { taxYear });
+  }
+  // === AUTO-EMAIL ===
+  async configureEmail(config) {
+    return this.request("send-statements", {
+      action: "configure",
+      email_config: {
+        enabled: config.enabled,
+        send_day: config.sendDay || 1,
+        from_name: config.fromName,
+        from_email: config.fromEmail,
+        subject_template: config.subjectTemplate,
+        body_template: config.bodyTemplate,
+        cc_admin: config.ccAdmin,
+        admin_email: config.adminEmail
+      }
+    });
+  }
+  async sendMonthlyStatements(year, month) {
+    return this.request("send-statements", {
+      action: "send_monthly_statements",
+      year,
+      month
+    });
+  }
+  async sendCreatorStatement(creatorId, year, month) {
+    return this.request("send-statements", {
+      action: "send_single_statement",
+      creator_id: creatorId,
+      year,
+      month
+    });
+  }
+  async previewStatementEmail(creatorId, year, month) {
+    return this.request("send-statements", {
+      action: "preview",
+      creator_id: creatorId,
+      year,
+      month
+    });
+  }
+  async getEmailHistory() {
+    return this.request("send-statements", { action: "get_queue" });
+  }
+  // === WEBHOOKS ===
+  async listWebhookEndpoints() {
+    const response = await this.request("webhooks", { action: "list" });
+    return {
+      success: response.success,
+      data: Array.isArray(response.data) ? response.data.map(mapWebhookEndpoint) : []
+    };
+  }
+  async createWebhookEndpoint(config) {
+    const response = await this.request("webhooks", {
+      action: "create",
+      url: config.url,
+      description: config.description,
+      events: config.events || ["*"]
+    });
+    return {
+      success: response.success,
+      data: {
+        ...mapWebhookEndpoint(response.data || {}),
+        secret: typeof response.data?.secret === "string" ? response.data.secret : null
+      },
+      message: typeof response.message === "string" ? response.message : void 0
+    };
+  }
+  async updateWebhookEndpoint(endpointId, updates) {
+    const response = await this.request("webhooks", {
+      action: "update",
+      endpoint_id: endpointId,
+      url: updates.url,
+      description: updates.description,
+      events: updates.events,
+      is_active: updates.isActive
+    });
+    return {
+      success: response.success,
+      data: mapWebhookEndpoint(response.data || {})
+    };
+  }
+  async deleteWebhookEndpoint(endpointId) {
+    const response = await this.request("webhooks", { action: "delete", endpoint_id: endpointId });
+    return {
+      success: response.success,
+      message: typeof response.message === "string" ? response.message : void 0
+    };
+  }
+  async testWebhookEndpoint(endpointId) {
+    const response = await this.request("webhooks", { action: "test", endpoint_id: endpointId });
+    return {
+      success: response.success,
+      error: typeof response.error === "string" ? response.error : void 0,
+      data: {
+        delivered: Boolean(response.data?.delivered),
+        status: typeof response.data?.status === "number" ? response.data.status : null,
+        responseTimeMs: typeof response.data?.response_time_ms === "number" ? response.data.response_time_ms : null
+      }
+    };
+  }
+  async getWebhookDeliveries(endpointId, limit) {
+    const response = await this.request("webhooks", {
+      action: "deliveries",
+      endpoint_id: endpointId,
+      limit
+    });
+    return {
+      success: response.success,
+      data: Array.isArray(response.data) ? response.data.map(mapWebhookDelivery) : []
+    };
+  }
+  async retryWebhookDelivery(deliveryId) {
+    const response = await this.request("webhooks", { action: "retry", delivery_id: deliveryId });
+    return {
+      success: response.success,
+      message: typeof response.message === "string" ? response.message : void 0
+    };
+  }
+  async rotateWebhookSecret(endpointId) {
+    const response = await this.request("webhooks", {
+      action: "rotate_secret",
+      endpoint_id: endpointId
+    });
+    return {
+      success: response.success,
+      data: {
+        secret: typeof response.data?.secret === "string" ? response.data.secret : null
+      },
+      message: typeof response.message === "string" ? response.message : void 0
+    };
+  }
+  // === BREACH ALERTS ===
+  // Configure Slack, email, or webhook notifications for breach risk events.
+  // Alerts trigger when project-intent creates projections that exceed cash coverage.
+  async listAlerts() {
+    const response = await this.request("configure-alerts", { action: "list" });
+    return {
+      success: response.success,
+      data: (response.data || []).map((c) => ({
+        id: c.id,
+        alertType: c.alert_type,
+        channel: c.channel,
+        config: c.config,
+        thresholds: {
+          coverageRatioBelow: c.thresholds?.coverage_ratio_below,
+          shortfallAbove: c.thresholds?.shortfall_above
+        },
+        isActive: c.is_active,
+        lastTriggeredAt: c.last_triggered_at,
+        triggerCount: c.trigger_count,
+        createdAt: c.created_at
+      }))
+    };
+  }
+  async createAlert(req) {
+    const config = {};
+    if ("webhookUrl" in req.config) {
+      config.webhook_url = req.config.webhookUrl;
+      config.channel = req.config.channel;
+    } else if ("recipients" in req.config) {
+      config.recipients = req.config.recipients;
+    }
+    const response = await this.request("configure-alerts", {
+      action: "create",
+      alert_type: req.alertType,
+      channel: req.channel,
+      config,
+      thresholds: req.thresholds ? {
+        coverage_ratio_below: req.thresholds.coverageRatioBelow,
+        shortfall_above: req.thresholds.shortfallAbove
+      } : void 0,
+      is_active: req.isActive
+    });
+    return {
+      success: response.success,
+      data: {
+        id: response.data.id,
+        alertType: response.data.alert_type,
+        channel: response.data.channel,
+        config: response.data.config || {},
+        thresholds: {
+          coverageRatioBelow: response.data.thresholds?.coverage_ratio_below,
+          shortfallAbove: response.data.thresholds?.shortfall_above
+        },
+        isActive: response.data.is_active,
+        triggerCount: response.data.trigger_count || 0,
+        createdAt: response.data.created_at
+      }
+    };
+  }
+  async updateAlert(req) {
+    const config = req.config ? {} : void 0;
+    if (req.config) {
+      if ("webhookUrl" in req.config && req.config.webhookUrl) {
+        config.webhook_url = req.config.webhookUrl;
+      }
+      if ("channel" in req.config) {
+        config.channel = req.config.channel;
+      }
+      if ("recipients" in req.config) {
+        config.recipients = req.config.recipients;
+      }
+    }
+    const response = await this.request("configure-alerts", {
+      action: "update",
+      config_id: req.configId,
+      config,
+      thresholds: req.thresholds ? {
+        coverage_ratio_below: req.thresholds.coverageRatioBelow,
+        shortfall_above: req.thresholds.shortfallAbove
+      } : void 0,
+      is_active: req.isActive
+    });
+    return {
+      success: response.success,
+      data: {
+        id: response.data.id,
+        alertType: response.data.alert_type,
+        channel: response.data.channel,
+        config: response.data.config || {},
+        thresholds: {
+          coverageRatioBelow: response.data.thresholds?.coverage_ratio_below,
+          shortfallAbove: response.data.thresholds?.shortfall_above
+        },
+        isActive: response.data.is_active,
+        triggerCount: response.data.trigger_count ?? 0,
+        createdAt: response.data.created_at ?? ""
+      }
+    };
+  }
+  async deleteAlert(configId) {
+    return this.request("configure-alerts", {
+      action: "delete",
+      config_id: configId
+    });
+  }
+  async testAlert(configId) {
+    return this.request("configure-alerts", {
+      action: "test",
+      config_id: configId
+    });
+  }
+  // === PREFLIGHT AUTHORIZATION (Phase 3) ===
+  // Evaluate whether a proposed transaction should be allowed BEFORE execution.
+  // This does NOT move money - only decides if the transaction is permitted.
+  async preflightAuthorization(req) {
+    const response = await this.request("preflight-authorization", {
+      idempotency_key: req.idempotencyKey,
+      amount: req.amount,
+      currency: req.currency,
+      counterparty_name: req.counterpartyName,
+      authorizing_instrument_id: req.authorizingInstrumentId,
+      expected_date: req.expectedDate,
+      category: req.category
+    });
+    return {
+      success: response.success,
+      cached: response.cached,
+      decision: {
+        id: response.decision.id,
+        decision: response.decision.decision,
+        violatedPolicies: (response.decision.violated_policies || []).map((v) => ({
+          policyId: v.policy_id,
+          policyType: v.policy_type,
+          severity: v.severity,
+          reason: v.reason
+        })),
+        expiresAt: response.decision.expires_at,
+        createdAt: response.decision.created_at
+      },
+      message: response.message
+    };
+  }
+  // Convenience method: preflight check then record expense if allowed
+  async preflightAndRecordExpense(preflight, expense) {
+    const preflightResult = await this.preflightAuthorization(preflight);
+    if (preflightResult.decision.decision === "blocked") {
+      return { preflight: preflightResult };
+    }
+    const transaction = await this.recordExpense({
+      ...expense,
+      authorizationDecisionId: preflightResult.decision.id
+    });
+    return { preflight: preflightResult, transaction };
+  }
+  // Convenience method: preflight check then record bill if allowed
+  async preflightAndRecordBill(preflight, bill) {
+    const preflightResult = await this.preflightAuthorization(preflight);
+    if (preflightResult.decision.decision === "blocked") {
+      return { preflight: preflightResult };
+    }
+    const transaction = await this.recordBill({
+      ...bill,
+      authorizationDecisionId: preflightResult.decision.id
+    });
+    return { preflight: preflightResult, transaction };
+  }
+  // === BANK IMPORT ===
+  async getImportTemplates() {
+    return this.request("import-transactions", { action: "get_templates" });
+  }
+  async parseImportFile(fileBase64, format) {
+    return this.request("import-transactions", {
+      action: "parse_preview",
+      data: fileBase64,
+      format
+    });
+  }
+  async importTransactions(transactions) {
+    return this.request("import-transactions", {
+      action: "import",
+      transactions
+    });
+  }
+  async saveImportTemplate(template) {
+    return this.request("import-transactions", {
+      action: "save_template",
+      template
+    });
+  }
+  // === ESCROW / HELD FUNDS ===
+  async getEscrowSummary() {
+    const response = await this.requestGet("holds/summary");
+    return {
+      success: response.success,
+      summary: response.summary || {}
+    };
+  }
+  async getHeldFunds(options) {
+    return this.requestGet("holds", {
+      venture_id: options?.ventureId,
+      participant_id: options?.creatorId,
+      ready_only: options?.readyOnly,
+      limit: options?.limit
+    });
+  }
+  async releaseFunds(entryId, executeTransfer = true) {
+    const response = await this.request(`holds/${entryId}/release`, {
+      execute_transfer: executeTransfer
+    });
+    return {
+      success: response.success,
+      release_id: response.release?.id ?? null,
+      entry_id: response.release?.hold_id ?? entryId,
+      executed: Boolean(response.release?.executed),
+      transfer_id: response.release?.transfer_id ?? null,
+      transfer_status: response.release?.transfer_status ?? null,
+      amount: response.release?.amount ?? null,
+      currency: response.release?.currency ?? null
+    };
+  }
+  // === PAYOUT ELIGIBILITY ===
+  async checkPayoutEligibility(participantId) {
+    const response = await this.requestGet(`participants/${participantId}/payout-eligibility`);
+    return {
+      success: response.success,
+      participant_id: response.eligibility?.participant_id ?? participantId,
+      eligible: Boolean(response.eligibility?.eligible),
+      available_balance: response.eligibility?.available_balance ?? 0,
+      issues: response.eligibility?.issues || [],
+      requirements: response.eligibility?.requirements || {}
+    };
+  }
+  // === HEALTH CHECKS ===
+  async runHealthCheck() {
+    return this.request("health-check", { action: "run" });
+  }
+  async getHealthStatus() {
+    return this.request("health-check", { action: "status" });
+  }
+  async getHealthHistory() {
+    return this.request("health-check", { action: "history" });
+  }
+  // === FINANCIAL REPORTS (DETAILED) ===
+  async getAPAging(asOfDate) {
+    return this.requestGet("ap-aging", { as_of_date: asOfDate });
+  }
+  async getARAging(asOfDate) {
+    return this.requestGet("ar-aging", { as_of_date: asOfDate });
+  }
+  async getBalanceSheet(asOfDate) {
+    return this.requestGet("balance-sheet", { as_of_date: asOfDate });
+  }
+  async getDetailedTrialBalance(options) {
+    return this.requestGet("trial-balance", {
+      as_of: options?.asOf,
+      snapshot: options?.snapshot ? "true" : void 0
+    });
+  }
+  async getDetailedProfitLoss(options) {
+    return this.requestGet("profit-loss", {
+      year: options?.year,
+      month: options?.month,
+      quarter: options?.quarter,
+      start_date: options?.startDate,
+      end_date: options?.endDate,
+      breakdown: options?.breakdown
+    });
+  }
+  async getRunway() {
+    return this.requestGet("get-runway");
+  }
+  // === TREASURY RESOURCES ===
+  async createParticipant(req) {
+    const response = await this.request("participants", {
+      participant_id: req.participantId,
+      user_id: req.userId,
+      display_name: req.displayName,
+      email: req.email,
+      default_split_percent: req.defaultSplitPercent,
+      tax_info: req.taxInfo ? {
+        tax_id_type: req.taxInfo.taxIdType,
+        tax_id_last4: req.taxInfo.taxIdLast4,
+        legal_name: req.taxInfo.legalName,
+        business_type: req.taxInfo.businessType,
+        address: req.taxInfo.address ? {
+          line1: req.taxInfo.address.line1,
+          line2: req.taxInfo.address.line2,
+          city: req.taxInfo.address.city,
+          state: req.taxInfo.address.state,
+          postal_code: req.taxInfo.address.postalCode,
+          country: req.taxInfo.address.country
+        } : void 0
+      } : void 0,
+      payout_preferences: req.payoutPreferences ? {
+        schedule: req.payoutPreferences.schedule,
+        minimum_amount: req.payoutPreferences.minimumAmount,
+        method: req.payoutPreferences.method
+      } : void 0,
+      metadata: req.metadata
+    });
+    const participant = response.participant || {};
+    return {
+      success: response.success,
+      participant: {
+        id: participant.id,
+        accountId: participant.account_id,
+        linkedUserId: participant.linked_user_id ?? null,
+        displayName: participant.display_name,
+        email: participant.email,
+        defaultSplitPercent: participant.default_split_percent,
+        payoutPreferences: participant.payout_preferences || {},
+        createdAt: participant.created_at
+      }
+    };
+  }
+  async listParticipants() {
+    const response = await this.requestGet("participants");
+    return {
+      success: response.success,
+      participants: (response.participants || []).map((participant) => ({
+        id: participant.id,
+        linkedUserId: participant.linked_user_id ?? null,
+        name: participant.name ?? null,
+        tier: participant.tier ?? null,
+        ledgerBalance: participant.ledger_balance,
+        heldAmount: participant.held_amount,
+        availableBalance: participant.available_balance
+      }))
+    };
+  }
+  async getParticipant(participantId) {
+    const response = await this.requestGet(`participants/${participantId}`);
+    const participant = response.participant || {};
+    return {
+      success: response.success,
+      participant: {
+        id: participant.id,
+        linkedUserId: participant.linked_user_id ?? null,
+        name: participant.name ?? null,
+        tier: participant.tier ?? null,
+        customSplitPercent: participant.custom_split_percent ?? null,
+        ledgerBalance: participant.ledger_balance,
+        heldAmount: participant.held_amount,
+        availableBalance: participant.available_balance,
+        holds: (participant.holds || []).map((hold) => ({
+          amount: hold.amount,
+          reason: hold.reason ?? null,
+          releaseDate: hold.release_date ?? null,
+          status: hold.status
+        }))
+      }
+    };
+  }
+  async getParticipantPayoutEligibility(participantId) {
+    const response = await this.requestGet(`participants/${participantId}/payout-eligibility`);
+    return {
+      success: response.success,
+      eligibility: {
+        participantId: response.eligibility?.participant_id ?? participantId,
+        eligible: Boolean(response.eligibility?.eligible),
+        availableBalance: response.eligibility?.available_balance ?? 0,
+        issues: response.eligibility?.issues || [],
+        requirements: response.eligibility?.requirements || {}
+      }
+    };
+  }
+  // === LEDGER MANAGEMENT ===
+  async createLedger(req) {
+    const response = await this.request("create-ledger", {
+      business_name: req.businessName,
+      owner_email: req.ownerEmail,
+      ledger_mode: req.ledgerMode,
+      settings: req.settings ? {
+        default_tax_rate: req.settings.defaultTaxRate,
+        default_split_percent: req.settings.defaultSplitPercent,
+        platform_fee_percent: req.settings.platformFeePercent,
+        min_payout_amount: req.settings.minPayoutAmount,
+        payout_schedule: req.settings.payoutSchedule,
+        tax_withholding_percent: req.settings.taxWithholdingPercent,
+        currency: req.settings.currency,
+        fiscal_year_start: req.settings.fiscalYearStart,
+        receipt_threshold: req.settings.receiptThreshold
+      } : void 0
+    });
+    return {
+      success: response.success,
+      ledger: {
+        id: response.ledger.id,
+        businessName: response.ledger.business_name,
+        ledgerMode: response.ledger.ledger_mode,
+        apiKey: response.ledger.api_key,
+        status: response.ledger.status,
+        createdAt: response.ledger.created_at
+      },
+      warning: response.warning
+    };
+  }
+  // === ACCOUNTING ADJUSTMENTS ===
+  async recordAdjustment(req) {
+    return this.request("record-adjustment", {
+      adjustment_type: req.adjustmentType,
+      adjustment_date: req.adjustmentDate,
+      entries: req.entries.map((e) => ({
+        account_type: e.accountType,
+        entity_id: e.entityId,
+        entry_type: e.entryType,
+        amount: e.amount
+      })),
+      reason: req.reason,
+      original_transaction_id: req.originalTransactionId,
+      supporting_documentation: req.supportingDocumentation,
+      prepared_by: req.preparedBy
+    });
+  }
+  async recordOpeningBalance(req) {
+    return this.request("record-opening-balance", {
+      as_of_date: req.asOfDate,
+      source: req.source,
+      source_description: req.sourceDescription,
+      balances: req.balances.map((b) => ({
+        account_type: b.accountType,
+        entity_id: b.entityId,
+        balance: b.balance
+      }))
+    });
+  }
+  async recordTransfer(req) {
+    return this.request("record-transfer", {
+      from_account_type: req.fromAccountType,
+      to_account_type: req.toAccountType,
+      amount: req.amount,
+      transfer_type: req.transferType,
+      description: req.description,
+      reference_id: req.referenceId
+    });
+  }
+  // === RISK & POLICY ===
+  async evaluateFraud(req) {
+    const response = await this.request("fraud/evaluations", {
+      idempotency_key: req.idempotencyKey,
+      amount: req.amount,
+      currency: req.currency,
+      counterparty_name: req.counterpartyName,
+      authorizing_instrument_id: req.authorizingInstrumentId,
+      expected_date: req.expectedDate,
+      category: req.category
+    });
+    return {
+      success: response.success,
+      cached: response.cached,
+      evaluation: {
+        id: response.evaluation.id,
+        signal: response.evaluation.signal,
+        riskFactors: (response.evaluation.risk_factors || []).map((f) => ({
+          policyId: f.policy_id,
+          policyType: f.policy_type,
+          severity: f.severity,
+          indicator: f.indicator
+        })),
+        validUntil: response.evaluation.valid_until,
+        createdAt: response.evaluation.created_at,
+        acknowledgedAt: response.evaluation.acknowledged_at
+      }
+    };
+  }
+  async createFraudPolicy(req) {
+    const response = await this.request("fraud/policies", {
+      policy_type: req.policyType,
+      config: req.config,
+      severity: req.severity,
+      priority: req.priority
+    });
+    return {
+      success: response.success,
+      policy: {
+        id: response.policy.id,
+        type: response.policy.type,
+        severity: response.policy.severity,
+        priority: response.policy.priority,
+        isActive: Boolean(response.policy.is_active),
+        config: response.policy.config || {},
+        createdAt: response.policy.created_at ?? null,
+        updatedAt: response.policy.updated_at ?? null
+      }
+    };
+  }
+  async listFraudPolicies() {
+    const response = await this.requestGet("fraud/policies");
+    return {
+      success: response.success,
+      policies: (response.policies || []).map((policy) => ({
+        id: policy.id,
+        type: policy.type,
+        severity: policy.severity,
+        priority: policy.priority,
+        isActive: Boolean(policy.is_active),
+        config: policy.config || {},
+        createdAt: policy.created_at ?? null,
+        updatedAt: policy.updated_at ?? null
+      }))
+    };
+  }
+  async deleteFraudPolicy(policyId) {
+    const response = await this.requestDelete(`fraud/policies/${policyId}`);
+    return {
+      success: response.success,
+      deleted: Boolean(response.deleted),
+      policyId: response.policy_id
+    };
+  }
+  // === TAX DOCUMENTS ===
+  async calculateTaxForParticipant(participantId, taxYear) {
+    const response = await this.requestGet(`tax/calculations/${participantId}`, {
+      tax_year: taxYear
+    });
+    return {
+      success: response.success,
+      calculation: {
+        participantId: response.calculation.participant_id,
+        taxYear: response.calculation.tax_year,
+        grossPayments: response.calculation.gross_payments,
+        transactionCount: response.calculation.transaction_count,
+        requires1099: Boolean(response.calculation.requires_1099),
+        monthlyTotals: response.calculation.monthly_totals || {},
+        threshold: response.calculation.threshold,
+        linkedUserId: response.calculation.linked_user_id ?? null,
+        sharedTaxProfile: response.calculation.shared_tax_profile ? {
+          status: response.calculation.shared_tax_profile.status,
+          legalName: response.calculation.shared_tax_profile.legal_name ?? null,
+          taxIdLast4: response.calculation.shared_tax_profile.tax_id_last4 ?? null
+        } : null
+      }
+    };
+  }
+  async generateAllTaxDocuments(taxYear) {
+    const response = await this.request("tax/documents/generate", { tax_year: taxYear });
+    return {
+      success: response.success,
+      generation: {
+        taxYear: response.generation.tax_year,
+        created: response.generation.created,
+        skipped: response.generation.skipped,
+        totalAmount: response.generation.total_amount
+      }
+    };
+  }
+  async listTaxDocuments(taxYear) {
+    const response = await this.requestGet("tax/documents", { tax_year: taxYear });
+    return {
+      success: response.success,
+      taxYear: response.tax_year,
+      summary: {
+        totalDocuments: response.summary?.total_documents ?? 0,
+        totalAmount: response.summary?.total_amount ?? 0,
+        byStatus: {
+          calculated: response.summary?.by_status?.calculated ?? 0,
+          exported: response.summary?.by_status?.exported ?? 0,
+          filed: response.summary?.by_status?.filed ?? 0
+        }
+      },
+      documents: response.documents || []
+    };
+  }
+  async getTaxDocument(documentId) {
+    const response = await this.requestGet(`tax/documents/${documentId}`);
+    return {
+      success: response.success,
+      document: response.document
+    };
+  }
+  async exportTaxDocuments(taxYear, format = "json") {
+    if (format === "csv") {
+      const response = await this.requestGetRaw("tax/documents/export", { tax_year: taxYear, format });
+      const csv = await response.text();
+      const disposition = response.headers.get("Content-Disposition") || "";
+      const filenameMatch = disposition.match(/filename="?([^"]+)"?/);
+      return { csv, filename: filenameMatch?.[1] || `1099_export_${taxYear}.csv` };
+    }
+    return this.requestGet("tax/documents/export", { tax_year: taxYear, format });
+  }
+  async markTaxDocumentFiled(documentId) {
+    const response = await this.request(`tax/documents/${documentId}/mark-filed`, {});
+    return {
+      success: response.success,
+      document: {
+        id: response.document.id,
+        tax_year: response.document.tax_year,
+        status: response.document.status
+      }
+    };
+  }
+  async generateTaxSummary(taxYear, creatorId) {
+    const response = await this.requestGet(`tax/summaries/${taxYear}`, {
+      participant_id: creatorId
+    });
+    return {
+      success: response.success,
+      taxYear: response.tax_year,
+      note: response.note,
+      summaries: (response.summaries || []).map((summary) => ({
+        participantId: summary.participant_id,
+        linkedUserId: summary.linked_user_id ?? null,
+        grossEarnings: summary.gross_earnings,
+        refundsIssued: summary.refunds_issued,
+        netEarnings: summary.net_earnings,
+        totalPaidOut: summary.total_paid_out,
+        requires1099: Boolean(summary.requires_1099),
+        sharedTaxProfile: summary.shared_tax_profile ? {
+          status: summary.shared_tax_profile.status,
+          legalName: summary.shared_tax_profile.legal_name ?? null,
+          taxIdLast4: summary.shared_tax_profile.tax_id_last4 ?? null
+        } : null
+      })),
+      totals: {
+        totalGross: response.totals.total_gross,
+        totalRefunds: response.totals.total_refunds,
+        totalNet: response.totals.total_net,
+        totalPaid: response.totals.total_paid,
+        participantsRequiring1099: response.totals.participants_requiring_1099
+      }
+    };
+  }
+  async markTaxDocumentsFiledBulk(taxYear) {
+    return this.request("tax/documents/mark-filed", { tax_year: taxYear });
+  }
+  async correctTaxDocument(documentId, params) {
+    return this.request(`tax/documents/${documentId}/correct`, {
+      reason: params.reason,
+      gross_amount: params.grossAmount,
+      federal_withholding: params.federalWithholding,
+      state_withholding: params.stateWithholding
+    });
+  }
+  async deliverTaxDocumentCopyB(taxYear) {
+    return this.request("tax/documents/deliver-copy-b", { tax_year: taxYear });
+  }
+  async generateTaxDocumentPdf(documentId, copyType) {
+    return this.request(`tax/documents/${documentId}/pdf`, {
+      copy_type: copyType
+    });
+  }
+  async generateTaxDocumentPdfBatch(taxYear, copyType) {
+    return this.request("tax/documents/pdf/batch", {
+      tax_year: taxYear,
+      copy_type: copyType
+    });
+  }
+  // === COMPLIANCE MONITORING ===
+  async getComplianceOverview(options) {
+    const response = await this.requestGet("compliance/overview", {
+      days: options?.days,
+      hours: options?.hours
+    });
+    return {
+      success: response.success,
+      overview: {
+        windowDays: response.overview.window_days,
+        accessWindowHours: response.overview.access_window_hours,
+        totalEvents: response.overview.total_events,
+        uniqueIps: response.overview.unique_ips,
+        uniqueActors: response.overview.unique_actors,
+        highRiskEvents: response.overview.high_risk_events,
+        criticalRiskEvents: response.overview.critical_risk_events,
+        failedAuthEvents: response.overview.failed_auth_events,
+        payoutsFailed: response.overview.payouts_failed,
+        refundsRecorded: response.overview.refunds_recorded,
+        disputeEvents: response.overview.dispute_events
+      },
+      note: response.note
+    };
+  }
+  async listComplianceAccessPatterns(options) {
+    const response = await this.requestGet("compliance/access-patterns", {
+      hours: options?.hours,
+      limit: options?.limit
+    });
+    return {
+      success: response.success,
+      windowHours: response.window_hours,
+      count: response.count,
+      patterns: (response.patterns || []).map((pattern) => ({
+        ipAddress: pattern.ip_address,
+        hour: pattern.hour,
+        requestCount: pattern.request_count,
+        uniqueActions: pattern.unique_actions,
+        actions: pattern.actions || [],
+        maxRiskScore: pattern.max_risk_score,
+        failedAuths: pattern.failed_auths
+      }))
+    };
+  }
+  async listComplianceFinancialActivity(options) {
+    const response = await this.requestGet("compliance/financial-activity", {
+      days: options?.days
+    });
+    return {
+      success: response.success,
+      windowDays: response.window_days,
+      activity: (response.activity || []).map((entry) => ({
+        date: entry.date,
+        payoutsInitiated: entry.payouts_initiated,
+        payoutsCompleted: entry.payouts_completed,
+        payoutsFailed: entry.payouts_failed,
+        salesRecorded: entry.sales_recorded,
+        refundsRecorded: entry.refunds_recorded,
+        disputeEvents: entry.dispute_events
+      }))
+    };
+  }
+  async listComplianceSecuritySummary(options) {
+    const response = await this.requestGet("compliance/security-summary", {
+      days: options?.days
+    });
+    return {
+      success: response.success,
+      windowDays: response.window_days,
+      summary: (response.summary || []).map((entry) => ({
+        date: entry.date,
+        action: entry.action,
+        eventCount: entry.event_count,
+        uniqueIps: entry.unique_ips,
+        uniqueActors: entry.unique_actors,
+        avgRiskScore: entry.avg_risk_score,
+        maxRiskScore: entry.max_risk_score,
+        highRiskCount: entry.high_risk_count,
+        criticalRiskCount: entry.critical_risk_count
+      }))
+    };
+  }
+  async exportReport(req) {
+    const body = {
+      report_type: req.reportType,
+      format: req.format,
+      start_date: req.startDate,
+      end_date: req.endDate,
+      creator_id: req.creatorId
+    };
+    if (req.format === "csv") {
+      const response = await this.requestRaw("export-report", body);
+      const csv = await response.text();
+      const disposition = response.headers.get("Content-Disposition") || "";
+      const filenameMatch = disposition.match(/filename="?([^"]+)"?/);
+      return { csv, filename: filenameMatch?.[1] || `${req.reportType}.csv` };
+    }
+    return this.request("export-report", body);
+  }
+  // === RECEIPTS ===
+  async uploadReceipt(req) {
+    return this.request("upload-receipt", {
+      file_url: req.fileUrl,
+      file_name: req.fileName,
+      file_size: req.fileSize,
+      mime_type: req.mimeType,
+      merchant_name: req.merchantName,
+      transaction_date: req.transactionDate,
+      total_amount: req.totalAmount,
+      transaction_id: req.transactionId
+    });
+  }
+  // === PAYMENTS ===
+  async receivePayment(req) {
+    return this.request("receive-payment", {
+      amount: req.amount,
+      invoice_transaction_id: req.invoiceTransactionId,
+      customer_name: req.customerName,
+      customer_id: req.customerId,
+      reference_id: req.referenceId,
+      payment_method: req.paymentMethod,
+      payment_date: req.paymentDate,
+      metadata: req.metadata
+    });
+  }
+  // === BREACH ALERTS ===
+  async sendBreachAlert(req) {
+    const response = await this.request("send-breach-alert", {
+      cash_balance: req.cashBalance,
+      pending_total: req.pendingTotal,
+      shortfall: req.shortfall,
+      coverage_ratio: req.coverageRatio,
+      triggered_by: req.triggeredBy,
+      instrument_id: req.instrumentId,
+      external_ref: req.externalRef,
+      projections_created: req.projectionsCreated,
+      channel: req.channel
+    });
+    return {
+      success: response.success,
+      message: response.message,
+      alertsSent: response.alerts_sent ?? 0,
+      alertsFailed: response.alerts_failed,
+      alertsSkipped: response.alerts_skipped,
+      results: response.results ? response.results.map((r) => ({
+        channel: r.channel,
+        success: r.success,
+        error: r.error
+      })) : void 0
+    };
+  }
+  // === WALLETS ===
+  mapWalletObject(wallet) {
+    return {
+      id: wallet.id,
+      object: "wallet",
+      walletType: wallet.wallet_type,
+      scopeType: wallet.scope_type,
+      ownerId: wallet.owner_id ?? null,
+      ownerType: wallet.owner_type ?? null,
+      participantId: wallet.participant_id ?? null,
+      accountType: wallet.account_type,
+      name: wallet.name ?? null,
+      currency: wallet.currency,
+      status: wallet.status,
+      balance: wallet.balance,
+      heldAmount: wallet.held_amount ?? 0,
+      availableBalance: wallet.available_balance ?? wallet.balance,
+      redeemable: wallet.redeemable === true,
+      transferable: wallet.transferable === true,
+      topupSupported: wallet.topup_supported === true,
+      payoutSupported: wallet.payout_supported === true,
+      createdAt: wallet.created_at ?? null,
+      metadata: wallet.metadata || {}
+    };
+  }
+  async listWallets(filters = {}) {
+    const response = await this.requestGet("wallets", {
+      owner_id: filters.ownerId,
+      owner_type: filters.ownerType,
+      wallet_type: filters.walletType,
+      limit: filters.limit,
+      offset: filters.offset
+    });
+    return {
+      success: response.success,
+      wallets: (response.wallets || []).map((wallet) => this.mapWalletObject(wallet)),
+      total: response.total,
+      limit: response.limit,
+      offset: response.offset
+    };
+  }
+  async createWallet(req) {
+    const response = await this.request("wallets", {
+      owner_id: req.ownerId,
+      participant_id: req.participantId,
+      owner_type: req.ownerType,
+      wallet_type: req.walletType,
+      name: req.name,
+      metadata: req.metadata
+    });
+    return {
+      success: response.success,
+      created: response.created === true,
+      wallet: this.mapWalletObject(response.wallet)
+    };
+  }
+  async getWallet(walletId) {
+    const response = await this.requestGet(`wallets/${walletId}`);
+    return {
+      success: response.success,
+      wallet: this.mapWalletObject(response.wallet)
+    };
+  }
+  async getWalletEntries(walletId, options) {
+    const response = await this.requestGet(`wallets/${walletId}/entries`, {
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    return {
+      success: response.success,
+      wallet: response.wallet ? this.mapWalletObject(response.wallet) : null,
+      entries: (response.entries || []).map((t) => ({
+        entryId: t.entry_id,
+        entryType: t.entry_type,
+        amount: t.amount,
+        transactionId: t.transaction_id,
+        referenceId: t.reference_id,
+        transactionType: t.transaction_type,
+        description: t.description,
+        status: t.status,
+        metadata: t.metadata,
+        createdAt: t.created_at
+      })),
+      total: response.total,
+      limit: response.limit,
+      offset: response.offset
+    };
+  }
+  async topUpWallet(req) {
+    const response = await this.request(`wallets/${req.walletId}/topups`, {
+      amount: req.amount,
+      reference_id: req.referenceId,
+      description: req.description,
+      metadata: req.metadata
+    });
+    const topup = response.topup || response.deposit || response;
+    return {
+      success: response.success,
+      walletId: topup.wallet_id ?? null,
+      ownerId: topup.owner_id ?? null,
+      transactionId: topup.transaction_id ?? null,
+      balance: topup.balance ?? null
+    };
+  }
+  async withdrawFromWallet(req) {
+    const response = await this.request(`wallets/${req.walletId}/withdrawals`, {
+      amount: req.amount,
+      reference_id: req.referenceId,
+      description: req.description,
+      metadata: req.metadata
+    });
+    const withdrawal = response.withdrawal || response;
+    return {
+      success: response.success,
+      walletId: withdrawal.wallet_id ?? null,
+      ownerId: withdrawal.owner_id ?? null,
+      transactionId: withdrawal.transaction_id ?? null,
+      balance: withdrawal.balance ?? null
+    };
+  }
+  async createTransfer(req) {
+    const response = await this.request("transfers", {
+      from_participant_id: req.fromParticipantId,
+      to_participant_id: req.toParticipantId,
+      amount: req.amount,
+      reference_id: req.referenceId,
+      description: req.description,
+      metadata: req.metadata
+    });
+    const transfer = response.transfer || response;
+    return {
+      success: response.success,
+      transfer: {
+        transactionId: transfer.transaction_id,
+        fromParticipantId: req.fromParticipantId,
+        toParticipantId: req.toParticipantId,
+        fromBalance: transfer.from_balance,
+        toBalance: transfer.to_balance
+      }
+    };
+  }
+  async listHolds(options) {
+    const response = await this.requestGet("holds", {
+      participant_id: options?.participantId,
+      venture_id: options?.ventureId,
+      ready_only: options?.readyOnly,
+      limit: options?.limit
+    });
+    return {
+      success: response.success,
+      holds: (response.holds || []).map((hold) => ({
+        id: hold.id,
+        participantId: hold.participant_id ?? null,
+        participantName: hold.participant_name ?? null,
+        amount: hold.amount,
+        currency: hold.currency,
+        heldSince: hold.held_since,
+        daysHeld: hold.days_held,
+        holdReason: hold.hold_reason ?? null,
+        holdUntil: hold.hold_until ?? null,
+        readyForRelease: Boolean(hold.ready_for_release),
+        releaseStatus: hold.release_status,
+        transactionReference: hold.transaction_reference ?? null,
+        productName: hold.product_name ?? null,
+        ventureId: hold.venture_id ?? null,
+        connectedAccountReady: Boolean(hold.connected_account_ready)
+      })),
+      count: response.count ?? 0
+    };
+  }
+  async getHoldSummary() {
+    const response = await this.requestGet("holds/summary");
+    return {
+      success: response.success,
+      summary: response.summary || {}
+    };
+  }
+  async releaseHold(req) {
+    const response = await this.request(`holds/${req.holdId}/release`, {
+      execute_transfer: req.executeTransfer !== false
+    });
+    const release = response.release || response;
+    return {
+      success: response.success,
+      release: {
+        id: release.id,
+        holdId: release.hold_id ?? req.holdId,
+        executed: Boolean(release.executed),
+        transferId: release.transfer_id ?? null,
+        transferStatus: release.transfer_status ?? null,
+        amount: release.amount ?? null,
+        currency: release.currency ?? null
+      }
+    };
+  }
+  async createCheckoutSession(req) {
+    const hasPaymentMethod = "paymentMethodId" in req ? Boolean(req.paymentMethodId || req.sourceId) : false;
+    if (!hasPaymentMethod && !req.successUrl) {
+      throw new Error("Either paymentMethodId/sourceId or successUrl is required");
+    }
+    const response = await this.request("checkout-sessions", {
+      amount: req.amount,
+      participant_id: req.participantId,
+      currency: req.currency,
+      product_id: req.productId,
+      product_name: req.productName,
+      customer_email: req.customerEmail,
+      customer_id: req.customerId,
+      payment_method_id: "paymentMethodId" in req ? req.paymentMethodId : void 0,
+      source_id: "sourceId" in req ? req.sourceId : void 0,
+      success_url: req.successUrl,
+      cancel_url: req.cancelUrl,
+      idempotency_key: "idempotencyKey" in req ? req.idempotencyKey : void 0,
+      metadata: req.metadata
+    });
+    const checkoutSession = response.checkout_session || response;
+    return {
+      success: Boolean(response.success),
+      checkoutSession: {
+        id: checkoutSession.id ?? checkoutSession.payment_id ?? checkoutSession.payment_intent_id,
+        mode: checkoutSession.mode === "session" ? "session" : "direct",
+        checkoutUrl: checkoutSession.checkout_url ?? null,
+        paymentId: checkoutSession.payment_id ?? null,
+        paymentIntentId: checkoutSession.payment_intent_id ?? checkoutSession.payment_id ?? null,
+        status: checkoutSession.status ?? null,
+        requiresAction: Boolean(checkoutSession.requires_action),
+        amount: checkoutSession.amount ?? req.amount,
+        currency: checkoutSession.currency ?? (req.currency || "USD"),
+        expiresAt: checkoutSession.expires_at ?? null,
+        fundingTransactionId: checkoutSession.funding_transaction_id ?? null,
+        saleTransactionId: checkoutSession.sale_transaction_id ?? null,
+        saleReference: checkoutSession.sale_reference ?? null,
+        breakdown: checkoutSession.breakdown ? {
+          grossAmount: checkoutSession.breakdown.gross_amount,
+          creatorAmount: checkoutSession.breakdown.creator_amount,
+          platformAmount: checkoutSession.breakdown.platform_amount,
+          creatorPercent: checkoutSession.breakdown.creator_percent
+        } : null
+      }
+    };
+  }
+  async createPayout(req) {
+    const response = await this.request("payouts", {
+      participant_id: req.participantId,
+      wallet_id: req.walletId,
+      amount: req.amount,
+      reference_id: req.referenceId,
+      reference_type: req.referenceType,
+      description: req.description,
+      payout_method: req.payoutMethod,
+      fees: req.fees,
+      fees_paid_by: req.feesPaidBy,
+      metadata: req.metadata
+    });
+    const payout = response.payout || response;
+    return {
+      success: response.success,
+      payout: {
+        id: payout.id,
+        transactionId: payout.transaction_id,
+        grossAmount: payout.gross_amount ?? null,
+        fees: payout.fees ?? null,
+        netAmount: payout.net_amount ?? null,
+        previousBalance: payout.previous_balance ?? null,
+        newBalance: payout.new_balance ?? null
+      }
+    };
+  }
+  async createRefund(req) {
+    const response = await this.request("refunds", {
+      sale_reference: req.saleReference,
+      reason: req.reason,
+      amount: req.amount,
+      refund_from: req.refundFrom,
+      external_refund_id: req.externalRefundId,
+      idempotency_key: req.idempotencyKey,
+      metadata: req.metadata
+    });
+    const refund = response.refund || response;
+    return {
+      success: response.success,
+      warning: response.warning ?? null,
+      warningCode: response.warning_code ?? null,
+      refund: {
+        id: refund.id ?? refund.reference_id ?? refund.transaction_id ?? "",
+        transactionId: refund.transaction_id ?? null,
+        referenceId: refund.reference_id ?? null,
+        saleReference: refund.sale_reference ?? null,
+        refundedAmount: refund.refunded_amount ?? null,
+        currency: refund.currency ?? null,
+        status: refund.status ?? null,
+        breakdown: refund.breakdown ? {
+          fromCreator: refund.breakdown.from_creator,
+          fromPlatform: refund.breakdown.from_platform
+        } : null,
+        isFullRefund: refund.is_full_refund ?? null,
+        repairPending: refund.repair_pending ?? null
+      }
+    };
+  }
+  async listRefunds(req = {}) {
+    const response = await this.requestGet("refunds", {
+      sale_reference: req.saleReference,
+      limit: req.limit
+    });
+    return {
+      success: response.success,
+      count: response.count ?? (response.refunds || []).length,
+      refunds: (response.refunds || []).map((refund) => ({
+        id: refund.id,
+        transactionId: refund.transaction_id ?? null,
+        referenceId: refund.reference_id ?? null,
+        saleReference: refund.sale_reference ?? null,
+        refundedAmount: refund.refunded_amount,
+        currency: refund.currency,
+        status: refund.status,
+        reason: refund.reason ?? null,
+        refundFrom: refund.refund_from ?? null,
+        externalRefundId: refund.external_refund_id ?? null,
+        createdAt: refund.created_at ?? null,
+        breakdown: refund.breakdown ? {
+          fromCreator: refund.breakdown.from_creator,
+          fromPlatform: refund.breakdown.from_platform
+        } : null,
+        repairPending: refund.repair_pending ?? null,
+        lastError: refund.last_error ?? null
+      }))
+    };
+  }
+  // === INVOICES ===
+  async createInvoice(req) {
+    return this.request("invoices", {
+      customer_name: req.customerName,
+      customer_email: req.customerEmail,
+      customer_id: req.customerId,
+      customer_address: req.customerAddress ? {
+        line1: req.customerAddress.line1,
+        line2: req.customerAddress.line2,
+        city: req.customerAddress.city,
+        state: req.customerAddress.state,
+        postal_code: req.customerAddress.postalCode,
+        country: req.customerAddress.country
+      } : void 0,
+      line_items: req.lineItems.map((item) => ({
+        description: item.description,
+        quantity: item.quantity,
+        unit_price: item.unitPrice,
+        amount: item.amount ?? Math.round(item.quantity * item.unitPrice)
+      })),
+      due_date: req.dueDate,
+      notes: req.notes,
+      terms: req.terms,
+      reference_id: req.referenceId,
+      metadata: req.metadata
+    });
+  }
+  async listInvoices(options) {
+    return this.requestGet("invoices", {
+      status: options?.status,
+      customer_id: options?.customerId,
+      limit: options?.limit,
+      offset: options?.offset
+    });
+  }
+  async getInvoice(invoiceId) {
+    return this.requestGet(`invoices/${invoiceId}`);
+  }
+  async sendInvoice(invoiceId) {
+    return this.request(`invoices/${invoiceId}/send`, {});
+  }
+  async recordInvoicePayment(invoiceId, req) {
+    return this.request(`invoices/${invoiceId}/record-payment`, {
+      amount: req.amount,
+      payment_method: req.paymentMethod,
+      payment_date: req.paymentDate,
+      reference_id: req.referenceId,
+      notes: req.notes
+    });
+  }
+  async voidInvoice(invoiceId, reason) {
+    return this.request(`invoices/${invoiceId}/void`, { reason });
+  }
+  // === PAY BILL ===
+  async payBill(req) {
+    return this.request("pay-bill", {
+      bill_transaction_id: req.billTransactionId,
+      amount: req.amount,
+      vendor_name: req.vendorName,
+      reference_id: req.referenceId,
+      payment_method: req.paymentMethod,
+      payment_date: req.paymentDate,
+      metadata: req.metadata
+    });
+  }
+  // === BUDGETS ===
+  async createBudget(req) {
+    return this.request("manage-budgets", {
+      name: req.name,
+      category_code: req.categoryCode,
+      budget_amount: req.budgetAmount,
+      budget_period: req.budgetPeriod,
+      alert_at_percentage: req.alertAtPercentage
+    });
+  }
+  async listBudgets() {
+    return this.requestGet("manage-budgets");
+  }
+  // === RECURRING EXPENSES ===
+  async createRecurring(req) {
+    return this.request("manage-recurring", {
+      name: req.name,
+      merchant_name: req.merchantName,
+      category_code: req.categoryCode,
+      amount: req.amount,
+      recurrence_interval: req.recurrenceInterval,
+      recurrence_day: req.recurrenceDay,
+      start_date: req.startDate,
+      end_date: req.endDate,
+      business_purpose: req.businessPurpose,
+      is_variable_amount: req.isVariableAmount
+    });
+  }
+  async listRecurring() {
+    return this.requestGet("manage-recurring");
+  }
+  async getDueRecurring(days) {
+    return this.requestGet("manage-recurring/due", { days });
+  }
+  // === CONTRACTORS ===
+  async createContractor(req) {
+    return this.request("manage-contractors", {
+      name: req.name,
+      email: req.email,
+      company_name: req.companyName
+    });
+  }
+  async listContractors() {
+    return this.requestGet("manage-contractors");
+  }
+  async recordContractorPayment(req) {
+    return this.request("manage-contractors/payment", {
+      contractor_id: req.contractorId,
+      amount: req.amount,
+      payment_date: req.paymentDate,
+      payment_method: req.paymentMethod,
+      payment_reference: req.paymentReference,
+      description: req.description
+    });
+  }
+  // === BANK ACCOUNTS ===
+  async createBankAccount(req) {
+    return this.request("manage-bank-accounts", {
+      bank_name: req.bankName,
+      account_name: req.accountName,
+      account_type: req.accountType,
+      account_last_four: req.accountLastFour
+    });
+  }
+  async listBankAccounts() {
+    return this.requestGet("manage-bank-accounts");
+  }
+  // === LEDGER LISTING ===
+  async listLedgers() {
+    return this.requestGet("list-ledgers");
+  }
+  // === DELETE CREATOR ===
+  async deleteCreator(creatorId) {
+    return this.request("delete-creator", {
+      creator_id: creatorId
+    });
+  }
+  // === TAX INFO ===
+  async submitTaxInfo(req) {
+    return this.request("submit-tax-info", {
+      participant_id: req.participantId,
+      legal_name: req.legalName,
+      tax_id_type: req.taxIdType,
+      tax_id_last4: req.taxIdLast4,
+      business_type: req.businessType,
+      address: req.address ? {
+        line1: req.address.line1,
+        line2: req.address.line2,
+        city: req.address.city,
+        state: req.address.state,
+        postal_code: req.address.postalCode,
+        country: req.address.country
+      } : void 0,
+      certify: req.certify
+    });
+  }
+  // === BANK STATEMENT IMPORT ===
+  async importBankStatement(req) {
+    return this.request("import-bank-statement", {
+      bank_account_id: req.bankAccountId,
+      lines: req.lines.map((line) => ({
+        transaction_date: line.transactionDate,
+        post_date: line.postDate,
+        description: line.description,
+        amount: line.amount,
+        reference_number: line.referenceNumber,
+        check_number: line.checkNumber,
+        merchant_name: line.merchantName,
+        category_hint: line.categoryHint
+      })),
+      auto_match: req.autoMatch
+    });
+  }
+};
+var client_default = Soledgic;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  ConflictError,
+  DEFAULT_API_VERSION,
+  DEFAULT_BASE_URL,
+  NotFoundError,
+  Soledgic,
+  SoledgicError,
+  ValidationError,
+  hmacHex,
+  isArrayBufferView,
+  mapWebhookDelivery,
+  mapWebhookEndpoint,
+  parseWebhookEvent,
+  parseWebhookSignatureHeader,
+  resolveWebhookEndpointUrl,
+  timingSafeEqual,
+  verifyWebhookSignature,
+  webhookPayloadToString
+});