@dossier-wiki/os-sdk 0.1.1 → 1.3.0

package/dist/service.d.ts

@@ -1,4 +1,5 @@
-import type { AccountResponseDto, AddFaceImageDto, ApiKeyResponseDto, ArchiveIdentificationDocumentInput, BulkCurrencyStatusInput, BulkUpsertOtherInformationInput, CustomerOtherInformationEntry, BulkCurrencyStatusResponseDto, CommentResourceType, ConfirmUploadDto, ConfirmedMatchDto, ConstantResponseDto, CounterpartyResponseDto, CreateAccountDto, CreateApiKeyDto, CreateConstantDto, CreateCounterpartyDto, CreateCurrencyInput, CreateEntityDto, CreateEventDefinitionDto, CreateIdentificationDocumentInput, CreateIndividualDto, CreateNoteDto, CreateProductDto, CreateRiskAssessmentDto, CreateRiskQuestionnaireDto, CreateRuleDto, CreateStakeholderDto, CreateWebhookDto, CurrencyResponseDto, CursorPaginationQuery, DeleteConstantQuery, DeleteIdentificationDocumentResponse, DeviceResponseDto, DeviceSummaryDto, EntityResponseDto, EventDefinitionResponseDto, ExpectedActivityResponseDto, FileResponseDto, GetCustomerQuery, IdentificationDocument, IndividualResponseDto, IngestEventDto, IngestEventResponse, IngestTransactionAsyncResponse, IngestTransactionDto, IngestTransactionResponse, InitializeSetupDto, InvitationDetailsDto, LinkCounterpartyDto, ListAccountsResponse, ListCounterpartiesResponse, ListCurrenciesQuery, ListEntitiesResponse, ListIdentificationDocumentsQuery, ListIndividualsResponse, NoteResponseDto, PatchTransactionStatusDto, PlatformComment, PlatformConfirmUploadDto, PlatformConfirmUploadResponseDto, PlatformCreateCommentDto, PlatformRequestUploadUrlDto, PlatformUpdateCommentDto, PlatformUploadUrlResponseDto, ProductResponseDto, PushExchangeRatesDto, PushExchangeRatesResponseDto, RegisterDeviceDto, RequestUploadUrlDto, ResetConfigResponseDto, ResetMemberPasswordDto, RiskAssessmentResponseDto, RiskQuestionnaireResponseDto, RuleResponseDto, ScreeningResultDto, SetupInitializeResponseDto, SetupStatusDto, StakeholderResponseDto, SyncExportDto, SyncSnapshotDto, SyncDriftDto, CreateSyncSnapshotInput, SyncKeyQuery, TokenResponseDto, TransitionIdentificationDocumentStatusInput, UploadUrlResponseDto, UpdateAccountDto, UpdateConstantDto, UpdateCounterpartyDto, UpdateCurrencyInput, UpdateDeviceTrustDto, UpdateEntityDto, UpdateEventDefinitionDto, UpdateExpectedActivityDto, UpdateFaceImageDto, UpdateIdentificationDocumentDto, UpdateIdentificationDocumentInput, UpdateIndividualDto, UpdateNoteDto, UpsertOtherInformationValueInput, UpdateProductDto, UpdateRiskRatingDto, UpdateRuleDto, UpdateStakeholderDto, UpdateWebhookDto, WebhookResponseDto } from './types';
+import type { AlertWorkflowVersion, RestoreAlertWorkflowInput, AlertWorkflowExperienceSettings, SaveAlertWorkflowExperienceInput, AlertWorkflowSettings, SaveAlertWorkflowInput, WorkflowAlertType } from "./types.js";
+import type { AccountResponseDto, AddFaceImageDto, AlertResourceDto, AlertResourceRefDto, AlertResponseDto, CreateCustomAlertDto, CreateCustomAlertTypeDto, CustomAlertTypeResponseDto, UpdateAlertNotesDto, UpdateCustomAlertTypeDto, TagFieldKey, TagCatalogueEntry, TagGroup, TagGroupInput, UpdateTagGroupInput, RegroupReport, TagCatalogueEntryInput, UpdateTagCatalogueEntryInput, ApiKeyResponseDto, ArchiveIdentificationDocumentInput, BulkCurrencyStatusInput, BulkUpsertOtherInformationInput, CustomerOtherInformationEntry, BulkCurrencyStatusResponseDto, CommentResourceType, ConfirmUploadDto, ConfirmedMatchDto, ConstantResponseDto, ChangeResourceStateInput, CreateStateDefinitionInput, CounterpartyResponseDto, CreateAccountDto, CreateApiKeyDto, CreateConstantDto, CreateCounterpartyDto, CreateCurrencyInput, CreateEntityInput, CreateEventDefinitionDto, CreateIdentificationDocumentInput, CreateIndividualInput, CreateNoteDto, CreateProductDto, CreateRiskAssessmentDto, CreateCustomerRiskAssessmentDto, CreateRuleDto, CreateStakeholderDto, CreateWebhookDto, CurrencyResponseDto, CursorPaginationQuery, DeleteConstantQuery, DeleteIdentificationDocumentResponse, DeviceResponseDto, DeviceMergeResponseDto, MergeDeviceDto, DeviceSummaryDto, EntityResponseDto, EntityCreatedResponseDto, CreateCustomerOptions, EventDefinitionResponseDto, ExpectedActivityResponseDto, FileResponseDto, GetCustomerQuery, IdentificationDocument, IndividualResponseDto, IndividualCreatedResponseDto, IngestEventDto, IngestEventResponse, IngestTransactionAsyncResponse, IngestTransactionAttemptDto, IngestTransactionAttemptResponse, ListTransactionAttemptsInput, TransactionAttemptDto, TransactionAttemptPage, AlertAttemptEvidence, TenantBehaviorSettings, UpdateTenantBehaviorSettingsInput, IngestTransactionDto, IngestTransactionResponse, InitializeSetupDto, InvitationDetailsDto, LinkCounterpartyDto, ListAccountsResponse, ListCounterpartiesResponse, ListCurrenciesQuery, ListEntitiesResponse, ListIdentificationDocumentsQuery, ListIndividualsResponse, NoteResponseDto, PatchTransactionStatusDto, TransactionResponseDto, PaymentInstrumentDto, CreatePaymentInstrumentDto, UpdatePaymentInstrumentDto, LinkPaymentInstrumentAccountDto, LinkPaymentInstrumentCustomerDto, PaymentInstrumentAccountRelationshipDto, PaymentInstrumentCustomerRelationshipDto, PlatformComment, PlatformConfirmUploadDto, PlatformConfirmUploadResponseDto, PlatformCreateCommentDto, PlatformRequestUploadUrlDto, PlatformUpdateCommentDto, PlatformUploadUrlResponseDto, ProductResponseDto, PushExchangeRatesDto, PushExchangeRatesResponseDto, RegisterDeviceDto, RequestUploadUrlDto, ResetConfigResponseDto, ResetMemberPasswordDto, RiskAssessmentResponseDto, CustomerRiskAssessmentResponseDto, RuleResponseDto, RuleVersionResponseDto, RuleAnalyticsResponseDto, ScreeningResultDto, ScreeningHistoryEntryDto, StartKycSessionResponseDto, KycSessionDto, ScreeningMatchResultDto, SimulateRulesDto, SimulationReportDto, SetupInitializeResponseDto, SetupStatusDto, StakeholderResponseDto, SyncSnapshotDto, SyncDriftDto, CreateSyncSnapshotInput, SyncKeyQuery, ListConstantsQuery, ResourceStateDto, ResourceStateHistoryDto, StateDefinitionDto, StateResourceType, SyncConfig, SyncValidationResult, SyncPlanResult, SyncApplyResult, SyncExportQuery, TokenResponseDto, TransitionIdentificationDocumentStatusInput, UploadUrlResponseDto, UpdateAccountDto, UpdateConstantDto, UpdateCounterpartyDto, UpdateCurrencyInput, UpdateDeviceTrustDto, UpdateEntityDto, UpdateEventDefinitionDto, UpdateExpectedActivityDto, UpdateFaceImageDto, UpdateIdentificationDocumentDto, UpdateIdentificationDocumentInput, UpdateIndividualDto, UpdateNoteDto, UpsertOtherInformationValueInput, UpdateProductDto, UpdateRiskRatingDto, UpdateCustomerStatusDto, UpdateCustomerStatusResponse, ArchiveCustomerDto, ArchiveCustomerResponse, UpdateRuleDto, UpdateStakeholderDto, UpdateWebhookDto, WebhookResponseDto, BulkCustomListImportResultDto, CreateCustomScreeningListInput, CustomListEntryDto, CustomListEntryInput, CustomListEntryListResponse, CustomScreeningListDto, CustomScreeningListListResponse, UpdateCustomListEntryInput, UpdateCustomScreeningListInput, AssignmentPolicyResponseDto, CreateAssignmentPolicyDto, UpdateAssignmentPolicyDto, ReorderAssignmentPoliciesDto, TeamRefDto, TeamDto, CreateTeamDto, UpdateTeamDto, TeamMemberIdsDto, CustomerAssignmentInput, BulkCustomerAssignmentInput, CustomerAssignmentResponse, BulkCustomerAssignmentResult, SessionDto, UpdateSessionDto, ChannelEndpointDto, UpdateChannelEndpointDto, Branch, BranchListResponse, CreateBranchInput, UpdateBranchInput, Employee, EmployeeListResponse, CreateEmployeeInput, UpdateEmployeeInput, CreateRiskSignalInput, ListRiskSignalsQuery, RiskSignal, RiskSignalListResponse, PartyRelationship, PartyRelationshipPartyType, PartyRelationshipType, CreatePartyRelationshipInput, CreatePartyRelationshipTypeInput } from './types.js';
 export interface DossiersOSAPIServiceOptions {
     /** Base URL of the OS API host, e.g. `https://sandbox-os.dossiers.wiki`. The `/v1` prefix is added by the SDK. */
     baseUrl: string;
@@ -17,6 +18,7 @@ type RequestOptions = {
     query?: Record<string, unknown> | object;
 };
 type RequestFn = <T>(method: HttpMethod, path: string, opts?: RequestOptions) => Promise<T>;
+type BinaryRequestFn = (path: string) => Promise<Uint8Array>;
 export declare class DossiersOSAPIService {
     private readonly apiKey;
     private readonly baseUrl;
@@ -28,17 +30,41 @@ export declare class DossiersOSAPIService {
     readonly accounts: AccountsResource;
     readonly counterparties: CounterpartiesResource;
     readonly devices: DevicesResource;
+    readonly paymentInstruments: PaymentInstrumentsResource;
+    readonly sessions: SessionsResource;
+    readonly channelEndpoints: ChannelEndpointsResource;
     readonly transactions: TransactionsResource;
+    readonly transactionAttempts: TransactionAttemptsResource;
+    readonly behaviorSettings: BehaviorSettingsResource;
     readonly events: EventsResource;
+    readonly riskSignals: RiskSignalsResource;
+    readonly employees: EmployeesResource;
+    readonly branches: BranchesResource;
     readonly exchangeRates: ExchangeRatesResource;
+    readonly states: StatesResource;
     readonly identificationDocuments: IdentificationDocumentsResource;
     readonly alerts: AlertsResource;
     readonly platform: PlatformResource;
     readonly config: ConfigResource;
     readonly setup: SetupResource;
     readonly settings: SettingsResource;
+    readonly customLists: CustomListsResource;
+    readonly teams: TeamsResource;
+    readonly reports: ReportsResource;
+    readonly partyRelationships: PartyRelationshipsResource;
     constructor(options: DossiersOSAPIServiceOptions);
     private request;
+    /** GET a binary body (PDF reports). Errors are parsed the same way as JSON requests. */
+    private requestBinary;
+}
+export declare class PartyRelationshipsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    listTypes(): Promise<PartyRelationshipType[]>;
+    createType(input: CreatePartyRelationshipTypeInput): Promise<PartyRelationshipType>;
+    list(partyType: PartyRelationshipPartyType, partyId: string): Promise<PartyRelationship[]>;
+    create(input: CreatePartyRelationshipInput): Promise<PartyRelationship>;
+    end(id: string): Promise<PartyRelationship>;
 }
 /**
  * Scoped view of `/v1/platform/v1/comments` for a single resourceType.
@@ -89,7 +115,12 @@ export declare class IndividualsResource {
     readonly otherInformation: CustomerOtherInformationResource;
     constructor(req: RequestFn);
     list(query?: CursorPaginationQuery): Promise<ListIndividualsResponse>;
-    create(input: CreateIndividualDto): Promise<IndividualResponseDto>;
+    /**
+     * `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: CreateIndividualInput, options?: CreateCustomerOptions): Promise<IndividualCreatedResponseDto>;
     get(customerId: string, query?: GetCustomerQuery): Promise<IndividualResponseDto>;
     update(customerId: string, input: UpdateIndividualDto): Promise<IndividualResponseDto>;
 }
@@ -118,7 +149,12 @@ export declare class EntitiesResource {
     readonly otherInformation: CustomerOtherInformationResource;
     constructor(req: RequestFn);
     list(query?: CursorPaginationQuery): Promise<ListEntitiesResponse>;
-    create(input: CreateEntityDto): Promise<EntityResponseDto>;
+    /**
+     * `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: CreateEntityInput, options?: CreateCustomerOptions): Promise<EntityCreatedResponseDto>;
     get(customerId: string, query?: GetCustomerQuery): Promise<EntityResponseDto>;
     update(customerId: string, input: UpdateEntityDto): Promise<EntityResponseDto>;
 }
@@ -137,14 +173,62 @@ export declare class EntityIdentificationDocumentsResource {
     create(customerId: string, input: CreateIdentificationDocumentInput): Promise<IdentificationDocument>;
 }
 export declare class CustomersResource {
+    private readonly req;
     readonly notes: CustomerNotesResource;
     readonly files: CustomerFilesResource;
     readonly screening: CustomerScreeningResource;
+    readonly kyc: CustomerKycResource;
     readonly riskRating: CustomerRiskRatingResource;
-    readonly riskQuestionnaires: CustomerRiskQuestionnairesResource;
+    readonly status: CustomerStatusResource;
+    readonly riskAssessments: CustomerRiskAssessmentsResource;
     readonly expectedActivity: CustomerExpectedActivityResource;
     readonly devices: CustomerDevicesResource;
+    readonly assignment: CustomerAssignmentResource;
     constructor(req: RequestFn);
+    /**
+     * `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: string, input?: ArchiveCustomerDto): Promise<ArchiveCustomerResponse>;
+}
+export declare class CustomerAssignmentResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * `POST /v1/customers/{customerId}/assignment` — add users/teams to a
+     * customer's standing assignment (additive; never silently removes).
+     */
+    assign(customerId: string, input: CustomerAssignmentInput): Promise<CustomerAssignmentResponse>;
+    /**
+     * `DELETE /v1/customers/{customerId}/assignment` — remove users/teams from
+     * a customer's standing assignment.
+     */
+    unassign(customerId: string, input: CustomerAssignmentInput): Promise<CustomerAssignmentResponse>;
+    /**
+     * `POST /v1/customers/assignment` — assign many customers to the same
+     * users/teams. Customers that already carry the target are skipped.
+     */
+    assignMany(input: BulkCustomerAssignmentInput): Promise<BulkCustomerAssignmentResult>;
+}
+export declare class TeamsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * Active teams. `tags` is an any-of filter over the team's `team.tags`
+     * catalogue values (repeated as `?tags=a&tags=b`).
+     */
+    list(query?: {
+        search?: string;
+        tags?: string[];
+    }): Promise<TeamRefDto[]>;
+    get(id: string): Promise<TeamDto>;
+    create(input: CreateTeamDto): Promise<TeamDto>;
+    update(id: string, input: UpdateTeamDto): Promise<TeamDto>;
+    archive(id: string): Promise<TeamDto>;
+    delete(id: string): Promise<boolean>;
+    addMembers(id: string, input: TeamMemberIdsDto): Promise<TeamDto>;
+    removeMembers(id: string, input: TeamMemberIdsDto): Promise<TeamDto>;
 }
 export declare class CustomerNotesResource {
     private readonly req;
@@ -167,18 +251,88 @@ export declare class CustomerScreeningResource {
     private readonly req;
     constructor(req: RequestFn);
     trigger(customerId: string): Promise<ScreeningResultDto>;
+    /**
+     * `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: string, params?: {
+        limit?: number;
+    }): Promise<ScreeningHistoryEntryDto[]>;
+    /**
+     * `GET /v1/customers/{customerId}/screening-history/latest` — the most
+     * recent screening run, or `null` if the customer has never been screened.
+     */
+    getLast(customerId: string): Promise<ScreeningHistoryEntryDto | 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: string, params?: {
+        disposition?: Array<'PENDING' | 'CONFIRMED' | 'FALSE_POSITIVE'>;
+    }): Promise<ScreeningMatchResultDto[]>;
+    /**
+     * `GET /v1/customers/{customerId}/confirmed-matches` — confirmed
+     * (true-positive) matches only. Alias for `listResults` filtered to
+     * `CONFIRMED`, kept for backwards compatibility.
+     */
     listConfirmedMatches(customerId: string): Promise<ConfirmedMatchDto[]>;
 }
+/**
+ * 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 declare class CustomerKycResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * `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: string): Promise<StartKycSessionResponseDto>;
+    /**
+     * `GET /v1/customers/{customerId}/kyc/sessions` — list a customer's KYC
+     * sessions, newest first.
+     */
+    list(customerId: string): Promise<KycSessionDto[]>;
+    /**
+     * `POST /v1/customers/{customerId}/kyc/sessions/{sessionId}/refresh` — pull
+     * the latest provider state for a session and persist it.
+     */
+    refresh(customerId: string, sessionId: string): Promise<KycSessionDto>;
+    /**
+     * `DELETE /v1/customers/{customerId}/kyc/sessions/{sessionId}` — cancel the
+     * session at the provider and remove the local record.
+     */
+    delete(customerId: string, sessionId: string): Promise<{
+        deletedId: string;
+    }>;
+}
 export declare class CustomerRiskRatingResource {
     private readonly req;
     constructor(req: RequestFn);
     update(customerId: string, input: UpdateRiskRatingDto): Promise<IndividualResponseDto | EntityResponseDto>;
 }
-export declare class CustomerRiskQuestionnairesResource {
+export declare class CustomerStatusResource {
     private readonly req;
     constructor(req: RequestFn);
-    list(customerId: string): Promise<RiskQuestionnaireResponseDto[]>;
-    create(customerId: string, input: CreateRiskQuestionnaireDto): Promise<RiskQuestionnaireResponseDto>;
+    /**
+     * `PUT /v1/customers/{customerId}/status` — transition a customer's lifecycle
+     * status. Emits a `customer.status_changed` webhook.
+     */
+    update(customerId: string, input: UpdateCustomerStatusDto): Promise<UpdateCustomerStatusResponse>;
+}
+export declare class CustomerRiskAssessmentsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(customerId: string): Promise<CustomerRiskAssessmentResponseDto[]>;
+    create(customerId: string, input: CreateCustomerRiskAssessmentDto): Promise<CustomerRiskAssessmentResponseDto>;
 }
 export declare class CustomerExpectedActivityResource {
     private readonly req;
@@ -233,6 +387,34 @@ export declare class DevicesResource {
     readonly comments: ResourceCommentsProxy;
     constructor(req: RequestFn);
     get(deviceId: string): Promise<DeviceResponseDto>;
+    /** Canonicalize the source device into the target without deleting history. */
+    merge(targetDeviceId: string, input: MergeDeviceDto): Promise<DeviceMergeResponseDto>;
+}
+export declare class PaymentInstrumentsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(): Promise<PaymentInstrumentDto[]>;
+    get(id: string): Promise<PaymentInstrumentDto>;
+    create(input: CreatePaymentInstrumentDto): Promise<PaymentInstrumentDto>;
+    update(id: string, input: UpdatePaymentInstrumentDto): Promise<PaymentInstrumentDto>;
+    linkAccount(id: string, input: LinkPaymentInstrumentAccountDto): Promise<PaymentInstrumentAccountRelationshipDto>;
+    unlinkAccount(id: string, relationshipId: string, validTo?: string): Promise<PaymentInstrumentAccountRelationshipDto>;
+    linkCustomer(id: string, input: LinkPaymentInstrumentCustomerDto): Promise<PaymentInstrumentCustomerRelationshipDto>;
+    unlinkCustomer(id: string, relationshipId: string, validTo?: string): Promise<PaymentInstrumentCustomerRelationshipDto>;
+}
+export declare class SessionsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(): Promise<SessionDto[]>;
+    get(id: string): Promise<SessionDto>;
+    update(id: string, input: UpdateSessionDto): Promise<SessionDto>;
+}
+export declare class ChannelEndpointsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(): Promise<ChannelEndpointDto[]>;
+    get(id: string): Promise<ChannelEndpointDto>;
+    update(id: string, input: UpdateChannelEndpointDto): Promise<ChannelEndpointDto>;
 }
 export declare class TransactionsResource {
     private readonly req;
@@ -242,22 +424,174 @@ export declare class TransactionsResource {
     ingest(input: IngestTransactionDto): Promise<IngestTransactionResponse | IngestTransactionAsyncResponse>;
     /** `PATCH /v1/transactions` — patch a transaction's terminal status. */
     patchStatus(input: PatchTransactionStatusDto): Promise<unknown>;
+    /**
+     * 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: string, opts?: {
+        by?: 'transactionId' | 'id';
+    }): Promise<TransactionResponseDto>;
+}
+export declare class TransactionAttemptsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * `POST /v1/transaction-attempts` — retain a failed, blocked, or unknown
+     * operation as behavioural history. This does not trigger rule evaluation.
+     */
+    ingest(input: IngestTransactionAttemptDto): Promise<IngestTransactionAttemptResponse>;
+    /** List retained attempts using an opaque, stable cursor. Requires `config:read`. */
+    list(input?: ListTransactionAttemptsInput): Promise<TransactionAttemptPage>;
+    /** Read one retained attempt by its database id. Requires `config:read`. */
+    get(id: string): Promise<TransactionAttemptDto>;
+}
+export declare class BehaviorSettingsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    get(): Promise<TenantBehaviorSettings>;
+    update(input: UpdateTenantBehaviorSettingsInput): Promise<TenantBehaviorSettings>;
 }
 export declare class EventsResource {
     private readonly req;
     constructor(req: RequestFn);
+    /**
+     * `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: IngestEventDto): Promise<IngestEventResponse>;
 }
+/**
+ * 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 declare class RiskSignalsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * `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: CreateRiskSignalInput): Promise<RiskSignal>;
+    /**
+     * `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: ListRiskSignalsQuery): Promise<RiskSignalListResponse>;
+}
+/**
+ * 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 declare class EmployeesResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * `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?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<EmployeeListResponse>;
+    get(id: string): Promise<Employee>;
+    /**
+     * `POST /v1/employees`. `externalEmployeeId` must be unique within the
+     * organization; a duplicate is rejected with 400.
+     */
+    create(input: CreateEmployeeInput): Promise<Employee>;
+    update(id: string, input: UpdateEmployeeInput): Promise<Employee>;
+}
+/**
+ * Branches — the institution's own physical or organizational units, through
+ * which Employees act. Like Employee, an attachable resource for Events and
+ * Risk Signals.
+ */
+export declare class BranchesResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /**
+     * `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?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<BranchListResponse>;
+    get(id: string): Promise<Branch>;
+    /**
+     * `POST /v1/branches`. `externalBranchId` must be unique within the
+     * organization.
+     */
+    create(input: CreateBranchInput): Promise<Branch>;
+    update(id: string, input: UpdateBranchInput): Promise<Branch>;
+}
 export declare class ExchangeRatesResource {
     private readonly req;
     constructor(req: RequestFn);
     push(input: PushExchangeRatesDto): Promise<PushExchangeRatesResponseDto>;
 }
+/**
+ * First-class identification-documents resource — independent of the customer
+ * collection a document belongs to. For customer-scoped list/create, see
+ * `customers.identificationDocuments` or the proxies on `individuals` / `entities`.
+ */
 export declare class IdentificationDocumentsResource {
     private readonly req;
     readonly comments: ResourceCommentsProxy;
     constructor(req: RequestFn);
     get(id: string): Promise<IdentificationDocument>;
+    /**
+     * 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: string, input: UpdateIdentificationDocumentInput): Promise<IdentificationDocument>;
     /** Hard-delete an identification document. Returns `{ deletedId }`. */
     delete(id: string): Promise<DeleteIdentificationDocumentResponse>;
@@ -268,10 +602,49 @@ export declare class IdentificationDocumentsResource {
     /** Transition status — `rejectionNarrative` is required when `status=REJECTED`. */
     transition(id: string, input: TransitionIdentificationDocumentStatusInput): Promise<IdentificationDocument>;
 }
+/**
+ * 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 declare class AlertsResource {
+    private readonly req;
     readonly comments: ResourceCommentsProxy;
+    readonly resources: AlertResourcesProxy;
+    constructor(req: RequestFn);
+    /**
+     * 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: CreateCustomAlertDto): Promise<AlertResponseDto>;
+    /** Flat view of any alert, with its linked resources. */
+    get(alertId: string): Promise<AlertResponseDto>;
+    /** Replace the alert's markdown notes (any alert type). */
+    updateNotes(alertId: string, input: UpdateAlertNotesDto): Promise<AlertResponseDto>;
+    /** Immutable attempt facts captured when attempt-history rules contributed to an alert. */
+    attemptEvidence(alertId: string): Promise<AlertAttemptEvidence[]>;
+}
+/** Resources linked to an alert — `/v1/alerts/{id}/resources`. */
+export declare class AlertResourcesProxy {
+    private readonly req;
     constructor(req: RequestFn);
+    list(alertId: string): Promise<AlertResourceDto[]>;
+    /** Idempotent on (resourceType, resourceId): re-linking returns the existing link. */
+    add(alertId: string, input: AlertResourceRefDto): Promise<AlertResourceDto>;
+    /** `alertResourceId` is the link id from `list` / `add`, not the target's id. */
+    remove(alertId: string, alertResourceId: string): Promise<void>;
 }
+/**
+ * Cross-resource primitives (`/v1/platform/v1/*`). Polymorphic comments and
+ * file uploads keyed by `resourceType` + `resourceId`. Most callers should
+ * prefer the per-resource proxies (e.g. `sdk.individuals.comments`).
+ */
 export declare class PlatformResource {
     readonly comments: PlatformCommentsResource;
     readonly files: PlatformFilesResource;
@@ -306,21 +679,59 @@ export declare class ConfigResource {
     private readonly req;
     readonly rules: ConfigRulesResource;
     readonly constants: ConfigConstantsResource;
+    readonly alertWorkflows: ConfigAlertWorkflowsResource;
+    /** @deprecated Read-only archive. Use alertWorkflows for assignment. */
+    readonly states: ConfigStatesResource;
+    readonly assignmentPolicies: ConfigAssignmentPoliciesResource;
     readonly products: ConfigProductsResource;
     readonly currencies: ConfigCurrenciesResource;
     readonly eventDefinitions: ConfigEventDefinitionsResource;
+    readonly customAlertTypes: ConfigCustomAlertTypesResource;
     readonly webhooks: ConfigWebhooksResource;
+    readonly tagCatalogue: ConfigTagCatalogueResource;
+    readonly tagGroups: ConfigTagGroupsResource;
+    readonly sync: ConfigSyncResource;
     constructor(req: RequestFn);
     /** `DELETE /v1/config/reset` — clear all org config (destructive). */
     reset(): Promise<ResetConfigResponseDto>;
 }
+/**
+ * Tenant sync (config-as-code). The client loads + merges local config files
+ * into a `SyncConfig` and the server validates / diffs / applies it against the
+ * live tenant. Backs the `dossiers-sync` CLI.
+ */
+export declare class ConfigSyncResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /** Validate a config (schema + cross-references). No writes. */
+    validate(config: SyncConfig): Promise<SyncValidationResult>;
+    /** Diff a config against live state — advisory preview, no writes. */
+    plan(config: SyncConfig): Promise<SyncPlanResult>;
+    /** Validate, diff, and apply a config to the live tenant. */
+    apply(config: SyncConfig): Promise<SyncApplyResult>;
+    /** Serialize the live tenant config back into a `SyncConfig` (import / pull). */
+    export(query?: SyncExportQuery): Promise<SyncConfig>;
+}
 export declare class ConfigRulesResource {
     private readonly req;
     constructor(req: RequestFn);
     list(query?: SyncKeyQuery): Promise<RuleResponseDto[]>;
     create(input: CreateRuleDto): Promise<RuleResponseDto>;
     getBySyncKey(syncKey: string): Promise<RuleResponseDto>;
+    /**
+     * 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: SimulateRulesDto): Promise<SimulationReportDto>;
     get(id: string): Promise<RuleResponseDto>;
+    /** List a rule's definitional version history, newest first (audit trail). */
+    versions(id: string): Promise<RuleVersionResponseDto[]>;
+    /** Get a single rule version by its version number. */
+    getVersion(id: string, version: number): Promise<RuleVersionResponseDto>;
+    /** Compute-on-read alert analytics for a rule: disposition breakdown + precision. */
+    analytics(id: string): Promise<RuleAnalyticsResponseDto>;
     update(id: string, input: UpdateRuleDto): Promise<RuleResponseDto>;
     /**
      * Tombstones the rule. The rule must already be in ARCHIVED lifecycle;
@@ -332,17 +743,154 @@ export declare class ConfigRulesResource {
     archive(id: string): Promise<RuleResponseDto>;
     /** Unarchive (ARCHIVED → LIVE). Validates outbound references first. */
     unarchive(id: string, targetStatus?: string): Promise<RuleResponseDto>;
+    /**
+     * 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: string, toVersion: number, reason?: string): Promise<RuleResponseDto>;
+}
+/**
+ * One workflow per alert type. Stages control assignment and review requirements;
+ * routers choose paths. Requires config:read / config:write.
+ */
+export declare class ConfigAlertWorkflowsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /** Organization-wide choice; defaults to SIMPLE until Defined workflows is selected. */
+    getExperience(): Promise<AlertWorkflowExperienceSettings>;
+    /** Requires config:write. Changes only the behavior of newly created alerts. */
+    saveExperience(input: SaveAlertWorkflowExperienceInput): Promise<AlertWorkflowExperienceSettings>;
+    /** Requires config:read. Returns one workflow per alert type. */
+    list(): Promise<AlertWorkflowSettings[]>;
+    /** Newest publication first. A null definition cannot be restored. Requires config:read. */
+    versions(alertType: WorkflowAlertType): Promise<AlertWorkflowVersion[]>;
+    /** Replaces the draft with a saved version. Publishing is a separate operation; existing alerts are unchanged. */
+    restore(alertType: WorkflowAlertType, input: RestoreAlertWorkflowInput): Promise<AlertWorkflowSettings>;
+    get(alertType: WorkflowAlertType): Promise<AlertWorkflowSettings>;
+    /** Requires config:write. Use revision from get(); publish=false only updates the draft. */
+    save(alertType: WorkflowAlertType, input: SaveAlertWorkflowInput): Promise<AlertWorkflowSettings>;
+}
+/** Read-only legacy policies. New alert assignment runs through alertWorkflows. */
+export declare class ConfigAssignmentPoliciesResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /** List policies in evaluation order. */
+    list(): Promise<AssignmentPolicyResponseDto[]>;
+    /** 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: CreateAssignmentPolicyDto): Promise<AssignmentPolicyResponseDto>;
+    getBySyncKey(syncKey: string): Promise<AssignmentPolicyResponseDto | {
+        found: false;
+    }>;
+    get(id: string): Promise<AssignmentPolicyResponseDto>;
+    /** @deprecated Returns HTTP 410. Use config.alertWorkflows.save() to configure stage assignment. */
+    update(id: string, input: UpdateAssignmentPolicyDto): Promise<AssignmentPolicyResponseDto>;
+    /** 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: ReorderAssignmentPoliciesDto): Promise<AssignmentPolicyResponseDto[]>;
+    /** @deprecated Returns HTTP 410. Use config.alertWorkflows.save() to configure stage assignment. */
+    delete(id: string): Promise<void>;
 }
 export declare class ConfigConstantsResource {
     private readonly req;
     constructor(req: RequestFn);
-    list(query?: SyncKeyQuery): Promise<ConstantResponseDto[]>;
+    list(query?: ListConstantsQuery): Promise<ConstantResponseDto[]>;
     create(input: CreateConstantDto): Promise<ConstantResponseDto>;
     getBySyncKey(syncKey: string): Promise<ConstantResponseDto>;
     get(id: string): Promise<ConstantResponseDto>;
     update(id: string, input: UpdateConstantDto): Promise<ConstantResponseDto>;
     delete(id: string, query?: DeleteConstantQuery): Promise<void>;
 }
+export declare class ConfigStatesResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(): Promise<StateDefinitionDto[]>;
+    create(input: CreateStateDefinitionInput): Promise<StateDefinitionDto>;
+}
+export declare class StatesResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    change(input: ChangeResourceStateInput): Promise<ResourceStateDto>;
+    get(resourceType: StateResourceType, resourceId: string, name: string): Promise<ResourceStateDto | null>;
+    history(resourceType: StateResourceType, resourceId: string, name: string, limit?: number): Promise<ResourceStateHistoryDto[]>;
+}
+/**
+ * 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 declare class ConfigTagCatalogueResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /** List catalogue entries, optionally filtered by field-key. */
+    list(query?: {
+        fieldKey?: TagFieldKey;
+        includeArchived?: boolean;
+    }): Promise<TagCatalogueEntry[]>;
+    /**
+     * The fixed colour palette. Served by the API so the token list isn't
+     * duplicated (and left to drift) in every client.
+     */
+    palette(): Promise<{
+        tokens: string[];
+    }>;
+    create(input: TagCatalogueEntryInput): Promise<TagCatalogueEntry>;
+    update(id: string, input: UpdateTagCatalogueEntryInput): Promise<TagCatalogueEntry>;
+    /** Archive an entry (hidden from pickers but kept for unarchive/history). */
+    archive(id: string): Promise<TagCatalogueEntry>;
+    /** Hard-delete an entry. Existing assignments keep their snapshot label/value. */
+    delete(id: string): Promise<void>;
+    /** Re-sync denormalised assignment labels from the catalogue. */
+    backfill(fieldKey: TagFieldKey): Promise<{
+        rewritten: number;
+    }>;
+}
+/**
+ * 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 declare class ConfigTagGroupsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(query?: {
+        fieldKey?: TagFieldKey;
+        includeArchived?: boolean;
+    }): Promise<TagGroup[]>;
+    create(input: TagGroupInput): Promise<TagGroup>;
+    update(id: string, input: UpdateTagGroupInput): Promise<TagGroup>;
+    /** Archive a group. Its tags keep their namespaced values. */
+    archive(id: string): Promise<TagGroup>;
+    /** Hard-delete. Rejected while the group still owns tags — archive instead. */
+    delete(id: string): Promise<void>;
+    /** Records holding more than one tag from this group — the SINGLE pre-flight. */
+    cardinalityConflicts(id: string): Promise<{
+        total: number;
+        sample: {
+            resourceId: string;
+            count: number;
+        }[];
+    }>;
+    /**
+     * 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: {
+        entryIds: string[];
+        groupId?: string | null;
+        dryRun?: boolean;
+    }): Promise<RegroupReport>;
+}
+/**
+ * Lifecycle-result shape returned by archive/unarchive endpoints across
+ * adopters. Subset of the resource row sufficient for UI feedback after a
+ * transition.
+ */
 export interface LifecycleResult {
     id: string;
     lifecycle: 'LIVE' | 'ARCHIVED' | 'TOMBSTONED';
@@ -378,6 +926,36 @@ export declare class ConfigCurrenciesResource {
     get(id: string): Promise<CurrencyResponseDto>;
     update(id: string, input: UpdateCurrencyInput): Promise<CurrencyResponseDto>;
     bulkUpdateStatus(input: BulkCurrencyStatusInput): Promise<BulkCurrencyStatusResponseDto>;
+    /** Archive a currency (LIVE → ARCHIVED). Also disables it. */
+    archive(id: string): Promise<CurrencyResponseDto>;
+    /** Tombstone a currency (terminal). Archive-first required — 409 if LIVE. */
+    delete(id: string): Promise<CurrencyResponseDto>;
+}
+/**
+ * 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 declare class ConfigCustomAlertTypesResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    list(query?: {
+        lifecycle?: 'LIVE' | 'ARCHIVED' | 'TOMBSTONED' | 'ALL';
+    }): Promise<CustomAlertTypeResponseDto[]>;
+    create(input: CreateCustomAlertTypeDto): Promise<CustomAlertTypeResponseDto>;
+    /** Returns `{ found: false }` when no type has that name. */
+    getByName(name: string): Promise<CustomAlertTypeResponseDto | {
+        found: false;
+    }>;
+    get(id: string): Promise<CustomAlertTypeResponseDto>;
+    /** Schema edits apply to alerts raised afterwards; existing alerts are not re-validated. */
+    update(id: string, input: UpdateCustomAlertTypeDto): Promise<CustomAlertTypeResponseDto>;
+    /** Tombstones the type. Archive-first enforced. */
+    delete(id: string): Promise<void>;
+    /** LIVE → ARCHIVED. 409 while any alert of this type is OPEN. */
+    archive(id: string): Promise<CustomAlertTypeResponseDto>;
+    /** ARCHIVED → LIVE. */
+    unarchive(id: string): Promise<CustomAlertTypeResponseDto>;
 }
 export declare class ConfigEventDefinitionsResource {
     private readonly req;
@@ -422,8 +1000,6 @@ export declare class SetupResource {
 export declare class SettingsResource {
     private readonly req;
     constructor(req: RequestFn);
-    /** Download the live tenant.sync.json zip. Use snapshots for audit-grade records. */
-    getSyncExport(): Promise<SyncExportDto>;
     /** List every captured snapshot for the tenant, newest first. */
     listSyncSnapshots(): Promise<SyncSnapshotDto[]>;
     /** Detect whether the live config has drifted from the latest snapshot. */
@@ -436,5 +1012,79 @@ export declare class SettingsResource {
     /** Download a specific snapshot as a zip archive (tenant.sync.json + README.md). */
     downloadSyncSnapshot(id: string): Promise<unknown>;
 }
+/**
+ * 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 declare class CustomListsResource {
+    private readonly req;
+    constructor(req: RequestFn);
+    /** `GET /v1/screening/custom-lists` — lists, LIVE only by default. */
+    list(params?: {
+        lifecycle?: 'LIVE' | 'ARCHIVED' | 'ALL';
+        enabled?: boolean;
+        search?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<CustomScreeningListListResponse>;
+    /** `POST /v1/screening/custom-lists` — create a list. */
+    create(input: CreateCustomScreeningListInput): Promise<CustomScreeningListDto>;
+    /** `GET /v1/screening/custom-lists/{listId}`. */
+    get(listId: string): Promise<CustomScreeningListDto>;
+    /** `PATCH /v1/screening/custom-lists/{listId}` — name / description / enabled / tags. */
+    update(listId: string, input: UpdateCustomScreeningListInput): Promise<CustomScreeningListDto>;
+    /**
+     * `POST /v1/screening/custom-lists/{listId}/archive` — archived lists are
+     * read-only and excluded from screening.
+     */
+    archive(listId: string): Promise<CustomScreeningListDto>;
+    /** `POST /v1/screening/custom-lists/{listId}/unarchive`. */
+    unarchive(listId: string): Promise<CustomScreeningListDto>;
+    /** `GET /v1/screening/custom-lists/{listId}/entries`. */
+    listEntries(listId: string, params?: {
+        search?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<CustomListEntryListResponse>;
+    /** `POST /v1/screening/custom-lists/{listId}/entries` — add a single entry. */
+    createEntry(listId: string, input: CustomListEntryInput): Promise<CustomListEntryDto>;
+    /**
+     * `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: string, rows: CustomListEntryInput[]): Promise<BulkCustomListImportResultDto>;
+    /** `PATCH /v1/screening/custom-lists/{listId}/entries/{entryId}`. */
+    updateEntry(listId: string, entryId: string, input: UpdateCustomListEntryInput): Promise<CustomListEntryDto>;
+    /** `DELETE /v1/screening/custom-lists/{listId}/entries/{entryId}`. */
+    deleteEntry(listId: string, entryId: string): Promise<{
+        deleted: boolean;
+    }>;
+}
+/**
+ * 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 declare class ReportsResource {
+    private readonly getBinary;
+    constructor(getBinary: BinaryRequestFn);
+    /** Alert case file: facts, subject customer, matches / rule triggers, comments, activity. */
+    alert(alertId: string): Promise<Uint8Array>;
+    /** Customer profile: identity, documents, accounts, risk, screening, totals, alerts. */
+    customerProfile(customerId: string): Promise<Uint8Array>;
+    /** Counterparty profile: classification, identifiers, payment methods, totals. */
+    counterpartyProfile(counterpartyId: string): Promise<Uint8Array>;
+    /**
+     * 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: ReportResourceType, resourceId: string): Promise<Uint8Array>;
+}
+export type ReportResourceType = 'ACCOUNT' | 'TRANSACTION' | 'TASK' | 'DEVICE' | 'PRODUCT' | 'IDENTIFICATION_DOCUMENT' | 'INSTITUTION' | 'CONSTANT' | 'WEBHOOK' | (string & {});
 export {};
 //# sourceMappingURL=service.d.ts.map