@dossier-wiki/os-sdk 0.7.0 → 1.3.0

package/dist/service.js

@@ -19,15 +19,28 @@ export class DossiersOSAPIService {
     accounts;
     counterparties;
     devices;
+    paymentInstruments;
+    sessions;
+    channelEndpoints;
     transactions;
+    transactionAttempts;
+    behaviorSettings;
     events;
+    riskSignals;
+    employees;
+    branches;
     exchangeRates;
+    states;
     identificationDocuments;
     alerts;
     platform;
     config;
     setup;
     settings;
+    customLists;
+    teams;
+    reports;
+    partyRelationships;
     constructor(options) {
         if (!options.baseUrl)
             throw new Error('DossiersOSAPIService: baseUrl is required');
@@ -44,15 +57,28 @@ export class DossiersOSAPIService {
         this.accounts = new AccountsResource(req);
         this.counterparties = new CounterpartiesResource(req);
         this.devices = new DevicesResource(req);
+        this.paymentInstruments = new PaymentInstrumentsResource(req);
+        this.sessions = new SessionsResource(req);
+        this.channelEndpoints = new ChannelEndpointsResource(req);
         this.transactions = new TransactionsResource(req);
+        this.transactionAttempts = new TransactionAttemptsResource(req);
+        this.behaviorSettings = new BehaviorSettingsResource(req);
         this.events = new EventsResource(req);
+        this.riskSignals = new RiskSignalsResource(req);
+        this.employees = new EmployeesResource(req);
+        this.branches = new BranchesResource(req);
         this.exchangeRates = new ExchangeRatesResource(req);
+        this.states = new StatesResource(req);
         this.identificationDocuments = new IdentificationDocumentsResource(req);
         this.alerts = new AlertsResource(req);
         this.platform = new PlatformResource(req);
         this.config = new ConfigResource(req);
         this.setup = new SetupResource(req);
         this.settings = new SettingsResource(req);
+        this.customLists = new CustomListsResource(req);
+        this.teams = new TeamsResource(req);
+        this.reports = new ReportsResource((path) => this.requestBinary(path));
+        this.partyRelationships = new PartyRelationshipsResource(req);
     }
     async request(method, path, opts = {}) {
         const url = new URL(`${this.baseUrl}${path}`);
@@ -92,6 +118,44 @@ export class DossiersOSAPIService {
         }
         return parsed;
     }
+    /** GET a binary body (PDF reports). Errors are parsed the same way as JSON requests. */
+    async requestBinary(path) {
+        const url = `${this.baseUrl}${path}`;
+        const response = await this.fetchImpl(url, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${this.apiKey}`, Accept: 'application/pdf' },
+        });
+        if (!response.ok) {
+            const raw = await response.text();
+            const parsed = raw.length > 0 ? safeJsonParse(raw) : undefined;
+            const message = (parsed && typeof parsed === 'object' && 'message' in parsed
+                ? String(parsed.message)
+                : null) ?? `Dossiers OS API GET ${path} failed: ${response.status}`;
+            throw new DossiersOSAPIError(response.status, message, parsed ?? raw);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+}
+export class PartyRelationshipsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    listTypes() {
+        return this.req('GET', '/v1/party-relationships/types');
+    }
+    createType(input) {
+        return this.req('POST', '/v1/party-relationships/types', { body: input });
+    }
+    list(partyType, partyId) {
+        return this.req('GET', '/v1/party-relationships', { query: { partyType, partyId } });
+    }
+    create(input) {
+        return this.req('POST', '/v1/party-relationships', { body: input });
+    }
+    end(id) {
+        return this.req('POST', `/v1/party-relationships/${encodeURIComponent(id)}/end`);
+    }
 }
 function safeJsonParse(raw) {
     try {
@@ -191,8 +255,16 @@ export class IndividualsResource {
     list(query = {}) {
         return this.req('GET', '/v1/customers/individuals', { query });
     }
-    create(input) {
-        return this.req('POST', '/v1/customers/individuals', { body: input });
+    /**
+     * `POST /v1/customers/individuals` — create an individual. Pass
+     * `{ screening: 'sync' }` to run the INITIAL screening before the call
+     * returns; the result and its matches then arrive under `screening`.
+     */
+    create(input, options = {}) {
+        return this.req('POST', '/v1/customers/individuals', {
+            body: input,
+            query: { screening: options.screening },
+        });
     }
     get(customerId, query = {}) {
         return this.req('GET', `/v1/customers/individuals/${encodeURIComponent(customerId)}`, {
@@ -256,8 +328,16 @@ export class EntitiesResource {
     list(query = {}) {
         return this.req('GET', '/v1/customers/entities', { query });
     }
-    create(input) {
-        return this.req('POST', '/v1/customers/entities', { body: input });
+    /**
+     * `POST /v1/customers/entities` — create an entity. Pass
+     * `{ screening: 'sync' }` to run the INITIAL screening before the call
+     * returns; the result and its matches then arrive under `screening`.
+     */
+    create(input, options = {}) {
+        return this.req('POST', '/v1/customers/entities', {
+            body: input,
+            query: { screening: options.screening },
+        });
     }
     get(customerId, query = {}) {
         return this.req('GET', `/v1/customers/entities/${encodeURIComponent(customerId)}`, {
@@ -301,23 +381,104 @@ export class EntityIdentificationDocumentsResource {
     }
 }
 export class CustomersResource {
+    req;
     notes;
     files;
     screening;
+    kyc;
     riskRating;
     status;
     riskAssessments;
     expectedActivity;
     devices;
+    assignment;
     constructor(req) {
+        this.req = req;
         this.notes = new CustomerNotesResource(req);
         this.files = new CustomerFilesResource(req);
         this.screening = new CustomerScreeningResource(req);
+        this.kyc = new CustomerKycResource(req);
         this.riskRating = new CustomerRiskRatingResource(req);
         this.status = new CustomerStatusResource(req);
         this.riskAssessments = new CustomerRiskAssessmentsResource(req);
         this.expectedActivity = new CustomerExpectedActivityResource(req);
         this.devices = new CustomerDevicesResource(req);
+        this.assignment = new CustomerAssignmentResource(req);
+    }
+    /**
+     * `POST /v1/customers/{customerId}/archive` — archive a customer
+     * (organization owner/admin only, irreversible). Frees the customer's
+     * external ID for reuse and makes the record read-only.
+     */
+    archive(customerId, input = {}) {
+        return this.req('POST', `/v1/customers/${encodeURIComponent(customerId)}/archive`, {
+            body: input,
+        });
+    }
+}
+export class CustomerAssignmentResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * `POST /v1/customers/{customerId}/assignment` — add users/teams to a
+     * customer's standing assignment (additive; never silently removes).
+     */
+    assign(customerId, input) {
+        return this.req('POST', `/v1/customers/${encodeURIComponent(customerId)}/assignment`, {
+            body: input,
+        });
+    }
+    /**
+     * `DELETE /v1/customers/{customerId}/assignment` — remove users/teams from
+     * a customer's standing assignment.
+     */
+    unassign(customerId, input) {
+        return this.req('DELETE', `/v1/customers/${encodeURIComponent(customerId)}/assignment`, {
+            body: input,
+        });
+    }
+    /**
+     * `POST /v1/customers/assignment` — assign many customers to the same
+     * users/teams. Customers that already carry the target are skipped.
+     */
+    assignMany(input) {
+        return this.req('POST', '/v1/customers/assignment', { body: input });
+    }
+}
+export class TeamsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * Active teams. `tags` is an any-of filter over the team's `team.tags`
+     * catalogue values (repeated as `?tags=a&tags=b`).
+     */
+    list(query = {}) {
+        return this.req('GET', '/v1/teams', { query });
+    }
+    get(id) {
+        return this.req('GET', `/v1/teams/${encodeURIComponent(id)}`);
+    }
+    create(input) {
+        return this.req('POST', '/v1/teams', { body: input });
+    }
+    update(id, input) {
+        return this.req('PATCH', `/v1/teams/${encodeURIComponent(id)}`, { body: input });
+    }
+    archive(id) {
+        return this.req('POST', `/v1/teams/${encodeURIComponent(id)}/archive`);
+    }
+    delete(id) {
+        return this.req('DELETE', `/v1/teams/${encodeURIComponent(id)}`);
+    }
+    addMembers(id, input) {
+        return this.req('POST', `/v1/teams/${encodeURIComponent(id)}/members`, { body: input });
+    }
+    removeMembers(id, input) {
+        return this.req('DELETE', `/v1/teams/${encodeURIComponent(id)}/members`, { body: input });
     }
 }
 export class CustomerNotesResource {
@@ -371,10 +532,89 @@ export class CustomerScreeningResource {
     trigger(customerId) {
         return this.req('POST', `/v1/customers/${encodeURIComponent(customerId)}/screen`);
     }
+    /**
+     * `GET /v1/customers/{customerId}/screening-history` — every screening run
+     * for the customer, most recent first. `limit` caps the number of entries
+     * returned (default 50 server-side).
+     */
+    listHistory(customerId, params = {}) {
+        const query = {};
+        if (params.limit !== undefined)
+            query.limit = params.limit;
+        return this.req('GET', `/v1/customers/${encodeURIComponent(customerId)}/screening-history`, { query });
+    }
+    /**
+     * `GET /v1/customers/{customerId}/screening-history/latest` — the most
+     * recent screening run, or `null` if the customer has never been screened.
+     */
+    async getLast(customerId) {
+        const latest = await this.req('GET', `/v1/customers/${encodeURIComponent(customerId)}/screening-history/latest`);
+        return latest ?? null;
+    }
+    /**
+     * `GET /v1/customers/{customerId}/screening-results` — every match for the
+     * customer with its current disposition (true positives = `CONFIRMED`,
+     * false positives = `FALSE_POSITIVE`, plus undecided `PENDING`, which
+     * also covers matches a workflow reviewer marked inconclusive). Pass
+     * `disposition` to filter (e.g. `['CONFIRMED', 'FALSE_POSITIVE']`).
+     */
+    listResults(customerId, params = {}) {
+        const query = {};
+        if (params.disposition && params.disposition.length > 0) {
+            query.disposition = params.disposition.join(',');
+        }
+        return this.req('GET', `/v1/customers/${encodeURIComponent(customerId)}/screening-results`, { query });
+    }
+    /**
+     * `GET /v1/customers/{customerId}/confirmed-matches` — confirmed
+     * (true-positive) matches only. Alias for `listResults` filtered to
+     * `CONFIRMED`, kept for backwards compatibility.
+     */
     listConfirmedMatches(customerId) {
         return this.req('GET', `/v1/customers/${encodeURIComponent(customerId)}/confirmed-matches`);
     }
 }
+/**
+ * KYC verification sessions for a customer. A session is an asynchronous,
+ * customer-driven flow: `start()` returns a hosted `sessionUrl` the customer
+ * visits; completion arrives out-of-band (provider webhook) or can be pulled
+ * with `refresh()`.
+ */
+export class CustomerKycResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * `POST /v1/customers/{customerId}/kyc/sessions` — start a KYC session with
+     * the organization's active provider. Hand the returned `sessionUrl` to the
+     * customer.
+     */
+    start(customerId) {
+        return this.req('POST', `/v1/customers/${encodeURIComponent(customerId)}/kyc/sessions`);
+    }
+    /**
+     * `GET /v1/customers/{customerId}/kyc/sessions` — list a customer's KYC
+     * sessions, newest first.
+     */
+    list(customerId) {
+        return this.req('GET', `/v1/customers/${encodeURIComponent(customerId)}/kyc/sessions`);
+    }
+    /**
+     * `POST /v1/customers/{customerId}/kyc/sessions/{sessionId}/refresh` — pull
+     * the latest provider state for a session and persist it.
+     */
+    refresh(customerId, sessionId) {
+        return this.req('POST', `/v1/customers/${encodeURIComponent(customerId)}/kyc/sessions/${encodeURIComponent(sessionId)}/refresh`);
+    }
+    /**
+     * `DELETE /v1/customers/{customerId}/kyc/sessions/{sessionId}` — cancel the
+     * session at the provider and remove the local record.
+     */
+    delete(customerId, sessionId) {
+        return this.req('DELETE', `/v1/customers/${encodeURIComponent(customerId)}/kyc/sessions/${encodeURIComponent(sessionId)}`);
+    }
+}
 export class CustomerRiskRatingResource {
     req;
     constructor(req) {
@@ -539,6 +779,62 @@ export class DevicesResource {
     get(deviceId) {
         return this.req('GET', `/v1/devices/${encodeURIComponent(deviceId)}`);
     }
+    /** Canonicalize the source device into the target without deleting history. */
+    merge(targetDeviceId, input) {
+        return this.req('POST', `/v1/devices/${encodeURIComponent(targetDeviceId)}/merge`, { body: input });
+    }
+}
+export class PaymentInstrumentsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list() {
+        return this.req('GET', '/v1/payment-instruments');
+    }
+    get(id) {
+        return this.req('GET', `/v1/payment-instruments/${encodeURIComponent(id)}`);
+    }
+    create(input) {
+        return this.req('POST', '/v1/payment-instruments', { body: input });
+    }
+    update(id, input) {
+        return this.req('PATCH', `/v1/payment-instruments/${encodeURIComponent(id)}`, { body: input });
+    }
+    linkAccount(id, input) {
+        return this.req('POST', `/v1/payment-instruments/${encodeURIComponent(id)}/accounts`, { body: input });
+    }
+    unlinkAccount(id, relationshipId, validTo) {
+        return this.req('POST', `/v1/payment-instruments/${encodeURIComponent(id)}/accounts/${encodeURIComponent(relationshipId)}/unlink`, { body: { validTo } });
+    }
+    linkCustomer(id, input) {
+        return this.req('POST', `/v1/payment-instruments/${encodeURIComponent(id)}/customers`, { body: input });
+    }
+    unlinkCustomer(id, relationshipId, validTo) {
+        return this.req('POST', `/v1/payment-instruments/${encodeURIComponent(id)}/customers/${encodeURIComponent(relationshipId)}/unlink`, { body: { validTo } });
+    }
+}
+export class SessionsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list() { return this.req('GET', '/v1/sessions'); }
+    get(id) { return this.req('GET', `/v1/sessions/${encodeURIComponent(id)}`); }
+    update(id, input) {
+        return this.req('PATCH', `/v1/sessions/${encodeURIComponent(id)}`, { body: input });
+    }
+}
+export class ChannelEndpointsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list() { return this.req('GET', '/v1/channel-endpoints'); }
+    get(id) { return this.req('GET', `/v1/channel-endpoints/${encodeURIComponent(id)}`); }
+    update(id, input) {
+        return this.req('PATCH', `/v1/channel-endpoints/${encodeURIComponent(id)}`, { body: input });
+    }
 }
 export class TransactionsResource {
     req;
@@ -555,16 +851,193 @@ export class TransactionsResource {
     patchStatus(input) {
         return this.req('PATCH', '/v1/transactions', { body: input });
     }
+    /**
+     * Read back a stored transaction. By default `reference` is your own
+     * `transactionId`; pass `{ by: 'id' }` to look up the internal UUID
+     * returned by `ingest()`.
+     */
+    get(reference, opts = {}) {
+        return this.req('GET', `/v1/transactions/${encodeURIComponent(reference)}`, {
+            query: opts.by ? { by: opts.by } : undefined,
+        });
+    }
+}
+export class TransactionAttemptsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * `POST /v1/transaction-attempts` — retain a failed, blocked, or unknown
+     * operation as behavioural history. This does not trigger rule evaluation.
+     */
+    ingest(input) {
+        return this.req('POST', '/v1/transaction-attempts', { body: input });
+    }
+    /** List retained attempts using an opaque, stable cursor. Requires `config:read`. */
+    list(input = {}) {
+        return this.req('GET', '/v1/transaction-attempts', { query: input });
+    }
+    /** Read one retained attempt by its database id. Requires `config:read`. */
+    get(id) {
+        return this.req('GET', `/v1/transaction-attempts/${encodeURIComponent(id)}`);
+    }
+}
+export class BehaviorSettingsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    get() {
+        return this.req('GET', '/v1/config/behavior-settings');
+    }
+    update(input) {
+        return this.req('PATCH', '/v1/config/behavior-settings', { body: input });
+    }
 }
 export class EventsResource {
     req;
     constructor(req) {
         this.req = req;
     }
+    /**
+     * `POST /v1/events` — store a behavioral event.
+     *
+     * Every event is about exactly one resource: pass
+     * `resource: { type, id }`. A bare top-level `customerId` is still
+     * accepted as the legacy spelling of `resource: { type: 'CUSTOMER', id }`,
+     * and `resource` wins when both are present; an event naming neither is
+     * rejected with 400.
+     *
+     * Supply `input.eventId` (your unique identifier) to make retries safe:
+     * resubmitting the same `eventId` returns the original stored event with
+     * `cached: true` instead of creating a duplicate. Idempotency covers the
+     * event's Risk Signals too — a replay echoes the same `riskSignalIds`
+     * rather than emitting a second set.
+     *
+     * The response carries the resolved `resource` and the `riskSignalIds`
+     * emitted by the event definition's `riskSignalEffects`.
+     */
     ingest(input) {
         return this.req('POST', '/v1/events', { body: input });
     }
 }
+/**
+ * Risk Signals — time-decaying evidence attached to one resource.
+ *
+ * A Risk Signal is evidence, **not** an Alert: adding one creates no alert, no
+ * notification, no assignment and no task, and does not change the resource's
+ * Risk Rating. Rules read the aggregate effective weight and decide for
+ * themselves.
+ */
+export class RiskSignalsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * `POST /v1/risk-signals` — attach a piece of evidence to one resource.
+     *
+     * The signal records the strength it had at `occurredAt` and how fast that
+     * strength halves, so weight 40 with half-life `P7D` reads 20 after seven
+     * days and 10 after fourteen.
+     *
+     * Supply `externalId` to make retries safe — resubmitting the same
+     * `externalId` returns the original signal instead of adding a second one.
+     *
+     * The server sets the source to `MANUAL` and captures the authenticated
+     * actor; a caller cannot claim a signal came from an Event or a Rule.
+     */
+    create(input) {
+        return this.req('POST', '/v1/risk-signals', { body: input });
+    }
+    /**
+     * `GET /v1/risk-signals` — read a resource's Risk Signals with their
+     * decayed weights, plus the aggregate effective weight.
+     *
+     * The aggregate is computed as of `asOf` (defaulting to server time) — it
+     * is not a cached score column on the resource, so a historical `asOf`
+     * returns what the resource looked like at that moment.
+     *
+     * `type` and `sourceType` filter which records contribute. They never
+     * change how far a contributing signal has decayed: age is always measured
+     * to `asOf`.
+     */
+    list(query) {
+        return this.req('GET', '/v1/risk-signals', { query });
+    }
+}
+/**
+ * Employees — people acting inside the financial institution's ecosystem.
+ *
+ * Monitored domain data, distinct from Dossiers organization members: an
+ * Employee need not have a Dossiers login, and an Employee id is never an
+ * org-member id. Employees are an attachable resource for Events and Risk
+ * Signals.
+ */
+export class EmployeesResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * `GET /v1/employees`.
+     *
+     * The endpoint declares `cursor` / `limit`, but the server currently
+     * resolves its own paging defaults (first page, 50 records) — treat paging
+     * as server-defaulted rather than caller-controlled.
+     */
+    list(query = {}) {
+        return this.req('GET', '/v1/employees', { query });
+    }
+    get(id) {
+        return this.req('GET', `/v1/employees/${encodeURIComponent(id)}`);
+    }
+    /**
+     * `POST /v1/employees`. `externalEmployeeId` must be unique within the
+     * organization; a duplicate is rejected with 400.
+     */
+    create(input) {
+        return this.req('POST', '/v1/employees', { body: input });
+    }
+    update(id, input) {
+        return this.req('PATCH', `/v1/employees/${encodeURIComponent(id)}`, { body: input });
+    }
+}
+/**
+ * Branches — the institution's own physical or organizational units, through
+ * which Employees act. Like Employee, an attachable resource for Events and
+ * Risk Signals.
+ */
+export class BranchesResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /**
+     * `GET /v1/branches`.
+     *
+     * The endpoint declares `cursor` / `limit`, but the server currently
+     * resolves its own paging defaults (first page, 50 records) — treat paging
+     * as server-defaulted rather than caller-controlled.
+     */
+    list(query = {}) {
+        return this.req('GET', '/v1/branches', { query });
+    }
+    get(id) {
+        return this.req('GET', `/v1/branches/${encodeURIComponent(id)}`);
+    }
+    /**
+     * `POST /v1/branches`. `externalBranchId` must be unique within the
+     * organization.
+     */
+    create(input) {
+        return this.req('POST', '/v1/branches', { body: input });
+    }
+    update(id, input) {
+        return this.req('PATCH', `/v1/branches/${encodeURIComponent(id)}`, { body: input });
+    }
+}
 export class ExchangeRatesResource {
     req;
     constructor(req) {
@@ -589,6 +1062,12 @@ export class IdentificationDocumentsResource {
     get(id) {
         return this.req('GET', `/v1/identification-documents/${encodeURIComponent(id)}`);
     }
+    /**
+     * Correct captured document fields (name, number, DOB, addresses, …).
+     * Captured fields are frozen while the document is `APPROVED` (400) —
+     * `transition` it back to `PENDING` first. `notes`/`tags`/`attachments`
+     * stay editable in any status.
+     */
     update(id, input) {
         return this.req('PATCH', `/v1/identification-documents/${encodeURIComponent(id)}`, {
             body: input,
@@ -612,16 +1091,61 @@ export class IdentificationDocumentsResource {
     }
 }
 /**
- * Surfaces comments on alerts received via webhooks. The OS API does not
- * currently expose a top-level alerts CRUD; alerts are produced by rule
- * evaluation and delivered via webhooks. This resource lets callers
- * attach/inspect notes against an alert id without going through the
- * platform comments interface.
+ * Alerts. Screening and rule-trigger alerts are produced by the platform and
+ * delivered via webhooks; **custom alerts** are raised here against an
+ * org-defined Custom Alert Type (`config.customAlertTypes`). Every alert type
+ * supports markdown notes, linked resources and comments.
+ *
+ * Requires the `alerts:read` / `alerts:write` API-key permissions.
  */
 export class AlertsResource {
+    req;
     comments;
+    resources;
     constructor(req) {
+        this.req = req;
         this.comments = new ResourceCommentsProxy(req, 'ALERT');
+        this.resources = new AlertResourcesProxy(req);
+    }
+    /**
+     * Raise an alert by hand. `alertType` is optional: with one, `fields` are
+     * validated against the type's schema; without one the alert is free-form
+     * and `fields` are self-declaring. Re-sending the same `externalRequestId`
+     * returns the existing alert (201 either way) — the key is scoped per
+     * organization.
+     */
+    create(input) {
+        return this.req('POST', '/v1/alerts', { body: input });
+    }
+    /** Flat view of any alert, with its linked resources. */
+    get(alertId) {
+        return this.req('GET', `/v1/alerts/${encodeURIComponent(alertId)}`);
+    }
+    /** Replace the alert's markdown notes (any alert type). */
+    updateNotes(alertId, input) {
+        return this.req('PATCH', `/v1/alerts/${encodeURIComponent(alertId)}/notes`, { body: input });
+    }
+    /** Immutable attempt facts captured when attempt-history rules contributed to an alert. */
+    attemptEvidence(alertId) {
+        return this.req('GET', `/v1/alerts/${encodeURIComponent(alertId)}/attempt-evidence`);
+    }
+}
+/** Resources linked to an alert — `/v1/alerts/{id}/resources`. */
+export class AlertResourcesProxy {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list(alertId) {
+        return this.req('GET', `/v1/alerts/${encodeURIComponent(alertId)}/resources`);
+    }
+    /** Idempotent on (resourceType, resourceId): re-linking returns the existing link. */
+    add(alertId, input) {
+        return this.req('POST', `/v1/alerts/${encodeURIComponent(alertId)}/resources`, { body: input });
+    }
+    /** `alertResourceId` is the link id from `list` / `add`, not the target's id. */
+    remove(alertId, alertResourceId) {
+        return this.req('DELETE', `/v1/alerts/${encodeURIComponent(alertId)}/resources/${encodeURIComponent(alertResourceId)}`);
     }
 }
 /**
@@ -681,21 +1205,32 @@ export class ConfigResource {
     req;
     rules;
     constants;
+    alertWorkflows;
+    /** @deprecated Read-only archive. Use alertWorkflows for assignment. */
+    states;
+    assignmentPolicies;
     products;
     currencies;
     eventDefinitions;
+    customAlertTypes;
     webhooks;
     tagCatalogue;
+    tagGroups;
     sync;
     constructor(req) {
         this.req = req;
         this.rules = new ConfigRulesResource(req);
         this.constants = new ConfigConstantsResource(req);
+        this.alertWorkflows = new ConfigAlertWorkflowsResource(req);
+        this.states = new ConfigStatesResource(req);
+        this.assignmentPolicies = new ConfigAssignmentPoliciesResource(req);
         this.products = new ConfigProductsResource(req);
         this.currencies = new ConfigCurrenciesResource(req);
         this.eventDefinitions = new ConfigEventDefinitionsResource(req);
+        this.customAlertTypes = new ConfigCustomAlertTypesResource(req);
         this.webhooks = new ConfigWebhooksResource(req);
         this.tagCatalogue = new ConfigTagCatalogueResource(req);
+        this.tagGroups = new ConfigTagGroupsResource(req);
         this.sync = new ConfigSyncResource(req);
     }
     /** `DELETE /v1/config/reset` — clear all org config (destructive). */
@@ -744,9 +1279,30 @@ export class ConfigRulesResource {
     getBySyncKey(syncKey) {
         return this.req('GET', `/v1/config/rules/by-sync-key/${encodeURIComponent(syncKey)}`);
     }
+    /**
+     * Dry-run rule simulation (spec v0 rules §11 backtest + synthetic
+     * source). Read-only: nothing is persisted and no actions execute —
+     * the response summarises what WOULD have happened. Requires only
+     * `config:read`.
+     */
+    backtest(input) {
+        return this.req('POST', '/v1/config/rules/backtest', { body: input });
+    }
     get(id) {
         return this.req('GET', `/v1/config/rules/${encodeURIComponent(id)}`);
     }
+    /** List a rule's definitional version history, newest first (audit trail). */
+    versions(id) {
+        return this.req('GET', `/v1/config/rules/${encodeURIComponent(id)}/versions`);
+    }
+    /** Get a single rule version by its version number. */
+    getVersion(id, version) {
+        return this.req('GET', `/v1/config/rules/${encodeURIComponent(id)}/versions/${version}`);
+    }
+    /** Compute-on-read alert analytics for a rule: disposition breakdown + precision. */
+    analytics(id) {
+        return this.req('GET', `/v1/config/rules/${encodeURIComponent(id)}/analytics`);
+    }
     update(id, input) {
         return this.req('PATCH', `/v1/config/rules/${encodeURIComponent(id)}`, { body: input });
     }
@@ -768,6 +1324,75 @@ export class ConfigRulesResource {
             body: targetStatus ? { targetStatus } : undefined,
         });
     }
+    /**
+     * Roll the rule back to a previous version. Forward-only: re-applies the
+     * target version's definition through the validated update path and mints a
+     * new version. Returns 409 if the restored definition no longer resolves
+     * (e.g. a tombstoned reference), 403 for system rules.
+     */
+    rollback(id, toVersion, reason) {
+        return this.req('POST', `/v1/config/rules/${encodeURIComponent(id)}/rollback`, {
+            body: { toVersion, reason },
+        });
+    }
+}
+/**
+ * One workflow per alert type. Stages control assignment and review requirements;
+ * routers choose paths. Requires config:read / config:write.
+ */
+export class ConfigAlertWorkflowsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /** Organization-wide choice; defaults to SIMPLE until Defined workflows is selected. */
+    getExperience() { return this.req('GET', '/v1/config/alert-workflows/experience'); }
+    /** Requires config:write. Changes only the behavior of newly created alerts. */
+    saveExperience(input) { return this.req('PUT', '/v1/config/alert-workflows/experience', { body: input }); }
+    /** Requires config:read. Returns one workflow per alert type. */
+    list() { return this.req('GET', '/v1/config/alert-workflows'); }
+    /** Newest publication first. A null definition cannot be restored. Requires config:read. */
+    versions(alertType) { return this.req('GET', `/v1/config/alert-workflows/${alertType}/versions`); }
+    /** Replaces the draft with a saved version. Publishing is a separate operation; existing alerts are unchanged. */
+    restore(alertType, input) { return this.req('POST', `/v1/config/alert-workflows/${alertType}/restore`, { body: input }); }
+    get(alertType) { return this.req('GET', `/v1/config/alert-workflows/${alertType}`); }
+    /** Requires config:write. Use revision from get(); publish=false only updates the draft. */
+    save(alertType, input) { return this.req('PUT', `/v1/config/alert-workflows/${alertType}`, { body: input }); }
+}
+/** Read-only legacy policies. New alert assignment runs through alertWorkflows. */
+export class ConfigAssignmentPoliciesResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /** List policies in evaluation order. */
+    list() {
+        return this.req('GET', '/v1/config/assignment-policies');
+    }
+    /** Create a policy (appended at the end of the evaluation order). */
+    /** @deprecated Returns HTTP 410. Use config.alertWorkflows.save() to configure stage assignment. */
+    create(input) {
+        return this.req('POST', '/v1/config/assignment-policies', { body: input });
+    }
+    getBySyncKey(syncKey) {
+        return this.req('GET', `/v1/config/assignment-policies/by-sync-key/${encodeURIComponent(syncKey)}`);
+    }
+    get(id) {
+        return this.req('GET', `/v1/config/assignment-policies/${encodeURIComponent(id)}`);
+    }
+    /** @deprecated Returns HTTP 410. Use config.alertWorkflows.save() to configure stage assignment. */
+    update(id, input) {
+        return this.req('PUT', `/v1/config/assignment-policies/${encodeURIComponent(id)}`, { body: input });
+    }
+    /** Reorder: pass EVERY policy id in the desired order; priorities are reassigned 1..n. */
+    /** @deprecated Returns HTTP 410. Use config.alertWorkflows.save() to configure stage assignment. */
+    reorder(input) {
+        return this.req('PUT', '/v1/config/assignment-policies/order/reorder', { body: input });
+    }
+    /** @deprecated Returns HTTP 410. Use config.alertWorkflows.save() to configure stage assignment. */
+    delete(id) {
+        return this.req('DELETE', `/v1/config/assignment-policies/${encodeURIComponent(id)}`);
+    }
 }
 export class ConfigConstantsResource {
     req;
@@ -795,9 +1420,38 @@ export class ConfigConstantsResource {
         return this.req('DELETE', `/v1/config/constants/${encodeURIComponent(id)}`, { query });
     }
 }
+export class ConfigStatesResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list() {
+        return this.req('GET', '/v1/config/states');
+    }
+    create(input) {
+        return this.req('POST', '/v1/config/states', { body: input });
+    }
+}
+export class StatesResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    change(input) {
+        return this.req('POST', '/v1/states/change', { body: input });
+    }
+    get(resourceType, resourceId, name) {
+        return this.req('GET', `/v1/states/${resourceType}/${encodeURIComponent(resourceId)}/${encodeURIComponent(name)}`);
+    }
+    history(resourceType, resourceId, name, limit = 100) {
+        return this.req('GET', `/v1/states/${resourceType}/${encodeURIComponent(resourceId)}/${encodeURIComponent(name)}/history`, {
+            query: { limit },
+        });
+    }
+}
 /**
- * Tag catalogue — per-org, per-field tag vocabulary plus enforcement. Backs the
- * eight `TagValue[]` resource tag fields. Under `strict` enforcement, writes
+ * Tag catalogue — per-org, per-field tag vocabulary plus enforcement. Backs
+ * every `TagValue[]` resource tag field. Under `strict` enforcement, writes
  * carrying off-catalogue values are rejected (422).
  */
 export class ConfigTagCatalogueResource {
@@ -809,9 +1463,12 @@ export class ConfigTagCatalogueResource {
     list(query = {}) {
         return this.req('GET', '/v1/config/tag-catalogue', { query });
     }
-    /** Per field-key enforcement settings (every field-key, defaulting to `open`). */
-    enforcement() {
-        return this.req('GET', '/v1/config/tag-catalogue/enforcement');
+    /**
+     * The fixed colour palette. Served by the API so the token list isn't
+     * duplicated (and left to drift) in every client.
+     */
+    palette() {
+        return this.req('GET', '/v1/config/tag-catalogue/palette');
     }
     create(input) {
         return this.req('POST', '/v1/config/tag-catalogue', { body: input });
@@ -827,15 +1484,53 @@ export class ConfigTagCatalogueResource {
     delete(id) {
         return this.req('DELETE', `/v1/config/tag-catalogue/${encodeURIComponent(id)}`);
     }
-    /** Set enforcement (`open` | `strict`) for one field-key. */
-    setEnforcement(input) {
-        return this.req('PATCH', '/v1/config/tag-catalogue/enforcement', { body: input });
-    }
     /** Re-sync denormalised assignment labels from the catalogue. */
     backfill(fieldKey) {
         return this.req('POST', `/v1/config/tag-catalogue/backfill/${encodeURIComponent(fieldKey)}`);
     }
 }
+/**
+ * Tag groups — the facet layer over the catalogue. A group owns a namespace, so
+ * its member tags are stored as `<group>:<tag>` and a group is recoverable from
+ * a tag value by splitting on the first colon.
+ */
+export class ConfigTagGroupsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list(query = {}) {
+        return this.req('GET', '/v1/config/tag-groups', { query });
+    }
+    create(input) {
+        return this.req('POST', '/v1/config/tag-groups', { body: input });
+    }
+    update(id, input) {
+        return this.req('PATCH', `/v1/config/tag-groups/${encodeURIComponent(id)}`, { body: input });
+    }
+    /** Archive a group. Its tags keep their namespaced values. */
+    archive(id) {
+        return this.req('POST', `/v1/config/tag-groups/${encodeURIComponent(id)}/archive`);
+    }
+    /** Hard-delete. Rejected while the group still owns tags — archive instead. */
+    delete(id) {
+        return this.req('DELETE', `/v1/config/tag-groups/${encodeURIComponent(id)}`);
+    }
+    /** Records holding more than one tag from this group — the SINGLE pre-flight. */
+    cardinalityConflicts(id) {
+        return this.req('GET', `/v1/config/tag-groups/${encodeURIComponent(id)}/cardinality-conflicts`);
+    }
+    /**
+     * Move tags into (or out of, with `groupId: null`) a group.
+     *
+     * This changes each tag's stored VALUE, so it also rewrites assignments,
+     * rule condition operands, and assignment-policy routing tables. Run it
+     * with `dryRun: true` first — the report is identical, nothing is written.
+     */
+    regroup(input) {
+        return this.req('POST', '/v1/config/tag-groups/regroup', { body: input });
+    }
+}
 export class ConfigProductsResource {
     req;
     constructor(req) {
@@ -896,6 +1591,54 @@ export class ConfigCurrenciesResource {
     bulkUpdateStatus(input) {
         return this.req('PATCH', '/v1/config/currencies/bulk-status', { body: input });
     }
+    /** Archive a currency (LIVE → ARCHIVED). Also disables it. */
+    archive(id) {
+        return this.req('POST', `/v1/config/currencies/${encodeURIComponent(id)}/archive`);
+    }
+    /** Tombstone a currency (terminal). Archive-first required — 409 if LIVE. */
+    delete(id) {
+        return this.req('DELETE', `/v1/config/currencies/${encodeURIComponent(id)}`);
+    }
+}
+/**
+ * Org-defined alert types for custom alerts — `/v1/config/custom-alert-types`.
+ * Requires `config:read` / `config:write`. Follows the canonical lifecycle:
+ * archive (blocked while alerts of the type are OPEN) → tombstone.
+ */
+export class ConfigCustomAlertTypesResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    list(query = {}) {
+        return this.req('GET', '/v1/config/custom-alert-types', { query });
+    }
+    create(input) {
+        return this.req('POST', '/v1/config/custom-alert-types', { body: input });
+    }
+    /** Returns `{ found: false }` when no type has that name. */
+    getByName(name) {
+        return this.req('GET', `/v1/config/custom-alert-types/by-name/${encodeURIComponent(name)}`);
+    }
+    get(id) {
+        return this.req('GET', `/v1/config/custom-alert-types/${encodeURIComponent(id)}`);
+    }
+    /** Schema edits apply to alerts raised afterwards; existing alerts are not re-validated. */
+    update(id, input) {
+        return this.req('PATCH', `/v1/config/custom-alert-types/${encodeURIComponent(id)}`, { body: input });
+    }
+    /** Tombstones the type. Archive-first enforced. */
+    delete(id) {
+        return this.req('DELETE', `/v1/config/custom-alert-types/${encodeURIComponent(id)}`);
+    }
+    /** LIVE → ARCHIVED. 409 while any alert of this type is OPEN. */
+    archive(id) {
+        return this.req('POST', `/v1/config/custom-alert-types/${encodeURIComponent(id)}/archive`);
+    }
+    /** ARCHIVED → LIVE. */
+    unarchive(id) {
+        return this.req('POST', `/v1/config/custom-alert-types/${encodeURIComponent(id)}/unarchive`);
+    }
 }
 export class ConfigEventDefinitionsResource {
     req;
@@ -1011,4 +1754,105 @@ export class SettingsResource {
         return this.req('GET', `/v1/settings/sync-snapshots/${encodeURIComponent(id)}/download`);
     }
 }
+/**
+ * Custom screening lists — tenant-managed lists (internal blocklists, exited
+ * customers, local regulator lists) checked by every screening run alongside
+ * external providers. Requires `config:read` / `config:write` API-key scope.
+ */
+export class CustomListsResource {
+    req;
+    constructor(req) {
+        this.req = req;
+    }
+    /** `GET /v1/screening/custom-lists` — lists, LIVE only by default. */
+    list(params = {}) {
+        return this.req('GET', '/v1/screening/custom-lists', { query: params });
+    }
+    /** `POST /v1/screening/custom-lists` — create a list. */
+    create(input) {
+        return this.req('POST', '/v1/screening/custom-lists', { body: input });
+    }
+    /** `GET /v1/screening/custom-lists/{listId}`. */
+    get(listId) {
+        return this.req('GET', `/v1/screening/custom-lists/${encodeURIComponent(listId)}`);
+    }
+    /** `PATCH /v1/screening/custom-lists/{listId}` — name / description / enabled / tags. */
+    update(listId, input) {
+        return this.req('PATCH', `/v1/screening/custom-lists/${encodeURIComponent(listId)}`, { body: input });
+    }
+    /**
+     * `POST /v1/screening/custom-lists/{listId}/archive` — archived lists are
+     * read-only and excluded from screening.
+     */
+    archive(listId) {
+        return this.req('POST', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/archive`);
+    }
+    /** `POST /v1/screening/custom-lists/{listId}/unarchive`. */
+    unarchive(listId) {
+        return this.req('POST', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/unarchive`);
+    }
+    /** `GET /v1/screening/custom-lists/{listId}/entries`. */
+    listEntries(listId, params = {}) {
+        return this.req('GET', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/entries`, {
+            query: params,
+        });
+    }
+    /** `POST /v1/screening/custom-lists/{listId}/entries` — add a single entry. */
+    createEntry(listId, input) {
+        return this.req('POST', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/entries`, {
+            body: input,
+        });
+    }
+    /**
+     * `POST /v1/screening/custom-lists/{listId}/entries/bulk` — import up to
+     * 500 rows per request. Invalid rows are rejected per-row (with reasons)
+     * while valid rows proceed; rows carrying `externalRef` upsert instead of
+     * duplicating, so re-importing a refreshed CSV is safe.
+     */
+    bulkCreateEntries(listId, rows) {
+        return this.req('POST', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/entries/bulk`, {
+            body: { rows },
+        });
+    }
+    /** `PATCH /v1/screening/custom-lists/{listId}/entries/{entryId}`. */
+    updateEntry(listId, entryId, input) {
+        return this.req('PATCH', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/entries/${encodeURIComponent(entryId)}`, { body: input });
+    }
+    /** `DELETE /v1/screening/custom-lists/{listId}/entries/{entryId}`. */
+    deleteEntry(listId, entryId) {
+        return this.req('DELETE', `/v1/screening/custom-lists/${encodeURIComponent(listId)}/entries/${encodeURIComponent(entryId)}`);
+    }
+}
+/**
+ * On-demand PDF reports (`/v1/reports/...`). Each method resolves to the raw
+ * PDF bytes; write them to disk or hand them to a download response. Requires
+ * the `report:read` grant. Generating a report records a `report.generated`
+ * activity on the subject record.
+ */
+export class ReportsResource {
+    getBinary;
+    constructor(getBinary) {
+        this.getBinary = getBinary;
+    }
+    /** Alert case file: facts, subject customer, matches / rule triggers, comments, activity. */
+    alert(alertId) {
+        return this.getBinary(`/v1/reports/alerts/${encodeURIComponent(alertId)}/pdf`);
+    }
+    /** Customer profile: identity, documents, accounts, risk, screening, totals, alerts. */
+    customerProfile(customerId) {
+        return this.getBinary(`/v1/reports/customers/${encodeURIComponent(customerId)}/pdf`);
+    }
+    /** Counterparty profile: classification, identifiers, payment methods, totals. */
+    counterpartyProfile(counterpartyId) {
+        return this.getBinary(`/v1/reports/counterparties/${encodeURIComponent(counterpartyId)}/pdf`);
+    }
+    /**
+     * Generic profile for any other registered resource type (`ACCOUNT`,
+     * `DEVICE`, `INSTITUTION`, `PRODUCT`, `TASK`, …). `ALERT`, `CUSTOMER` and
+     * `COUNTERPARTY` are rejected with 400 — use the dedicated methods.
+     */
+    resourceProfile(resourceType, resourceId) {
+        return this.getBinary(`/v1/reports/resources/${encodeURIComponent(resourceType)}/${encodeURIComponent(resourceId)}/pdf`);
+    }
+}
 //# sourceMappingURL=service.js.map