@artu-ai/compliance-sdk 0.13.4 → 0.17.0

package/dist/resources/workflows.d.ts

@@ -4,10 +4,11 @@
  * Resource manager for workflows and workflow variables.
  * Workflows define triggers and visual graphs for the monitoring engine.
  */
-import type { CreateWorkflowInput, ListOptions, PaginatedResponse, ResourceTagResponse, TriggerWorkflowExecutionInput, TriggerWorkflowExecutionResponse, UpdateWorkflowInput, WorkflowFilter } from "@artu-ai/shared";
+import type { ApiEndpointResponse, CreateApiEndpointInput, CreateWorkflowInput, ListApiEndpointsInput, ListApiEndpointsResult, ListOptions, PaginatedResponse, ResourceTagResponse, RevokeApiEndpointInput, TriggerWorkflowExecutionInput, TriggerWorkflowExecutionResponse, UpdateApiEndpointLabelInput, UpdateWorkflowInput, WorkflowFilter, WorkflowSort } from "@artu-ai/shared";
 import { Workflow } from "../models/Workflow";
 import { BaseResource, type ResourceConfig } from "./base";
 import { WorkflowExecutionsResource } from "./workflow-executions";
+import { WorkflowLinksResource } from "./workflow-links";
 import { WorkflowTemplatesResource } from "./workflow-templates";
 import { WorkflowVariablesResource } from "./workflow-variables";
 /**
@@ -40,6 +41,11 @@ export declare class WorkflowsResource extends BaseResource<Workflow, CreateWork
      * Workflow executions resource (read-only).
      */
     readonly executions: WorkflowExecutionsResource;
+    /**
+     * Workflow links resource.
+     * Provides create, list, and revoke operations for shareable workflow links.
+     */
+    readonly links: WorkflowLinksResource;
     /**
      * Workflow templates resource.
      * Provides CRUD and import/publish operations for reusable workflow blueprints.
@@ -65,35 +71,103 @@ export declare class WorkflowsResource extends BaseResource<Workflow, CreateWork
     /**
      * List workflows with optional filtering and pagination.
      */
-    list(options?: ListOptions<WorkflowFilter, never>): Promise<PaginatedResponse<Workflow>>;
+    list(options?: ListOptions<WorkflowFilter, WorkflowSort>): Promise<PaginatedResponse<Workflow>>;
+    /**
+     * List workflows ordered by the timestamp of their most recent execution
+     * (most-recently-run first; never-run workflows appear last). Returns each
+     * workflow augmented with a `lastExecutedAt` field.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.workflows.listRecent({ limit: 10 });
+     * data.forEach((wf) => console.log(wf.name, wf.lastExecutedAt));
+     * ```
+     */
+    listRecent(options?: {
+        limit?: number;
+        cursor?: string;
+        includeTotalCount?: boolean;
+    }): Promise<PaginatedResponse<Workflow & {
+        lastExecutedAt: Date | null;
+    }>>;
     /**
      * Count workflows matching the given filter.
      */
     count(filter?: WorkflowFilter): Promise<number>;
     /**
-     * Manually trigger execution of a workflow.
-     *
-     * For scheduled workflows, pass `{ triggerType: "schedule" }`.
-     * For event workflows, pass `{ triggerType: "event", entityType, entityId }`.
+     * Fire a workflow execution. Returns `status: "queued"` immediately; the
+     * execution runs in the background. Use `runAndWait` if you want to
+     * block until the run finishes.
      *
      * @example
      * ```typescript
-     * // Scheduled workflow
-     * const result = await sdk.workflows.triggerExecution({
+     * const result = await sdk.workflows.run({
      *   id: workflowId,
-     *   triggerType: "schedule",
+     *   triggerType: "manual",
      * });
+     * if (result.ok) {
+     *   console.log("Queued:", result.executionId);
+     * }
+     * ```
+     */
+    run(input: TriggerWorkflowExecutionInput): Promise<TriggerWorkflowExecutionResponse>;
+    /**
+     * Fire a workflow execution and wait for it to reach a stopping state.
+     * Blocks for up to `options.timeoutMs` (default 30000, server-capped at
+     * 60000).
      *
-     * // Event workflow against a specific entity
-     * const result = await sdk.workflows.triggerExecution({
-     *   id: workflowId,
-     *   triggerType: "event",
-     *   entityType: "transaction",
-     *   entityId: "txn_123",
-     * });
+     * Possible outcomes:
+     *   - `status: "completed"` — the run finished (success or soft failure;
+     *     check `error`). `producedRecords` lists every record the run
+     *     created/updated (alerts, upserted clients/transactions,
+     *     subresources; capped per type) and `alertIds` is its alert subset.
+     *     `producedFiles` lists the files the run produced (descriptors
+     *     only — fetch contents via `executions.getFileDownloadUrl`).
+     *   - `status: "waiting_for_input"` — the run hit a human-in-loop step
+     *     (e.g. `form.choice`) and is paused waiting for a person to act on
+     *     it. The run won't finish without that, so the caller is returned
+     *     immediately instead of timing out. Surface the `executionId` to
+     *     your user (or display the workflow execution page) so they can
+     *     complete it.
+     *   - `status: "queued"` — the wait window elapsed before either of the
+     *     above. The caller can poll `executions.wait(id)` later.
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.workflows.runAndWait(
+     *   { id: workflowId, triggerType: "manual" },
+     *   { timeoutMs: 10000 },
+     * );
+     * if (result.ok) {
+     *   switch (result.status) {
+     *     case "completed": console.log("Done:", result.alertIds); break;
+     *     case "waiting_for_input": console.log("Needs human:", result.executionId); break;
+     *     case "queued": console.log("Still running:", result.executionId); break;
+     *   }
+     * }
      * ```
      */
+    runAndWait(input: TriggerWorkflowExecutionInput, options?: {
+        timeoutMs?: number;
+    }): Promise<TriggerWorkflowExecutionResponse>;
+    /**
+     * Manually trigger execution of a workflow.
+     *
+     * @deprecated Use `run` for fire-and-forget or `runAndWait` for sync
+     *   semantics. This method now wraps `runAndWait` to preserve the
+     *   pre-async-dispatch contract — note that API triggers, which
+     *   previously returned `queued` from `triggerExecution`, now wait by
+     *   default; switch to `run` if you want the old API-trigger behavior.
+     */
     triggerExecution(input: TriggerWorkflowExecutionInput): Promise<TriggerWorkflowExecutionResponse>;
+    /**
+     * Mint a public URL for a trigger.api node. The returned `friendlyId`
+     * is the path slug for `POST /v1/triggers/{friendlyId}`.
+     */
+    createApiEndpoint(input: CreateApiEndpointInput): Promise<ApiEndpointResponse>;
+    listApiEndpoints(input: ListApiEndpointsInput): Promise<ListApiEndpointsResult>;
+    updateApiEndpointLabel(input: UpdateApiEndpointLabelInput): Promise<ApiEndpointResponse>;
+    revokeApiEndpoint(input: RevokeApiEndpointInput): Promise<ApiEndpointResponse>;
     getFileUploadUrl(input: {
         id: string;
         filename: string;
@@ -132,6 +206,23 @@ export declare class WorkflowsResource extends BaseResource<Workflow, CreateWork
         testWorkflow: Workflow;
         liveWorkflow: Workflow;
     }>;
+    /**
+     * Recreate the test counterpart for a live workflow that has none.
+     *
+     * Live workflows are config-immutable — you edit in test and re-promote.
+     * When a live workflow's test counterpart was deleted, this recreates a
+     * draft test workflow from the live config and links the two, so a later
+     * {@link promote} updates this same live workflow. Idempotent: returns the
+     * existing test counterpart if one already exists. Must be called from a
+     * live environment SDK instance.
+     *
+     * @example
+     * ```typescript
+     * const testWorkflow = await sdk.workflows.recreateInTest(liveWorkflowId);
+     * console.log(testWorkflow.status); // "draft"
+     * ```
+     */
+    recreateInTest(id: string): Promise<Workflow>;
     /**
      * Adds tags to a workflow.
      */
@@ -150,6 +241,6 @@ export declare class WorkflowsResource extends BaseResource<Workflow, CreateWork
     listTags(id: string): Promise<ResourceTagResponse[]>;
 }
 export { WorkflowExecutionsResource } from "./workflow-executions";
+export { WorkflowLinksResource } from "./workflow-links";
 export { WorkflowTemplatesResource } from "./workflow-templates";
 export { WorkflowVariablesResource } from "./workflow-variables";
-//# sourceMappingURL=workflows.d.ts.map

package/dist/resources/workflows.js

@@ -4,10 +4,12 @@
  * Resource manager for workflows and workflow variables.
  * Workflows define triggers and visual graphs for the monitoring engine.
  */
-import { createWorkflowInputSchema, updateWorkflowInputSchema, } from "@artu-ai/shared";
+import { createWorkflowInputSchema, updateWorkflowInputSchema, validateWorkflow, WorkflowExecutionStatusUtils, } from "@artu-ai/shared";
+import { ValidationError } from "../errors/validation";
 import { Workflow } from "../models/Workflow";
 import { BaseResource } from "./base";
 import { WorkflowExecutionsResource } from "./workflow-executions";
+import { WorkflowLinksResource } from "./workflow-links";
 import { WorkflowTemplatesResource } from "./workflow-templates";
 import { WorkflowVariablesResource } from "./workflow-variables";
 /**
@@ -40,6 +42,11 @@ export class WorkflowsResource extends BaseResource {
      * Workflow executions resource (read-only).
      */
     executions;
+    /**
+     * Workflow links resource.
+     * Provides create, list, and revoke operations for shareable workflow links.
+     */
+    links;
     /**
      * Workflow templates resource.
      * Provides CRUD and import/publish operations for reusable workflow blueprints.
@@ -49,6 +56,7 @@ export class WorkflowsResource extends BaseResource {
         super(config);
         this.variables = new WorkflowVariablesResource(config);
         this.executions = new WorkflowExecutionsResource(config);
+        this.links = new WorkflowLinksResource(config);
         this.templates = new WorkflowTemplatesResource(config);
     }
     /**
@@ -56,6 +64,7 @@ export class WorkflowsResource extends BaseResource {
      */
     async create(data) {
         const validated = this.validate(createWorkflowInputSchema, data);
+        assertValidWorkflowGraph(validated.workflow);
         const response = await this.execute(() => this.trpc.workflows.create.mutate(validated));
         return new Workflow(response);
     }
@@ -71,6 +80,9 @@ export class WorkflowsResource extends BaseResource {
      */
     async update(id, data) {
         const validated = this.validate(updateWorkflowInputSchema, data);
+        if (validated.workflow !== undefined) {
+            assertValidWorkflowGraph(validated.workflow);
+        }
         const response = await this.execute(() => this.trpc.workflows.update.mutate({ id, ...validated }));
         return new Workflow(response);
     }
@@ -86,6 +98,7 @@ export class WorkflowsResource extends BaseResource {
     async list(options) {
         const response = await this.execute(() => this.trpc.workflows.list.query({
             filter: options?.filter,
+            sort: options?.sort,
             limit: options?.limit,
             offset: options?.offset,
             cursor: options?.cursor,
@@ -96,6 +109,32 @@ export class WorkflowsResource extends BaseResource {
             pagination: response.pagination,
         };
     }
+    /**
+     * List workflows ordered by the timestamp of their most recent execution
+     * (most-recently-run first; never-run workflows appear last). Returns each
+     * workflow augmented with a `lastExecutedAt` field.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.workflows.listRecent({ limit: 10 });
+     * data.forEach((wf) => console.log(wf.name, wf.lastExecutedAt));
+     * ```
+     */
+    async listRecent(options) {
+        const response = await this.execute(() => this.trpc.workflows.listRecent.query({
+            limit: options?.limit,
+            cursor: options?.cursor,
+            includeTotalCount: options?.includeTotalCount,
+        }));
+        return {
+            data: response.data.map((item) => Object.assign(new Workflow(item), {
+                lastExecutedAt: item.lastExecutedAt
+                    ? new Date(item.lastExecutedAt)
+                    : null,
+            })),
+            pagination: response.pagination,
+        };
+    }
     /**
      * Count workflows matching the given filter.
      */
@@ -103,30 +142,110 @@ export class WorkflowsResource extends BaseResource {
         return this.execute(() => this.trpc.workflows.count.query({ filter }));
     }
     /**
-     * Manually trigger execution of a workflow.
-     *
-     * For scheduled workflows, pass `{ triggerType: "schedule" }`.
-     * For event workflows, pass `{ triggerType: "event", entityType, entityId }`.
+     * Fire a workflow execution. Returns `status: "queued"` immediately; the
+     * execution runs in the background. Use `runAndWait` if you want to
+     * block until the run finishes.
      *
      * @example
      * ```typescript
-     * // Scheduled workflow
-     * const result = await sdk.workflows.triggerExecution({
+     * const result = await sdk.workflows.run({
      *   id: workflowId,
-     *   triggerType: "schedule",
+     *   triggerType: "manual",
      * });
+     * if (result.ok) {
+     *   console.log("Queued:", result.executionId);
+     * }
+     * ```
+     */
+    async run(input) {
+        return this.execute(() => this.trpc.workflows.triggerExecution.mutate(input));
+    }
+    /**
+     * Fire a workflow execution and wait for it to reach a stopping state.
+     * Blocks for up to `options.timeoutMs` (default 30000, server-capped at
+     * 60000).
      *
-     * // Event workflow against a specific entity
-     * const result = await sdk.workflows.triggerExecution({
-     *   id: workflowId,
-     *   triggerType: "event",
-     *   entityType: "transaction",
-     *   entityId: "txn_123",
-     * });
+     * Possible outcomes:
+     *   - `status: "completed"` — the run finished (success or soft failure;
+     *     check `error`). `producedRecords` lists every record the run
+     *     created/updated (alerts, upserted clients/transactions,
+     *     subresources; capped per type) and `alertIds` is its alert subset.
+     *     `producedFiles` lists the files the run produced (descriptors
+     *     only — fetch contents via `executions.getFileDownloadUrl`).
+     *   - `status: "waiting_for_input"` — the run hit a human-in-loop step
+     *     (e.g. `form.choice`) and is paused waiting for a person to act on
+     *     it. The run won't finish without that, so the caller is returned
+     *     immediately instead of timing out. Surface the `executionId` to
+     *     your user (or display the workflow execution page) so they can
+     *     complete it.
+     *   - `status: "queued"` — the wait window elapsed before either of the
+     *     above. The caller can poll `executions.wait(id)` later.
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.workflows.runAndWait(
+     *   { id: workflowId, triggerType: "manual" },
+     *   { timeoutMs: 10000 },
+     * );
+     * if (result.ok) {
+     *   switch (result.status) {
+     *     case "completed": console.log("Done:", result.alertIds); break;
+     *     case "waiting_for_input": console.log("Needs human:", result.executionId); break;
+     *     case "queued": console.log("Still running:", result.executionId); break;
+     *   }
+     * }
      * ```
      */
+    async runAndWait(input, options) {
+        const queued = await this.run(input);
+        if (!queued.ok || queued.status !== "queued")
+            return queued;
+        const terminal = await this.executions.wait(queued.executionId, options);
+        const isTerminal = WorkflowExecutionStatusUtils.isTerminal(terminal.status);
+        const isWaiting = terminal.status === "waiting_for_input";
+        if (!isTerminal && !isWaiting)
+            return queued; // timeout — caller can retry
+        return {
+            ok: true,
+            workflowId: queued.workflowId,
+            executionId: queued.executionId,
+            status: isWaiting ? "waiting_for_input" : "completed",
+            error: isWaiting ? null : (terminal.error ?? null),
+            producedRecords: isWaiting ? [] : (terminal.producedRecords ?? []),
+            alertIds: isWaiting ? [] : (terminal.alertIds ?? []),
+            producedFiles: isWaiting ? [] : (terminal.producedFiles ?? []),
+            durationMs: isWaiting ? 0 : (terminal.durationMs ?? 0),
+            ...(queued.rowCount !== undefined && { rowCount: queued.rowCount }),
+            ...(queued.schemaHash !== undefined && { schemaHash: queued.schemaHash }),
+        };
+    }
+    /**
+     * Manually trigger execution of a workflow.
+     *
+     * @deprecated Use `run` for fire-and-forget or `runAndWait` for sync
+     *   semantics. This method now wraps `runAndWait` to preserve the
+     *   pre-async-dispatch contract — note that API triggers, which
+     *   previously returned `queued` from `triggerExecution`, now wait by
+     *   default; switch to `run` if you want the old API-trigger behavior.
+     */
     async triggerExecution(input) {
-        return this.execute(() => this.trpc.workflows.triggerExecution.mutate(input));
+        return this.runAndWait(input);
+    }
+    /**
+     * Mint a public URL for a trigger.api node. The returned `friendlyId`
+     * is the path slug for `POST /v1/triggers/{friendlyId}`.
+     */
+    async createApiEndpoint(input) {
+        return this.execute(() => this.trpc.workflows.apiEndpoints.create.mutate(input));
+    }
+    async listApiEndpoints(input) {
+        return this.execute(() => this.trpc.workflows.apiEndpoints.list.query(input));
+    }
+    async updateApiEndpointLabel(input) {
+        return this.execute(() => this.trpc.workflows.apiEndpoints.updateLabel.mutate(input));
+    }
+    async revokeApiEndpoint(input) {
+        return this.execute(() => this.trpc.workflows.apiEndpoints.revoke.mutate(input));
     }
     async getFileUploadUrl(input) {
         return this.execute(() => this.trpc.workflows.getFileUploadUrl.mutate(input));
@@ -167,6 +286,26 @@ export class WorkflowsResource extends BaseResource {
             liveWorkflow: new Workflow(response.liveWorkflow),
         };
     }
+    /**
+     * Recreate the test counterpart for a live workflow that has none.
+     *
+     * Live workflows are config-immutable — you edit in test and re-promote.
+     * When a live workflow's test counterpart was deleted, this recreates a
+     * draft test workflow from the live config and links the two, so a later
+     * {@link promote} updates this same live workflow. Idempotent: returns the
+     * existing test counterpart if one already exists. Must be called from a
+     * live environment SDK instance.
+     *
+     * @example
+     * ```typescript
+     * const testWorkflow = await sdk.workflows.recreateInTest(liveWorkflowId);
+     * console.log(testWorkflow.status); // "draft"
+     * ```
+     */
+    async recreateInTest(id) {
+        const response = await this.execute(() => this.trpc.workflows.recreateInTest.mutate({ id }));
+        return new Workflow(response);
+    }
     // ─────────────────────────────────────────────────────────────────
     // Tag Operations
     // ─────────────────────────────────────────────────────────────────
@@ -197,5 +336,28 @@ export class WorkflowsResource extends BaseResource {
 }
 // Re-export sub-resources for direct access
 export { WorkflowExecutionsResource } from "./workflow-executions";
+export { WorkflowLinksResource } from "./workflow-links";
 export { WorkflowTemplatesResource } from "./workflow-templates";
 export { WorkflowVariablesResource } from "./workflow-variables";
+/**
+ * Runs the shared structural validator (cycles, bad edges, duplicate
+ * single-instance nodes, incompatible data types, etc.) and throws a
+ * `ValidationError` if anything fails. This is the same validator the
+ * server runs on create/update/execute — running it client-side saves
+ * a round-trip and lets consumers handle graph errors the same way they
+ * handle zod issues.
+ */
+function assertValidWorkflowGraph(workflow) {
+    const errors = validateWorkflow(workflow);
+    if (errors.length === 0)
+        return;
+    throw new ValidationError(errors.map(workflowErrorToIssue));
+}
+function workflowErrorToIssue(error) {
+    const path = ["workflow"];
+    if (error.nodeId)
+        path.push("nodes", error.nodeId);
+    else if (error.edgeId)
+        path.push("edges", error.edgeId);
+    return { path, message: error.message, code: error.code };
+}

package/dist/sdk/ComplianceSDK.d.ts

@@ -4,12 +4,12 @@
  * This class provides access to all compliance API resources.
  * It initializes the tRPC client and all resource managers.
  *
- * The SDK can be scoped to a specific jurisdiction/activity via the `scope` field,
+ * The SDK can be scoped to a specific scope/activity via the `scope` field,
  * which automatically applies to all resource operations.
  *
  * @example
  * ```typescript
- * // Unscoped SDK - works with any jurisdiction
+ * // Unscoped SDK - works with any scope
  * const sdk = new ComplianceSDK({
  *   apiKey: process.env.COMPLIANCE_API_KEY!,
  *   environment: "test",
@@ -36,9 +36,9 @@
  * });
  * ```
  */
-import type { Scope } from "@artu-ai/shared";
+import type { Locale, Scope } from "@artu-ai/shared";
 import { type SDKSessionOptions, type SDKSessionOptionsWithReturnTo, type SessionResultWithoutRedirect, type SessionResultWithRedirect } from "../utils/session";
-import { type APIVersion, type TRPCClient } from "../utils/trpc-client";
+import { type APIVersion } from "../utils/trpc-client";
 import { type UnscopedSDKOptions } from "./base";
 import { type AVIComplianceSDK, type AVISDKOptions } from "./mx/av/avi/types";
 import { type JYSComplianceSDK, type JYSSDKOptions } from "./mx/av/jys/types";
@@ -47,12 +47,14 @@ import { type TransmisorComplianceSDK, type TransmisorSDKOptions } from "./mx/cn
 import { type ComplianceSDKOptionsMexico, type MexicoComplianceSDK, type MexicoSDKOptions } from "./mx/types";
 import { type BaseComplianceSDK, type ComplianceAuthMode, type Environment, type FetchCredentials } from "./types";
 export type { ComplianceSDKOptionsBase } from "./types";
-import { AddressesResource, type AlertsResource, ApiKeysResource, AuditLogsResource, BankAccountsResource, type ClientsResource, ContactMethodsResource, DocumentsResource, ExchangeRatesResource, OcrResource, OnboardingResource, ProductsResource, ReferenceDataResource, ReportsResource, RolesResource, TagsResource, TenantResource, type TransactionsResource, UsersResource, WorkflowsResource } from "../resources";
+import { AddressesResource, type AlertsResource, ApiKeysResource, AuditLogsResource, BankAccountsResource, type ClientsResource, ContactMethodsResource, DocumentsResource, EvidenceResource, ExchangeRatesResource, ProductsResource, ReferenceDataResource, ReportsResource, RolesResource, SignableTemplatesResource, TagsResource, TenantResource, type TransactionsResource, UsersResource, WorkflowsResource } from "../resources";
+import { IdentityResource } from "../resources/identity";
+import { ScreeningResource } from "../resources/screening";
 export type { ComplianceSDKOptionsMexico, MexicoSDKOptions, AVISDKOptions, JYSSDKOptions, TSCSDKOptions, TransmisorSDKOptions, MexicoComplianceSDK, AVIComplianceSDK, JYSComplianceSDK, TSCComplianceSDK, TransmisorComplianceSDK, };
 /**
  * SDK configuration options.
  *
- * Use `scope` to target a specific jurisdiction/activity.
+ * Use `scope` to target a specific scope/activity.
  */
 export type ComplianceSDKOptions = UnscopedSDKOptions | ComplianceSDKOptionsMexico;
 /**
@@ -67,18 +69,20 @@ export interface UnscopedComplianceSDK extends BaseComplianceSDK {
     readonly addresses: AddressesResource;
     readonly contactMethods: ContactMethodsResource;
     readonly documents: DocumentsResource;
+    readonly evidence: EvidenceResource;
     readonly exchangeRates: ExchangeRatesResource;
     readonly referenceData: ReferenceDataResource;
     readonly reports: ReportsResource;
     readonly workflows: WorkflowsResource;
-    readonly ocr: OcrResource;
-    readonly onboarding: OnboardingResource;
     readonly tenant: TenantResource;
+    readonly signableTemplates: SignableTemplatesResource;
     readonly tags: TagsResource;
     readonly roles: RolesResource;
     readonly users: UsersResource;
     readonly apiKeys: ApiKeysResource;
     readonly auditLogs: AuditLogsResource;
+    readonly screening: ScreeningResource;
+    readonly identity: IdentityResource;
 }
 /**
  * Main entry point for the Compliance SDK.
@@ -94,7 +98,7 @@ export interface UnscopedComplianceSDK extends BaseComplianceSDK {
  *
  * ## Scoping
  *
- * The SDK can be scoped to a specific jurisdiction/activity:
+ * The SDK can be scoped to a specific scope/activity:
  *
  * ```typescript
  * // Unscoped - generic SDK
@@ -142,12 +146,12 @@ export interface UnscopedComplianceSDK extends BaseComplianceSDK {
  * ```
  */
 export declare class ComplianceSDKImpl {
-    /** tRPC client for API communication */
-    protected readonly trpc: TRPCClient;
     /** Current environment */
     protected readonly _environment: Environment;
     /** Current API version */
     protected readonly _apiVersion: APIVersion;
+    /** Current locale */
+    protected _locale: Locale;
     /** SDK scope */
     protected readonly _scope: Scope | undefined;
     /** Resolved base URL */
@@ -200,6 +204,12 @@ export declare class ComplianceSDKImpl {
      * Provides upload, download, and management for client documents.
      */
     readonly documents: DocumentsResource;
+    /**
+     * Evidence resource manager.
+     *
+     * Provides upload, download, and management for compliance evidence records.
+     */
+    readonly evidence: EvidenceResource;
     /**
      * Alerts resource manager.
      *
@@ -249,16 +259,6 @@ export declare class ComplianceSDKImpl {
      * Provides access to workflow-related sub-resources (variables, executions, templates).
      */
     readonly workflows: WorkflowsResource;
-    /**
-     * OCR resource for document text extraction.
-     */
-    readonly ocr: OcrResource;
-    /**
-     * Onboarding resource.
-     *
-     * Namespace for onboarding operations (links, forms, etc.).
-     */
-    readonly onboarding: OnboardingResource;
     /**
      * Tenant resource.
      *
@@ -271,6 +271,13 @@ export declare class ComplianceSDKImpl {
      * Manage organization roles and user role assignments.
      */
     readonly roles: RolesResource;
+    /**
+     * Signable Templates resource.
+     *
+     * Admin catalog over the unified `signable_templates` table — privacy
+     * notices, NDAs, contracts, declarations, and other signable PDFs.
+     */
+    readonly signableTemplates: SignableTemplatesResource;
     /**
      * Users resource.
      *
@@ -297,6 +304,18 @@ export declare class ComplianceSDKImpl {
      * Read-only access to the immutable audit trail of all resource mutations.
      */
     readonly auditLogs: AuditLogsResource;
+    /**
+     * Screening resource (top-level, global).
+     *
+     * Screening surface for sanctions / PEP / blacklist checks.
+     */
+    readonly screening: ScreeningResource;
+    /**
+     * Identity resource (top-level, global).
+     *
+     * Identity-verification surface for CURP / INE / RFC checks.
+     */
+    readonly identity: IdentityResource;
     constructor(options: ComplianceSDKOptions);
     /**
      * Current environment ("test" or "live").
@@ -306,6 +325,21 @@ export declare class ComplianceSDKImpl {
      * Current API version.
      */
     get apiVersion(): APIVersion;
+    /**
+     * Current locale used for SDK-owned API requests.
+     */
+    get locale(): Locale;
+    /**
+     * Updates the locale used by subsequent SDK-owned API requests.
+     */
+    setLocale(locale: Locale | string): void;
+    /**
+     * Resolved base URL the SDK targets (e.g. `https://api.artu.ai`,
+     * `http://localhost:4000`). Useful when a UI needs to surface a
+     * derived URL to the user (e.g. the public API trigger endpoint URL)
+     * without re-implementing the resolution chain.
+     */
+    get baseUrl(): string;
     /**
      * Whether SDK is running in test environment.
      */
@@ -374,4 +408,3 @@ export interface ComplianceSDKConstructor {
 }
 export declare const ComplianceSDK: ComplianceSDKConstructor;
 export type ComplianceSDK = InstanceType<typeof ComplianceSDKImpl>;
-//# sourceMappingURL=ComplianceSDK.d.ts.map