Resources - Artu Compliance SDK

This page documents all methods available on each resource in the TypeScript SDK. For scope-specific field shapes (what fields are available on scoped models), see the Scopes tab. All list methods return PaginatedResponse<T>:

interface PaginatedResponse<T> {
  data: T[];
  pagination: {
    hasMore: boolean;
    nextCursor?: string;
  };
}

All upsert methods return UpsertResult<T>:

interface UpsertResult<T> {
  data: T;
  action: "created" | "updated";
}

Clients

sdk.clients — CRUD, batch operations, upsert, relationship management, and atomic sync.

CRUD

// Create
const client = await sdk.clients.create({
  type: ClientType.Individual,
  name: "Juan García",
  scopes: ["MX"],
  scopeData: { MX: { rfc: "GAJL850101ABC" } },
});

// Retrieve by ID
const client = await sdk.clients.retrieve("client_id");

// Retrieve by external ID
const client = await sdk.clients.retrieveByExternalId("crm-12345");

// Retrieve by metadata key/value
const client = await sdk.clients.retrieveByMetadata("salesforceId", "SF-001");

// Update
const updated = await sdk.clients.update("client_id", { name: "Juan García Jr." });

// Delete (soft delete)
await sdk.clients.delete("client_id");

List, Count, and Iteration

// List with optional filter and pagination
const { data, pagination } = await sdk.clients.list({
  filter: { type: "individual" },
  limit: 20,
  cursor: pagination.nextCursor, // from a previous call
  includePrimaryContacts: true,
});

// Count matching records
const count = await sdk.clients.count({ type: "individual" });

// Async iteration (auto-paginating)
for await (const client of sdk.clients.iterate({ filter: { type: "individual" } })) {
  console.log(client.name);
}

Batch Operations

// Atomic batch create (all or nothing)
const result = await sdk.clients.createMany([...clients]);
if (result.atomic) {
  console.log("All created:", result.data.length);
}

// Partial batch create (some may fail)
const result = await sdk.clients.createMany([...clients], { atomic: false });
if (!result.atomic) {
  console.log("Succeeded:", result.succeeded.length, "Failed:", result.failed.length);
}

// Batch update
const result = await sdk.clients.updateMany([
  { id: "client_1", data: { name: "Updated Name" } },
]);

Upsert

// Create or update by externalId
const result = await sdk.clients.upsertByExternalId({
  externalId: "crm-123",
  type: ClientType.Individual,
  name: "Juan García",
  scopes: ["MX"],
});
console.log(result.action); // "created" | "updated"

// Batch upsert
const result = await sdk.clients.upsertManyByExternalId([...items]);

Compliance Checklist

// Get per-field compliance status for a client
const checklist = await sdk.clients.checklist("client_id", {
  scope: "MX:AV:AVI",
  includeChildren: true, // include checklist items for linked clients
});

Client Relationships

Clients can be linked together with typed relationships (legal representatives, controlling beneficiaries):

// Link an existing client as legal representative
const updatedParent = await sdk.clients.linkClient(
  companyId,
  legalRepId,
  ClientRelationshipType.LegalRepresentative,
);

// Link with metadata (e.g. ownership percentage for controlling beneficiaries)
await sdk.clients.linkClient(
  companyId,
  beneficiaryId,
  ClientRelationshipType.ControllingBeneficiary,
  { ownershipPercentage: 51 },
);

// Unlink
await sdk.clients.unlinkClient(companyId, legalRepId, ClientRelationshipType.LegalRepresentative);

// List linked clients (optionally filter by relationship type)
const links = await sdk.clients.listLinkedClients(companyId);
const reps = await sdk.clients.listLinkedClients(companyId, ClientRelationshipType.LegalRepresentative);

// Retrieve a specific relationship record
const link = await sdk.clients.retrieveLinkedClient(linkId);

// Update relationship metadata
const updated = await sdk.clients.updateLinkedClient(linkId, { ownershipPercentage: 60 });

// Replace all linked clients at once
await sdk.clients.setLinkedClients(companyId, [
  { clientId: legalRepId, relationshipType: "legal_representative" },
  { clientId: beneficiaryId, relationshipType: "controlling_beneficiary" },
]);

Typed sub-resources are also available for the most common relationship types:

// Create and link in one call
const { child, parent, link } = await sdk.clients.legalRepresentatives.create(companyId, {
  type: ClientType.Individual,
  name: "María Pérez",
  scopes: ["MX"],
});

// Same for controlling beneficiaries
const { child } = await sdk.clients.controllingBeneficiaries.create(companyId, {
  type: ClientType.Individual,
  name: "Beneficiary Name",
});

To use a dynamic relationship type (e.g. from a UI picker), use createRelatedClient:

const { child, parent, link } = await sdk.clients.createRelatedClient(
  parentId,
  relationshipType,
  childInput,
  metadata,
);

Promote a Non-Primary Client

// Make a legal rep or BO a stand-alone primary client
const promoted = await sdk.clients.promote("client_id");

Atomic Sync

syncAll creates or updates a client together with its related resources in a single transaction:

// Create mode — client data is required when clientId is undefined
const result = await sdk.clients.syncAll(undefined, {
  client: { type: "individual", name: "Juan García" },
  addresses: [{ street: "Reforma 123", city: "CDMX", country: "MX" }],
  contactMethods: [{ type: "email", value: "juan@example.com" }],
  bankAccounts: [{ country: "MX", clabe: "012345678901234567" }],
  linkedClients: [],
});

// Edit mode — update an existing client and its nested resources
const result = await sdk.clients.syncAll("client_id", {
  client: { name: "Updated Name" },
  addresses: [
    { street: "New St", city: "CDMX", country: "MX" },   // create new
    { id: "addr_456", street: "Updated St" },              // update existing
    { id: "addr_789", _delete: true },                     // delete
  ],
});

// Replace mode — the provided arrays become the complete set
const result = await sdk.clients.syncAll("client_id", {
  addresses: currentAddresses,
}, { replaceMode: true });

console.log(result.client);              // the created/updated client
console.log(result.addresses.created);  // newly created addresses
console.log(result.addresses.updated);  // updated addresses
console.log(result.addresses.deleted);  // deleted address IDs

Tag Management

await sdk.clients.addTags("client_id", ["tag_id_1", "tag_id_2"]);
await sdk.clients.removeTags("client_id", ["tag_id_1"]);
await sdk.clients.setTags("client_id", ["tag_id_2"]);      // replaces all tags
const tags = await sdk.clients.listTags("client_id");

Transactions

sdk.transactions — CRUD, batch operations, upsert, client relationship management.

CRUD

const txn = await sdk.transactions.create({
  amount: 50000,
  currency: "MXN",
  scopes: ["MX:AV:AVI"],
  relatedClientIds: ["client_sender"],
  timestamp: new Date(),
  scopeData: { MX: { actividadVulnerable: { AVI: { tipoOperacion: "buy" } } } },
});

const txn = await sdk.transactions.retrieve("txn_id");
const txn = await sdk.transactions.retrieveByExternalId("ext-txn-456");
const txn = await sdk.transactions.retrieveByMetadata("internalRef", "REF-001");
const updated = await sdk.transactions.update("txn_id", { status: "completed" });
await sdk.transactions.delete("txn_id");

List, Count, Iterate

const { data, pagination } = await sdk.transactions.list({ filter: { status: "completed" }, limit: 50 });
const count = await sdk.transactions.count({ status: "completed" });
const byClient = await sdk.transactions.listByClient("client_id", { limit: 20 });

for await (const txn of sdk.transactions.iterate({ filter: { currency: "MXN" } })) {
  console.log(txn.amount);
}

Batch / Upsert

const result = await sdk.transactions.createMany([...txns]);
const result = await sdk.transactions.updateMany([{ id: "txn_1", data: { ... } }]);
const result = await sdk.transactions.upsertByExternalId({ externalId: "ext-1", ... });
const result = await sdk.transactions.upsertManyByExternalId([...txns]);

Client Linking

Transactions can be linked to multiple clients with optional roles:

// Link a client (optionally with a role)
const updated = await sdk.transactions.linkClient(txnId, clientId, ClientRole.Sender);

// Unlink
const updated = await sdk.transactions.unlinkClient(txnId, clientId);

// Replace all related clients
const updated = await sdk.transactions.setClients(txnId, [
  { clientId: senderId, role: "sender" },
  { clientId: receiverId, role: "receiver" },
]);

Evidence Linking

await sdk.transactions.linkEvidence({ transactionId: txnId, evidenceId: "evid_123" });
await sdk.transactions.unlinkEvidence({ transactionId: txnId, evidenceId: "evid_123" });
const { data: evidenceList } = await sdk.transactions.listEvidence(txnId);

Tag Management

await sdk.transactions.addTags("txn_id", ["tag_id"]);
await sdk.transactions.removeTags("txn_id", ["tag_id"]);
await sdk.transactions.setTags("txn_id", ["tag_id"]);
const tags = await sdk.transactions.listTags("txn_id");

Checklist

const checklist = await sdk.transactions.checklist("txn_id", { scope: "MX:AV:AVI" });

Addresses

sdk.addresses — CRUD and list for client address records.

const address = await sdk.addresses.create({
  clientId: "client_id",
  type: AddressType.Home,
  street: "Paseo de la Reforma 123",
  city: "Ciudad de México",
  state: "CDMX",
  postalCode: "06600",
  country: "MX",
});

const address = await sdk.addresses.retrieve("addr_id");
const updated = await sdk.addresses.update("addr_id", { street: "New Street" });
await sdk.addresses.delete("addr_id");

const { data } = await sdk.addresses.list({ filter: { clientId: "client_id" } });

Contact Methods

sdk.contactMethods — CRUD and list for client email, phone, and other contact methods.

const contact = await sdk.contactMethods.create({
  clientId: "client_id",
  type: ContactMethodType.Email,
  value: "juan@example.com",
  isPrimary: true,
});

const contact = await sdk.contactMethods.retrieve("cm_id");
const updated = await sdk.contactMethods.update("cm_id", { value: "new@example.com" });
await sdk.contactMethods.delete("cm_id");

const { data } = await sdk.contactMethods.list({ filter: { clientId: "client_id" } });

Bank Accounts

sdk.bankAccounts — CRUD, batch, upsert, and sync for client bank accounts. The SDK automatically derives missing CLABE components for Mexican accounts.

CLABE Auto-Fill

When creating or updating a Mexican bank account, the SDK automatically fills in missing fields:

Providing clabe populates codigoBanco, codigoPlaza, accountNumber, and bankName.
Providing codigoBanco + codigoPlaza + accountNumber computes clabe and bankName.

// Only CLABE required — other fields are derived automatically
const account = await sdk.bankAccounts.create({
  clientId: "client_id",
  country: "MX",
  clabe: "012345678901234567",
  // codigoBanco, codigoPlaza, accountNumber, bankName filled in automatically
});

CRUD

const account = await sdk.bankAccounts.create({ clientId: "client_id", country: "MX", clabe: "..." });
const account = await sdk.bankAccounts.retrieve("ba_id");
const account = await sdk.bankAccounts.retrieveByExternalId("ext-ba-1");
const account = await sdk.bankAccounts.retrieveByMetadata("key", "value");
const updated = await sdk.bankAccounts.update("ba_id", { bankName: "BBVA México" });
await sdk.bankAccounts.delete("ba_id");

List, Count, Iterate

const { data } = await sdk.bankAccounts.list({ filter: { clientId: "client_id" } });
const { data } = await sdk.bankAccounts.listByClient("client_id");
const count = await sdk.bankAccounts.count({ clientId: "client_id" });
for await (const account of sdk.bankAccounts.iterate()) { ... }

Convenience Helpers

const primary = await sdk.bankAccounts.getPrimary("client_id");  // or null
const account = await sdk.bankAccounts.setPrimary("ba_id");
const account = await sdk.bankAccounts.activate("ba_id");
const account = await sdk.bankAccounts.deactivate("ba_id");

Batch / Upsert

const result = await sdk.bankAccounts.createMany([...accounts]);
const result = await sdk.bankAccounts.updateMany([{ id: "ba_1", data: { ... } }]);
const result = await sdk.bankAccounts.upsertByExternalId({ externalId: "ext-1", ... });
const result = await sdk.bankAccounts.upsertManyByExternalId([...accounts]);

Sync

// Patch mode — only specified items are affected
const result = await sdk.bankAccounts.sync("client_id", [
  { accountNumber: "1234", bankName: "BBVA", country: "MX" },   // create
  { id: "ba_456", bankName: "Updated Name" },                    // update
  { id: "ba_789", _delete: true },                               // delete
]);

// Replace mode — provided array becomes the complete set
const result = await sdk.bankAccounts.sync("client_id", currentAccounts, { replaceMode: true });

console.log(result.created, result.updated, result.deleted);

Documents

sdk.documents — Document record management with file upload, download, OCR extraction, and review workflow.

Create and Upload

// Low-level: create a record, get presigned URL, upload manually, confirm
const { document, upload } = await sdk.documents.create({
  clientId: "client_id",
  scope: "MX",
  type: "ine_front",
  contentType: "image/jpeg",
});

await fetch(upload.url, { method: "PUT", body: fileBlob, headers: { "Content-Type": "image/jpeg" } });

await sdk.documents.confirmUpload({
  id: document.id,
  filename: "ine.jpg",
  contentType: "image/jpeg",
  size: fileBlob.size,
});

// High-level helper: create + upload + confirm in one call
const document = await sdk.documents.upload(file, {
  clientId: "client_id",
  scope: "MX",
  type: "ine_front",
}, {
  onProgress: (progress) => console.log(`${Math.round(progress * 100)}%`),
  signal: abortController.signal,
});

Retry a Failed Upload

If the storage PUT step fails and the document record was already created:

const document = await sdk.documents.retryUpload("doc_id", file);

Download

const { url, expiresAt } = await sdk.documents.getDownloadUrl("doc_id");

CRUD

const doc = await sdk.documents.retrieve("doc_id");
const doc = await sdk.documents.retrieveByExternalId("ext-doc-1");
const doc = await sdk.documents.retrieveByMetadata("key", "value");
const updated = await sdk.documents.update("doc_id", { metadata: { verified: true } });
await sdk.documents.delete("doc_id");

List, Count, Iterate

const { data } = await sdk.documents.list({ filter: { clientId: "client_id" } });
const { data } = await sdk.documents.listByClient("client_id");
const count = await sdk.documents.count({ clientId: "client_id" });
for await (const doc of sdk.documents.iterate()) { ... }

Review Lifecycle

await sdk.documents.submit("doc_id");            // uploaded → pending_review
await sdk.documents.verify("doc_id");            // pending_review → verified
await sdk.documents.reject("doc_id", { reason: "Blurry image" });  // pending_review → rejected

OCR Extraction

const result = await sdk.documents.extract("doc_id");
// Returns structured fields extracted from the document image

Batch / Upsert

const result = await sdk.documents.createMany([...documents]);
const result = await sdk.documents.updateMany([{ id: "doc_1", data: { ... } }]);
const result = await sdk.documents.upsertByExternalId({ externalId: "ext-1", clientId: "...", ... });
const result = await sdk.documents.upsertManyByExternalId([...documents]);

Evidence

sdk.evidence — Evidence record management with file upload, download, OCR extraction, review workflow, and transaction linking. Evidence attaches to transactions (whereas documents attach to clients).

Create and Upload

// Low-level: create a record, get presigned URL, upload manually, confirm
const { evidence, upload } = await sdk.evidence.create({
  scope: "MX",
  type: "contrato_compraventa",
  contentType: "application/pdf",
  transactionIds: ["txn_id"],
});

await fetch(upload.url, { method: "PUT", body: fileBlob, headers: { "Content-Type": "application/pdf" } });

await sdk.evidence.confirmUpload({
  id: evidence.id,
  filename: "contrato.pdf",
  contentType: "application/pdf",
  size: fileBlob.size,
});

// High-level helper: create + upload + confirm in one call
const evidence = await sdk.evidence.upload(file, {
  scope: "MX",
  type: "contrato_compraventa",
  transactionIds: ["txn_id"],
}, {
  onProgress: (progress) => console.log(`${Math.round(progress * 100)}%`),
  signal: abortController.signal,
});

Retry a Failed Upload

// Regenerate a presigned URL for a record stuck in pending_upload
const upload = await sdk.evidence.getUploadUrl("evid_id");

// Or regenerate + re-upload + confirm in one call
const evidence = await sdk.evidence.retryUpload("evid_id", file);

Download

const { url, expiresAt } = await sdk.evidence.getDownloadUrl("evid_id");

CRUD

const evidence = await sdk.evidence.retrieve("evid_id");
const evidence = await sdk.evidence.retrieveByMetadata("key", "value");
const updated = await sdk.evidence.update("evid_id", { metadata: { reviewed: true } });
await sdk.evidence.delete("evid_id");

List, Count, Iterate

const { data } = await sdk.evidence.list({ filter: { type: "contrato_compraventa" } });
const count = await sdk.evidence.count({ type: "contrato_compraventa" });
for await (const evidence of sdk.evidence.iterate()) { ... }

Review Lifecycle

await sdk.evidence.submit("evid_id");            // uploaded → pending_review
await sdk.evidence.verify("evid_id");            // pending_review → verified
await sdk.evidence.reject("evid_id", { reason: "Illegible scan" });  // pending_review → rejected

OCR Extraction

const result = await sdk.evidence.extract("evid_id");
// Returns structured fields extracted from the evidence file

Transaction Linking

Evidence links to transactions from either side. See also the transaction-side Evidence Linking snippet above.

await sdk.evidence.linkTransaction({ evidenceId: "evid_id", transactionId: "txn_id" });
await sdk.evidence.unlinkTransaction({ evidenceId: "evid_id", transactionId: "txn_id" });

// Replace all transaction links at once
await sdk.evidence.setTransactions({ evidenceId: "evid_id", transactionIds: ["txn_1", "txn_2"] });

// List linked transaction IDs for an evidence record
const transactionIds = await sdk.evidence.listLinkedTransactions("evid_id");

// List evidence records linked to a transaction
const { data } = await sdk.evidence.listForTransaction("txn_id");

// Completeness check — does a transaction have a verified evidence of a type?
const hasCfdi = await sdk.evidence.hasEvidenceType("txn_id", "factura_cfdi_4_0");

Batch / Upsert

const result = await sdk.evidence.createMany([...evidence]);
const result = await sdk.evidence.updateMany([{ id: "evid_1", data: { ... } }]);
const result = await sdk.evidence.upsertByExternalId({ externalId: "ext-1", ... });
const result = await sdk.evidence.upsertManyByExternalId([...evidence]);

Alerts

sdk.alerts — Regulatory alert management including item management, validation, and report generation.

CRUD

const alert = await sdk.alerts.create({
  scopeData: {
    MX: { actividadVulnerable: { AVI: { mesReportado: "202401" } } },
  },
});

const alert = await sdk.alerts.retrieve("alert_id");
const alert = await sdk.alerts.retrieveByExternalId("ext-alert-1");
const alert = await sdk.alerts.retrieveByMetadata("key", "value");
const updated = await sdk.alerts.update("alert_id", { metadata: { ... } });
await sdk.alerts.delete("alert_id");

Status Transitions

// Manually transition lifecycle status
const updated = await sdk.alerts.updateStatus("alert_id", { status: "in_review" });

// Mark as filed (terminal — requires acknowledgment file already uploaded)
const filed = await sdk.alerts.markAsFiled("alert_id");

Acknowledgment Files

// Get presigned URL to upload the regulator's acknowledgment file
const { url, expiresAt } = await sdk.alerts.getAcknowledgmentUploadUrl("alert_id", {
  contentType: "application/pdf",
});

// After uploading, call markAsFiled (see above)

// Get presigned download URL for an already-filed alert's acknowledgment
const { url } = await sdk.alerts.getAcknowledgmentDownloadUrl("alert_id");

List, Count, Iterate

const { data, pagination } = await sdk.alerts.list({ filter: { scope: "MX:AV:AVI" }, limit: 20 });
const count = await sdk.alerts.count({ scope: "MX:AV:AVI" });
for await (const alert of sdk.alerts.iterate()) { ... }

Alert Items

Alert items represent the individual transactions or clients included in the alert. The SDK provides both per-alert item management and a top-level items sub-resource for cross-alert queries.

// Add a single item (transaction or client reference)
const item = await sdk.alerts.addItem("alert_id", { transactionId: "txn_123" });

// Add multiple items at once (validates all upfront)
const { added, items } = await sdk.alerts.addItems("alert_id", [
  { transactionId: "txn_123" },
  { transactionId: "txn_456" },
]);

// Get, update, and remove an item
const item = await sdk.alerts.getItem("alert_id", "item_id");
const updated = await sdk.alerts.updateItem("alert_id", "item_id", { ... });
await sdk.alerts.removeItem("alert_id", "item_id");
await sdk.alerts.removeItems("alert_id", ["item_1", "item_2"]);

// List items with filtering
const { data: items } = await sdk.alerts.listItems("alert_id", { limit: 50 });

// List related transactions and clients via the alert
const { data: txns } = await sdk.alerts.listTransactionItems("alert_id");
const { data: clients } = await sdk.alerts.listClients("alert_id");

// Top-level items sub-resource (across all alerts)
const { data: items } = await sdk.alerts.items.list();
const count = await sdk.alerts.items.count({ alertId: { eq: "alert_id" } });

Validation and Report Generation

// Validate an alert without generating output (dry run)
const result = await sdk.alerts.validateReport("alert_id", "mex.actividad-vulnerable.avi");
if (result.valid) {
  console.log("Ready to generate");
} else {
  console.log(result.errors);
}

// Generate the regulatory report (XML for Mexico alerts)
// Returns { status: "success", reports: [...] } or { status: "validation_failed", validation: {...} }
const result = await sdk.alerts.generateReport("alert_id", "mex.actividad-vulnerable.avi");
if (result.status === "success") {
  console.log("Generated:", result.reports.length, "report(s)");
}

// With split options (for large alerts)
const result = await sdk.alerts.generateReport(
  "alert_id",
  "mex.actividad-vulnerable.avi",
  undefined,
  { split: { strategy: "minimize" } }
);

Batch / Upsert

const result = await sdk.alerts.createMany([...alerts]);
const result = await sdk.alerts.updateMany([{ id: "alert_1", data: { ... } }]);
const result = await sdk.alerts.upsertByExternalId({ externalId: "ext-1", ... });
const result = await sdk.alerts.upsertManyByExternalId([...alerts]);

Tag Management

await sdk.alerts.addTags("alert_id", ["tag_id"]);
await sdk.alerts.removeTags("alert_id", ["tag_id"]);
await sdk.alerts.setTags("alert_id", ["tag_id"]);
const tags = await sdk.alerts.listTags("alert_id");

Reports

sdk.reports — Read-only access to generated report files. Reports are created by alerts.generateReport and stored immutably.

// Retrieve a specific report
const report = await sdk.reports.retrieve("report_id");

// List all reports (with optional filter/sort)
const { data, pagination } = await sdk.reports.list({ limit: 20 });

// List reports for a specific alert
const { data } = await sdk.reports.listByAlert("alert_id", {
  currentOnly: true,   // only the most recent generation per alert (default: true)
  limit: 10,
});

// Count reports
const count = await sdk.reports.count({ alertId: { eq: "alert_id" } });

// Get presigned download URL (valid ~15 minutes)
const { url } = await sdk.reports.getDownloadUrl("report_id");

Workflows

sdk.workflows — Monitoring workflow management. The workflows namespace also exposes variables, executions, templates, and links sub-resources.

Workflow CRUD

const workflow = await sdk.workflows.create({
  name: "High-value transaction alert",
  trigger: { type: "event", entity: "transaction", events: ["created"] },
  workflow: { nodes: [], edges: [] },
});

const workflow = await sdk.workflows.retrieve("workflow_id");
const updated = await sdk.workflows.update("workflow_id", { name: "Updated Name" });
await sdk.workflows.delete("workflow_id");

const { data } = await sdk.workflows.list({ filter: { status: "active" } });

Workflow Variables

sdk.workflows.variables — Configurable threshold and value management for workflows.

const variable = await sdk.workflows.variables.create({
  name: "high_value_threshold",
  value: 100000,
  scope: WorkflowVariableScope.Organization,
});

const variable = await sdk.workflows.variables.retrieve("var_id");
const updated = await sdk.workflows.variables.update("var_id", { value: 150000 });
await sdk.workflows.variables.delete("var_id");

const { data } = await sdk.workflows.variables.list();

Reference Data

sdk.referenceData — Read-only access to external reference datasets.

// Look up postal code settlements (Mexico)
const settlements = await sdk.referenceData.mex.postalCodes.lookup("06600");

// Basel AML score by country
const entry = await sdk.referenceData.global.baselAml.byCountry({ countryCode: "MX" });

Exchange Rates

sdk.exchangeRates — Exchange rate lookups with multi-level caching.

const rate = await sdk.exchangeRates.get({ from: "USD", to: "MXN", date: "2024-01-15" });

Tenant

sdk.tenant — Singleton resource for organization-level metadata and settings.

const tenant = await sdk.tenant.get();
await sdk.tenant.update({ settings: { enablePostalCodeValidation: true } });

​Clients

​CRUD

​List, Count, and Iteration

​Batch Operations

​Upsert

​Compliance Checklist

​Client Relationships

​Promote a Non-Primary Client

​Atomic Sync

​Tag Management

​Transactions

​CRUD

​List, Count, Iterate

​Batch / Upsert

​Client Linking

​Evidence Linking

​Tag Management

​Checklist

​Addresses

​Contact Methods

​Bank Accounts

​CLABE Auto-Fill

​CRUD

​List, Count, Iterate

​Convenience Helpers

​Batch / Upsert

​Sync

​Documents

​Create and Upload

​Retry a Failed Upload

​Download

​CRUD

​List, Count, Iterate

​Review Lifecycle

​OCR Extraction

​Batch / Upsert

​Evidence

​Create and Upload

​Retry a Failed Upload

​Download

​CRUD

​List, Count, Iterate

​Review Lifecycle

​OCR Extraction

​Transaction Linking

​Batch / Upsert

​Alerts

​CRUD

​Status Transitions

​Acknowledgment Files

​List, Count, Iterate

​Alert Items

​Validation and Report Generation

​Batch / Upsert

​Tag Management

​Reports

​Workflows

​Workflow CRUD

​Workflow Variables

​Reference Data

​Exchange Rates

​Tenant

Clients

CRUD

List, Count, and Iteration

Batch Operations

Upsert

Compliance Checklist

Client Relationships

Promote a Non-Primary Client

Atomic Sync

Tag Management

Transactions

CRUD

List, Count, Iterate

Batch / Upsert

Client Linking

Evidence Linking

Tag Management

Checklist

Addresses

Contact Methods

Bank Accounts

CLABE Auto-Fill

CRUD

List, Count, Iterate

Convenience Helpers

Batch / Upsert

Sync

Documents

Create and Upload

Retry a Failed Upload

Download

CRUD

List, Count, Iterate

Review Lifecycle

OCR Extraction

Batch / Upsert

Evidence

Create and Upload

Retry a Failed Upload

Download

CRUD

List, Count, Iterate

Review Lifecycle

OCR Extraction

Transaction Linking

Batch / Upsert

Alerts

CRUD

Status Transitions

Acknowledgment Files

List, Count, Iterate

Alert Items

Validation and Report Generation

Batch / Upsert

Tag Management

Reports

Workflows

Workflow CRUD

Workflow Variables

Reference Data

Exchange Rates

Tenant