@dossier-wiki/os-sdk 0.1.1 → 1.3.0

package/dist/types.d.ts

@@ -2,6 +2,195 @@ export interface Paginated<T> {
     data: T[];
     pagination: PaginationMeta;
 }
+/** A resource tag assignment: slugified `value` + snapshotted `label`. */
+export interface TagValue {
+    /** Slugified, stable key (catalogue value). */
+    value: string;
+    /** Human-readable label snapshot at assignment time. */
+    label: string;
+}
+/**
+ * Tag assignment input. Pass `label` only and the slug `value` is derived
+ * server-side, or pass both to pin a specific catalogue value.
+ */
+export interface TagValueInput {
+    label: string;
+    value?: string;
+}
+/** The catalogue-governed tag field-keys. */
+export type TagFieldKey = 'customer.tags' | 'customer.riskTags' | 'counterparty.tags' | 'counterparty.riskTags' | 'alert.dispositionTags' | 'product.tags' | 'address.tags' | 'rule.tags' | 'identificationDocument.tags' | 'customScreeningList.tags' | 'team.tags' | 'channelEndpoint.tags' | 'channelEndpoint.riskTags' | 'institution.riskTags';
+/** How many tags from one group a single record may carry. */
+export type TagGroupCardinality = 'SINGLE' | 'MULTI';
+/**
+ * A tag group — the facet ("Occupation", "Primary Branch") that owns a slice of
+ * one field-key's vocabulary. Its `value` is the namespace its member tags
+ * carry: `primary-branch:kandy`.
+ */
+export interface TagGroup {
+    id: string;
+    fieldKey: TagFieldKey;
+    /** Namespace slug. Never contains ':'. */
+    value: string;
+    label: string;
+    description?: string | null;
+    color?: string | null;
+    cardinality: TagGroupCardinality;
+    sortOrder: number;
+    archivedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TagGroupInput {
+    fieldKey: TagFieldKey;
+    label: string;
+    /** Namespace slug. Derived from label when omitted. May not contain ':'. */
+    value?: string;
+    description?: string;
+    color?: string;
+    cardinality?: TagGroupCardinality;
+    sortOrder?: number;
+}
+/** `fieldKey`/`value` are absent by design — see `regroup` for why. */
+export interface UpdateTagGroupInput {
+    label?: string;
+    description?: string;
+    color?: string;
+    /** Tightening to SINGLE is rejected while records hold more than one member tag. */
+    cardinality?: TagGroupCardinality;
+    sortOrder?: number;
+}
+/** What a regroup did, or (dryRun) exactly what it would do. */
+export interface RegroupReport {
+    dryRun: boolean;
+    entriesMoved: number;
+    assignmentsRewritten: number;
+    rulesRewritten: number;
+    assignmentPoliciesRewritten: number;
+    moves: {
+        label: string;
+        from: string;
+        to: string;
+    }[];
+}
+export interface TagCatalogueEntry {
+    id: string;
+    fieldKey: TagFieldKey;
+    /** Namespaced (`primary-branch:kandy`) when the entry belongs to a group. */
+    value: string;
+    label: string;
+    /** Owning group id, or null when ungrouped. */
+    groupId?: string | null;
+    /** Namespace prefix of `value` — the owning group's slug, or null. */
+    groupValue?: string | null;
+    color?: string | null;
+    description?: string | null;
+    archivedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TagCatalogueEntryInput {
+    fieldKey: TagFieldKey;
+    label: string;
+    /** Unqualified slug. May not contain ':' — join a group via `groupId`. */
+    value?: string;
+    /** Owning group. The server composes the namespaced stored value. */
+    groupId?: string;
+    color?: string;
+    description?: string;
+}
+export interface UpdateTagCatalogueEntryInput {
+    label?: string;
+    color?: string;
+    description?: string;
+}
+export type TypedFieldType = 'TEXT' | 'NUMBER' | 'BOOLEAN' | 'DATE' | 'LIST' | 'SINGLE_SELECT' | 'MULTI_SELECT'
+/** @deprecated Use LIST, SINGLE_SELECT, or MULTI_SELECT. */
+ | 'SET' | 'CURRENCY' | 'MONETARY';
+/** Schema declaration carried on a parent resource (e.g. `Product.accountFieldConfig`). */
+export interface TypedFieldDefinition {
+    key: string;
+    displayName: string;
+    type: TypedFieldType;
+    /** Required closed vocabulary for SINGLE_SELECT and MULTI_SELECT. */
+    options?: string[] | null;
+    required: boolean;
+    /** Default applied at write time when the caller omits the key. Raw value, validated against `type`. */
+    defaultValue?: unknown;
+    description?: string | null;
+}
+/**
+ * Caller-facing input for one typed key/value entry. `type` tells the
+ * backend validator how to interpret `value`:
+ *   - TEXT / DATE / CURRENCY → string
+ *   - NUMBER → finite JS number
+ *   - BOOLEAN → boolean
+ *   - LIST / MULTI_SELECT / legacy SET → string[]
+ *   - SINGLE_SELECT → one string from the definition's options
+ *   - MONETARY → denominated literal `"<amount>@<TYPE:CODE>"`, e.g. `"50000.00@FIAT:USD"`
+ */
+export interface TypedFieldValueInput {
+    key: string;
+    type: TypedFieldType;
+    value: unknown;
+}
+/** Untyped escape-hatch input (Tier C). Stored verbatim. */
+export interface UntypedKeyValueInput {
+    key: string;
+    value: unknown;
+}
+/**
+ * Read shape for one typed key/value entry. Wire-format `type` strings use
+ * the lowercase form. Monetary carries pre-resolved minor units.
+ */
+export type TypedFieldStored = {
+    key: string;
+    type: 'text';
+    value: string;
+} | {
+    key: string;
+    type: 'number';
+    value: number;
+} | {
+    key: string;
+    type: 'boolean';
+    value: boolean;
+} | {
+    key: string;
+    type: 'date';
+    value: string;
+} | {
+    key: string;
+    type: 'list';
+    value: string[];
+} | {
+    key: string;
+    type: 'single_select';
+    value: string;
+} | {
+    key: string;
+    type: 'multi_select';
+    value: string[];
+}
+/** @deprecated Legacy open list. */
+ | {
+    key: string;
+    type: 'set';
+    value: string[];
+} | {
+    key: string;
+    type: 'currency';
+    value: string;
+} | {
+    key: string;
+    type: 'monetary';
+    amountMinor: number;
+    currency: string;
+    precision: number;
+};
+export interface UntypedKeyValueDto {
+    key: string;
+    value: unknown;
+}
 export interface AccountResponseDto {
     id: string;
     externalId?: string;
@@ -9,14 +198,14 @@ export interface AccountResponseDto {
     productId?: string;
     label: string;
     accountCategory: 'DEPOSIT' | 'CREDIT' | 'LOAN' | 'WALLET' | 'SECURITIES' | 'OTHER';
+    /** @deprecated Retained for API compatibility. Prefer product tags for classification. */
     accountType: 'CHECKING' | 'SAVINGS' | 'OPERATING' | 'TRUST' | 'INVESTMENT' | 'ESCROW' | 'CREDIT_CARD' | 'LINE_OF_CREDIT' | 'PERSONAL_LOAN' | 'MORTGAGE' | 'AUTO_LOAN' | 'BUSINESS_LOAN' | 'CRYPTO_WALLET' | 'MOBILE_WALLET' | 'PREPAID_CARD' | 'E_WALLET' | 'BROKERAGE' | 'FUND' | 'OTHER';
-    status: 'ACTIVE' | 'FROZEN' | 'CLOSED' | 'DORMANT';
+    status: 'PENDING' | 'ACTIVE' | 'FROZEN' | 'CLOSED' | 'DORMANT';
     currency?: string;
-    bankName?: string;
-    bankSwift?: string;
-    iban?: string;
-    accountNumber?: string;
-    customProperties?: Record<string, unknown>;
+    /** Typed Field bag (Tier A). Validated against `Product.typedAccountFieldConfig`. */
+    fields?: TypedFieldStored[];
+    /** Untyped escape hatch (Tier C). */
+    otherProperties?: UntypedKeyValueDto[];
     openedAt: string;
     closedAt?: string;
 }
@@ -39,8 +228,32 @@ export type AddressCategory = 'HOME' | 'MAILING' | 'BILLING' | 'WORK' | 'REGISTE
 export type Iso20022AddressType = 'BIZZ' | 'DLVY' | 'HOME' | 'MLTO' | 'PBOX' | 'ADDR';
 export type AddressVerificationStatus = 'PENDING' | 'VERIFIED' | 'REJECTED' | 'EXPIRED';
 export type Lifecycle = 'LIVE' | 'ARCHIVED' | 'TOMBSTONED';
+/**
+ * A geographic point — the platform's one coordinate shape.
+ *
+ * A latitude without its longitude is not half a location. Everywhere the API
+ * carries a point it carries this: one value, one field.
+ */
+export interface CoordinatesDto {
+    latitude: number;
+    longitude: number;
+    /** @deprecated The original spelling. Same number as `latitude`. */
+    lat?: number;
+    /** @deprecated The original spelling. Same number as `longitude`. */
+    lng?: number;
+}
 export interface AddressCoordinatesDto {
+    /**
+     * The point.
+     *
+     * On a write this is the only accepted shape — a caller cannot send half a
+     * coordinate. On a read, `lat`/`lng` are still returned alongside it for
+     * consumers written against the original spelling.
+     */
+    point?: CoordinatesDto;
+    /** @deprecated Read-only. Use `point.latitude`. */
     lat?: number;
+    /** @deprecated Read-only. Use `point.longitude`. */
     lng?: number;
     /** Provenance, e.g. 'manual', 'google.geocode'. */
     source?: string;
@@ -50,8 +263,7 @@ export interface AddressCoordinatesDto {
 /**
  * Operational postal address. Lives in the polymorphic `addresses` table on the
  * server (owner = CUSTOMER / COUNTERPARTY / INSTITUTION). Exposed on the Customer
- * subtypes as `Individual.addresses` and `Entity.locations` — same shape, different
- * semantic field name.
+ * subtypes as `Individual.addresses` and `Entity.addresses` — same shape.
  *
  * Categories (semantic) and `iso20022Type` (wire-protocol) are parallel
  * discriminators; customer rows use `category`, counterparty/institution rows
@@ -67,7 +279,7 @@ export interface AddressDto {
     ownerResourceId: string;
     category?: AddressCategory | null;
     iso20022Type?: Iso20022AddressType | null;
-    tags: string[];
+    tags: TagValue[];
     note?: string | null;
     line1?: string | null;
     line2?: string | null;
@@ -106,7 +318,7 @@ export interface AddressDto {
 export interface AddressInputDto {
     category?: AddressCategory;
     iso20022Type?: Iso20022AddressType;
-    tags?: string[];
+    tags?: TagValueInput[];
     note?: string;
     line1?: string;
     line2?: string;
@@ -201,10 +413,30 @@ export interface CashDetailsDto {
 export interface ChannelDto {
     /** Channel type (WEB, MOBILE_APP, BRANCH, ATM, POS, API). */
     type: string;
+    /** Stable identifier for the concrete endpoint, such as a POS terminal, ATM, API client, or web page. */
+    identifier?: string;
+    /** Integration/provider namespace. Identical identifiers from different providers resolve independently. */
+    provider?: string;
+    /** Human-readable endpoint name used when it is first observed. */
+    displayName?: string;
     /** Session identifier. */
     sessionId?: string;
     /** Embedded session events (auth, copy-paste, form-fill, etc.). */
     events?: ChannelEventDto[];
+    /** Physical endpoint location, distinct from the device location. */
+    physicalLocation?: LocationObservationDto;
+    /** Bounded integration-defined values. Credential-like keys are rejected by the API. */
+    context?: Record<string, string | number | boolean | null>;
+}
+export interface LocationObservationDto {
+    latitude: number;
+    longitude: number;
+    accuracyMeters?: number;
+    confidence?: number;
+    source?: string;
+    method?: string;
+    isEstimated?: boolean;
+    observedAt?: string;
 }
 export interface ChannelEventDto {
     /** Event type (e.g. session.auth, session.copy_paste). */
@@ -302,7 +534,8 @@ export interface CounterpartyResponseDto {
     identity: 'INDIVIDUAL' | 'ENTITY' | 'UNKNOWN';
     classification: 'BANK_ACCOUNT' | 'WALLET' | 'MERCHANT' | 'FINANCIAL_INSTITUTION' | 'PAYMENT_NETWORK' | 'UNKNOWN';
     country?: string;
-    riskLevel: 'HIGH' | 'MEDIUM' | 'LOW' | 'UNRATED';
+    /** Unified risk rating; null = unrated (was `riskLevel` with UNRATED). */
+    riskRating: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL' | null;
     source: 'MANUAL' | 'SYSTEM';
     linkedCustomerIds: string[];
     /** ID of the transaction that first created this counterparty */
@@ -313,25 +546,35 @@ export interface CounterpartyResponseDto {
     institution?: InstitutionDetailsDto;
     firstTransactionAt?: string;
     lastTransactionAt?: string;
+    /** Untyped escape hatch (Tier C). */
+    otherProperties?: UntypedKeyValueDto[];
     createdAt: string;
     updatedAt: string;
 }
 export interface CreateAccountDto {
-    /** Your external identifier */
+    /**
+     * Customer to register as the PRIMARY owner. Written into
+     * `account_owners`, not stored on the accounts row (D18).
+     */
+    primaryCustomerId: string;
+    /** Your external identifier. Defaults to `ACC-${timestamp}`. */
     externalId?: string;
-    /** Product ID this account is based on */
+    /**
+     * Product this account is instantiated from. Determines `accountCategory`
+     * and the required typed-field schema. The deprecated `accountType`
+     * compatibility field is still derived from the product and is not
+     * accepted from the caller.
+     */
     productId?: string;
     label: string;
-    accountCategory: 'DEPOSIT' | 'CREDIT' | 'LOAN' | 'WALLET' | 'SECURITIES' | 'OTHER';
-    accountType: 'CHECKING' | 'SAVINGS' | 'OPERATING' | 'TRUST' | 'INVESTMENT' | 'ESCROW' | 'CREDIT_CARD' | 'LINE_OF_CREDIT' | 'PERSONAL_LOAN' | 'MORTGAGE' | 'AUTO_LOAN' | 'BUSINESS_LOAN' | 'CRYPTO_WALLET' | 'MOBILE_WALLET' | 'PREPAID_CARD' | 'E_WALLET' | 'BROKERAGE' | 'FUND' | 'OTHER';
-    /** Currency code (ISO 4217) */
+    /** Currency code (ISO 4217 / `TYPE:CODE`). Falls back to `product.defaultCurrency`. */
     currency?: string;
-    bankName?: string;
-    bankSwift?: string;
-    iban?: string;
-    accountNumber?: string;
-    /** Arbitrary key-value properties */
-    customProperties?: Record<string, unknown>;
+    /** Typed Field write input (Tier A). Validated against `Product.typedAccountFieldConfig`. */
+    fields?: TypedFieldValueInput[];
+    /** Untyped escape hatch (Tier C). Stored verbatim. */
+    otherProperties?: UntypedKeyValueInput[];
+    /** Customer IDs to add as JOINT owners alongside the primary. */
+    additionalOwnerIds?: string[];
     /** Override account opening timestamp (ISO 8601). Used by data-loading tools to backfill historical accounts. */
     openedAt?: string;
 }
@@ -342,16 +585,14 @@ export interface CreateApiKeyDto {
     scope: 'full_access' | 'evaluate_only';
     /** Expiration in seconds (default: 1 year) */
     expiresInSeconds?: number;
-    /** Organization ID to scope this key to (defaults to active org) */
-    organizationId?: string;
 }
 export interface CreateConstantDto {
     /** Constant name (e.g. $global.highRiskCountries). */
     name: string;
     /** Scope (derived from name if omitted). */
-    scope?: 'global' | 'product' | 'customer' | 'account' | 'counterparty' | 'instrument' | 'device';
+    scope?: 'global' | 'product' | 'customer' | 'account' | 'counterparty' | 'paymentInstrument' | 'device';
     /** Constant type. Determines the required shape of `value`. */
-    type: 'scalar' | 'monetary' | 'set' | 'range' | 'text' | 'number' | 'boolean' | 'date' | 'currency';
+    type: 'scalar' | 'monetary' | 'set' | 'range' | 'text' | 'number' | 'boolean' | 'date' | 'currency' | 'regex';
     /** Payload shape depends on the constant's `type`. Pick the matching variant below. Validated at write time. */
     value: {
         /** e.g. `"1000000@FIAT:USD"` = $10,000.00. Precision implied by currency: USD=2, JPY=0, BTC=8, ETH=9, USDT/USDC=6. */
@@ -368,6 +609,65 @@ export interface CreateConstantDto {
     description?: string;
     /** Sync key for config-as-code management. */
     syncKey?: string;
+    /** Product id for a product-bound `$account.*` definition. */
+    productId?: string;
+}
+export type StateScope = 'customer' | 'account' | 'counterparty' | 'product' | 'paymentInstrument' | 'device';
+export type StateResourceType = 'CUSTOMER' | 'ACCOUNT' | 'COUNTERPARTY' | 'PRODUCT' | 'PAYMENT_INSTRUMENT' | 'DEVICE';
+export type StateType = 'text' | 'number' | 'boolean' | 'date' | 'currency' | 'monetary' | 'set';
+export type StateOperation = 'SET' | 'INCREMENT' | 'DECREMENT';
+export interface CreateStateDefinitionInput {
+    name: string;
+    scope: StateScope;
+    type: StateType;
+    initialValue?: unknown;
+    description?: string;
+    /** Only valid for account-scoped definitions. */
+    productId?: string;
+}
+export interface StateDefinitionDto extends Omit<CreateStateDefinitionInput, 'productId'> {
+    id: string;
+    productId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ChangeResourceStateInput {
+    resourceType: StateResourceType;
+    resourceId: string;
+    name: string;
+    operation: StateOperation;
+    /** Replacement value for SET; magnitude for INCREMENT or DECREMENT. */
+    value: unknown;
+    reason?: string;
+}
+export interface ResourceStateDto {
+    id: string;
+    resourceType: StateResourceType;
+    resourceId: string;
+    name: string;
+    type: StateType;
+    value: unknown;
+    updatedByActorType: string;
+    updatedByActorId: string;
+    reason: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ResourceStateHistoryDto {
+    id: string;
+    resourceStateId: string;
+    resourceType: StateResourceType;
+    resourceId: string;
+    name: string;
+    type: StateType;
+    operation: StateOperation;
+    operand: unknown | null;
+    previousValue: unknown | null;
+    newValue: unknown;
+    actorType: string;
+    actorId: string;
+    reason: string | null;
+    changedAt: string;
 }
 export interface CreateCounterpartyDto {
     externalId?: string;
@@ -377,33 +677,152 @@ export interface CreateCounterpartyDto {
     classification: 'BANK_ACCOUNT' | 'WALLET' | 'MERCHANT' | 'FINANCIAL_INSTITUTION' | 'PAYMENT_NETWORK' | 'UNKNOWN';
     /** ISO 3166-1 alpha-3 country code */
     country?: string;
+    /**
+     * Catalogue-governed tags (e.g. operating branch), stamped at creation so
+     * the INITIAL screening run — and any assignment-policy tag routing —
+     * sees them. Values not in the catalogue are rejected.
+     */
+    tags?: TagValueInput[];
     bankAccount?: BankAccountDetailsDto;
     wallet?: CryptoWalletDetailsDto;
     merchant?: MerchantDetailsDto;
     institution?: InstitutionDetailsDto;
 }
-/** OpenAPI schema is empty; treated as an opaque key/value bag — narrow on the caller side. */
-export type CreateCurrencyInput = Record<string, unknown>;
-export interface CreateEntityDto {
+/** Currency classification. Mirrors the backend `CurrencyType` enum. */
+export type CurrencyType = 'FIAT' | 'CRYPTO' | 'OTHER';
+/** Product/account category. Mirrors the backend `AccountCategory` enum. */
+export type AccountCategory = 'DEPOSIT' | 'CREDIT' | 'LOAN' | 'WALLET' | 'SECURITIES' | 'OTHER';
+/** Base account type. Mirrors the backend `AccountType` enum. */
+export type AccountType = 'CHECKING' | 'SAVINGS' | 'OPERATING' | 'TRUST' | 'INVESTMENT' | 'ESCROW' | 'CREDIT_CARD' | 'LINE_OF_CREDIT' | 'PERSONAL_LOAN' | 'MORTGAGE' | 'AUTO_LOAN' | 'BUSINESS_LOAN' | 'CRYPTO_WALLET' | 'MOBILE_WALLET' | 'PREPAID_CARD' | 'E_WALLET' | 'BROKERAGE' | 'FUND' | 'OTHER';
+/** Product lifecycle status. Mirrors the backend `ProductStatus` enum. */
+export type ProductStatus = 'ACTIVE' | 'DISCONTINUED';
+export interface CreateCurrencyInput {
+    type: CurrencyType;
+    code: string;
+    /** Number of minor-unit decimal places (0–18). */
+    precision: number;
+    name: string;
+    symbol?: string;
+}
+export interface ContactEntryInput {
+    value: string;
+    primary: boolean;
+}
+/** Identification document embedded in an individual-create request. */
+export interface InlineIdentificationDocumentInput {
+    id?: string;
+    type: string;
+    number: string;
+    /** ISO 3166-1 alpha-3 country code. */
+    country: string;
+    /** @deprecated Alias for `country`, honoured only when `country` is absent. */
+    issuingCountry?: string;
+    expiryDate?: string;
+    dateOfIssue?: string;
+    fullNameEn?: string;
+    transliterationNames?: string[];
+    addresses?: RichAddressInputDto[];
+    dateOfBirth?: string;
+    sex?: string;
+    other?: Record<string, unknown>;
+    notes?: string;
+    attachments?: IdDocFileAttachmentInput[];
+    /** @deprecated Use `attachments` instead. */
+    fileIds?: string[];
+}
+/** Canonical REST/GraphQL entity-create request. */
+export interface CreateEntityInput {
     /** Your external identifier for this entity. Must be unique within the organization. */
     externalId: string;
     legalName: string;
+    status?: CustomerStatus;
     tradingNames?: string[];
     registrationNumber?: string;
+    /** Tax Identification Number (TIN). */
+    taxId?: string;
     /** ISO 3166-1 alpha-3 country code */
     countryOfIncorporation?: string;
     dateOfIncorporation?: string;
     entityType?: string;
-    /** Parent entity ID for subsidiaries */
-    parentEntityId?: string;
-    email?: string;
-    phone?: string;
+    websites?: string[];
+    stakeholders?: StakeholderInput[];
     /** Inline fan-out into the polymorphic `addresses` table. Same shape as
-     *  Individual.addresses; field is named `locations` to match the read-side
-     *  GraphQL field for entities. */
+     *  Individual.addresses; named `locations` on entities. */
     locations?: AddressInputDto[];
-    /** Override creation timestamp (ISO 8601). Used by data-loading tools to backfill historical entities. */
+    /**
+     * Catalogue-governed tags (e.g. operating branch), stamped at creation so
+     * the INITIAL screening run — and any assignment-policy tag routing —
+     * sees them. Values not in the catalogue are rejected.
+     */
+    tags?: TagValueInput[];
+    /**
+     * Standing assignment (user ids), stamped at creation so INITIAL screening
+     * and CUSTOMER_ASSIGNEE routing see it. Post-create edits via
+     * `customers.assignment.assign`.
+     */
+    assignedToUserIds?: string[];
+    /**
+     * Standing assignment (team ids), stamped at creation so INITIAL screening
+     * and CUSTOMER_ASSIGNEE routing see it. Post-create edits via
+     * `customers.assignment.assign`.
+     */
+    assignedToTeamIds?: string[];
+    /** @deprecated Use `emails`. Honoured only when `emails` is absent. */
+    email?: string;
+    /** @deprecated Use `phones`. Honoured only when `phones` is absent. */
+    phone?: string;
+    /** Override the creation timestamp (ISO 8601). For data-loading tools backfilling historical records. */
     createdAt?: string;
+    /** @deprecated Alias for `locations`, honoured only when `locations` is absent. */
+    addresses?: AddressInputDto[];
+    /** Parent entity for subsidiaries. */
+    parentEntityId?: string;
+}
+/** @deprecated Use `CreateEntityInput`. */
+export type CreateEntityDto = CreateEntityInput;
+/**
+ * A Risk Signal to emit on every valid occurrence of an event.
+ *
+ * Tenant configuration: an integration pushing an event cannot add, change, or
+ * suppress an effect. `weight` and `halfLife` are snapshotted onto each emitted
+ * signal, so editing the definition later never rewrites signals already
+ * recorded.
+ */
+export interface RiskSignalEffect {
+    /** Dotted signal type to emit, e.g. `authentication.password_change_attempt`. */
+    type: string;
+    /** Strength at the event timestamp. Must be greater than zero. */
+    weight: number;
+    /**
+     * Positive ISO 8601 duration, e.g. `P3D`. Calendar units (Y/M) are
+     * rejected — they have no fixed length.
+     */
+    halfLife: string;
+    /**
+     * Defaults to `EVENT_RESOURCE` — the signal attaches to the event's own
+     * primary resource.
+     */
+    target?: 'EVENT_RESOURCE';
+}
+/** What a declared resource is to the event. */
+export type EventResourceRole = 'SUBJECT' | 'CONTEXT';
+/** Every resource an Event Definition can name, in either role. */
+export type EventDeclaredResource = 'CUSTOMER' | 'ACCOUNT' | 'COUNTERPARTY' | 'EMPLOYEE' | 'BRANCH' | 'PAYMENT_INSTRUMENT' | 'DEVICE' | 'SESSION' | 'TRANSACTION';
+/**
+ * One resource an Event Definition names.
+ *
+ * `SUBJECT` entries enumerate the kinds an occurrence may be *about*; an
+ * occurrence names exactly one, so `required` carries no meaning there and the
+ * API normalises it to true. `CONTEXT` entries are the further resources it
+ * references, where `required` decides whether ingestion accepts an occurrence
+ * without one.
+ *
+ * `DEVICE`, `SESSION` and `TRANSACTION` are declarable as `CONTEXT` only.
+ */
+export interface EventResourceDeclarationDto {
+    resource: EventDeclaredResource;
+    role: EventResourceRole;
+    required: boolean;
 }
 export interface CreateEventDefinitionDto {
     /** Unique event name (used as key). */
@@ -414,29 +833,67 @@ export interface CreateEventDefinitionDto {
     description?: string;
     /** Event category. */
     category?: string;
-    /** Event properties schema. */
-    properties?: Record<string, unknown>[];
+    /**
+     * Resources this event names, each as SUBJECT (what an occurrence is
+     * about) or CONTEXT (what it also references). Omit to accept any
+     * attachable subject and expect no context.
+     */
+    resources?: EventResourceDeclarationDto[];
+    /** Event property schema. Same shape as `TypedFieldDefinition` (including `options` for select types). */
+    properties?: TypedFieldDefinition[];
+    /** Risk Signals to emit on every valid occurrence of this event. */
+    riskSignalEffects?: RiskSignalEffect[];
     /** Sync key for config-as-code management. */
     syncKey?: string;
 }
-export interface CreateIndividualDto {
+/** Canonical REST/GraphQL individual-create request. */
+export interface CreateIndividualInput {
     /** Your external identifier for this customer. Must be unique within the organization. */
     externalId: string;
     fullName: string;
+    status?: CustomerStatus;
     preferredName?: string;
+    aliases?: string[];
     dateOfBirth?: string;
     /** ISO 3166-1 alpha-3 country codes */
     nationality?: string[];
     /** ISO 3166-1 alpha-3 country codes */
     countryOfResidence?: string[];
-    email?: string;
-    phone?: string;
-    identificationDocuments?: IdentificationDocumentDto[];
+    /** Tax Identification Number (TIN). */
+    taxId?: string;
+    emails?: ContactEntryInput[];
+    phones?: ContactEntryInput[];
+    identificationDocuments?: InlineIdentificationDocumentInput[];
+    faceImageFileIds?: string[];
     /** Inline fan-out into the polymorphic `addresses` table. */
     addresses?: AddressInputDto[];
-    /** Override creation timestamp (ISO 8601). Used by data-loading tools to backfill historical customers. */
+    /**
+     * Catalogue-governed tags (e.g. operating branch), stamped at creation so
+     * the INITIAL screening run — and any assignment-policy tag routing —
+     * sees them. Values not in the catalogue are rejected.
+     */
+    tags?: TagValueInput[];
+    /**
+     * Standing assignment (user ids), stamped at creation so INITIAL screening
+     * and CUSTOMER_ASSIGNEE routing see it. Post-create edits via
+     * `customers.assignment.assign`.
+     */
+    assignedToUserIds?: string[];
+    /**
+     * Standing assignment (team ids), stamped at creation so INITIAL screening
+     * and CUSTOMER_ASSIGNEE routing see it. Post-create edits via
+     * `customers.assignment.assign`.
+     */
+    assignedToTeamIds?: string[];
+    /** @deprecated Use `emails`. Honoured only when `emails` is absent. */
+    email?: string;
+    /** @deprecated Use `phones`. Honoured only when `phones` is absent. */
+    phone?: string;
+    /** Override the creation timestamp (ISO 8601). For data-loading tools backfilling historical records. */
     createdAt?: string;
 }
+/** @deprecated Use `CreateIndividualInput`. */
+export type CreateIndividualDto = CreateIndividualInput;
 export interface CreateNoteDto {
     /** Note text content */
     text: string;
@@ -449,59 +906,146 @@ export interface CreateProductDto {
     /** Product description. */
     description?: string;
     /** Account category. */
-    category: string;
-    /** Base account type. */
-    baseType: string;
+    category: AccountCategory;
+    /** Preferred product classification, governed by the `product.tags` catalogue. */
+    tags?: TagValueInput[];
+    /** @deprecated Use `tags`. Omitted values are stored as `OTHER`. */
+    baseType?: AccountType;
     /** Default currency in TYPE:CODE format. */
     defaultCurrency: string;
-    /** ISO 3166-1 alpha-3 country code. */
+    /** @deprecated Use `tags` when product classification is needed. */
     country?: string;
     /** Supported transaction method IDs. */
     supportedMethodIds: string[];
-    /** Arbitrary product metadata. */
-    metadata?: Record<string, unknown>;
+    /** Account field template for accounts created from this product. */
+    accountFieldConfig?: TypedFieldDefinition[];
+    /** @deprecated Use `accountFieldConfig`. */
+    typedAccountFieldConfig?: TypedFieldDefinition[];
+    /** Product-level typed bag (Tier B, self-declaring). */
+    fields?: TypedFieldValueInput[];
+    /** Untyped escape hatch (Tier C). */
+    otherProperties?: UntypedKeyValueInput[];
     /** Sync key for config-as-code management. */
     syncKey?: string;
 }
+/** Attachment metadata for a file already uploaded via the file-upload flow. */
+export interface RiskAssessmentFileDto {
+    /** Uploaded file id (customer file id, or fileKey for platform uploads) */
+    id: string;
+    name: string;
+    /** File size in bytes */
+    size: number;
+}
 export interface CreateRiskAssessmentDto {
     answers: RiskAssessmentAnswerDto[];
-    resultingRiskLevel: 'HIGH' | 'MEDIUM' | 'LOW' | 'UNRATED';
-    computedRiskLevel?: 'HIGH' | 'MEDIUM' | 'LOW' | 'UNRATED';
+    resultingRiskRating: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+    computedRiskRating?: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
     ratingOverridden?: boolean;
     overrideJustification?: string;
     narrative?: string;
-    riskTags?: string[];
+    riskTags?: TagValueInput[];
+    files?: RiskAssessmentFileDto[];
 }
-export interface CreateRiskQuestionnaireDto {
-    answers: RiskQuestionnaireAnswerDto[];
+export interface CreateCustomerRiskAssessmentDto {
+    answers: CustomerRiskAssessmentAnswerDto[];
     /** Optional narrative summary */
     narrative?: string;
+    files?: RiskAssessmentFileDto[];
+}
+/**
+ * One action executed when a rule fires (spec v0 rules §8).
+ * `CREATE_ALERT` accepts an optional `severity` override
+ * (CRITICAL/HIGH/MEDIUM/LOW) plus `assignToTeamIds` / `assignToUserIds`;
+ * `SEND_WEBHOOK` references a configured webhook destination by `webhookId`;
+ * `FLAG_ENTITY` requires `entityType` + `flagType`; `TAG_CUSTOMER` requires
+ * `tag`; `ESCALATE` accepts an optional raising `severity` (HIGH/CRITICAL);
+ * `ADD_RISK_SIGNAL` requires `signalType`, `weight`, `halfLife` and `target`.
+ * Non-webhook types may appear at most once per rule — duplicates are
+ * rejected with 400. `ADD_RISK_SIGNAL` is exempt (one rule may legitimately
+ * record several kinds of evidence, or the same evidence against several
+ * resources); what it rejects is the same `signalType` on the same
+ * `target.resource` twice, which would double-count in every aggregate.
+ */
+export interface RuleAction {
+    type: 'CREATE_ALERT' | 'SEND_WEBHOOK' | 'FLAG_ENTITY' | 'TAG_CUSTOMER' | 'BLOCK_TRANSACTION' | 'FREEZE_ACCOUNT' | 'ADD_RISK_SIGNAL' | 'ASSIGN_FOR_REVIEW' | 'ESCALATE';
+    /** CREATE_ALERT: alert risk level override (defaults to the rule
+     *  severity). ESCALATE: HIGH or CRITICAL only. */
+    severity?: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    /** CREATE_ALERT: better-auth team ids assigned to the alert on creation. */
+    assignToTeamIds?: string[];
+    /** CREATE_ALERT: user ids assigned to the alert on creation. */
+    assignToUserIds?: string[];
+    /** SEND_WEBHOOK: configured webhook destination id. */
+    webhookId?: string;
+    /** FLAG_ENTITY: which entity the flag lands on (required). */
+    entityType?: 'TRANSACTION' | 'CUSTOMER' | 'ACCOUNT';
+    /** FLAG_ENTITY: tenant-meaningful flag label, e.g. REVIEW_REQUIRED (required). */
+    flagType?: string;
+    /** TAG_CUSTOMER: tag appended to the customer record (required). */
+    tag?: string;
+    /**
+     * ADD_RISK_SIGNAL: dotted signal type to record (required). Tenant
+     * vocabulary — not a fixed platform enum.
+     */
+    signalType?: string;
+    /**
+     * ADD_RISK_SIGNAL: strength at the moment the rule fires (required, > 0).
+     * Snapshotted onto every signal the action emits.
+     */
+    weight?: number;
+    /**
+     * ADD_RISK_SIGNAL: positive ISO 8601 duration (required), e.g. `P7D`.
+     * Calendar units (Y/M) are rejected — they have no fixed length.
+     */
+    halfLife?: string;
+    /**
+     * ADD_RISK_SIGNAL: which resource in the evaluation the signal attaches to
+     * (required). A closed selector, never a field expression.
+     *
+     * `employee` and `branch` are **not** valid selectors: no evaluation
+     * envelope resolves either slot yet, so a rule targeting one could never
+     * fire. Both are rejected at save time with a 400 explaining why.
+     */
+    target?: {
+        resource: 'customer' | 'account' | 'counterparty' | 'paymentInstrument';
+    };
+    [key: string]: unknown;
 }
 export interface CreateRuleDto {
     /** Rule name. */
     name: string;
     /** Rule description. */
     description?: string;
-    /** Rule subject. */
+    /** Rule subject: 'TRANSACTION' | 'EVENT' | 'CUSTOMER' | 'ALL'. */
     subject: string;
-    /** Rule trigger. */
+    /**
+     * Rule trigger — the event type that causes evaluation. Core triggers:
+     * `transaction.*` (subject TRANSACTION), `customer.*` / `account.*`
+     * (subject EVENT). Custom triggers use `custom.{slug}` and must name an
+     * ACTIVE event definition (Event Definitions API). `'*'` fires on all
+     * events in the subject's scope. Invalid pairs are rejected with 400.
+     */
     trigger?: string;
     /** Rule severity. */
     severity: 'HIGH' | 'MEDIUM' | 'LOW';
-    /** Tags for categorisation. */
-    tags?: string[];
+    /** Tags for categorisation (tag catalogue). */
+    tags?: TagValueInput[];
     /** Condition tree (AND/OR logic with leaf conditions). */
     conditionTree?: Record<string, unknown>;
     /** Actions to execute when the rule triggers. */
-    actions?: string[];
+    actions?: RuleAction[];
     /** Window period for aggregate conditions. */
     windowPeriod?: string;
     /** Initial status for the rule. */
     initialStatus?: 'DRAFT' | 'ACTIVE' | 'DISABLED';
     /** Sync key for config-as-code management. */
     syncKey?: string;
+    /** Product applicability. Omit or empty products = unscoped. */
+    scope?: {
+        products?: string[];
+    };
 }
-export interface CreateStakeholderDto {
+export interface StakeholderInput {
     name: string;
     role: 'SHAREHOLDER' | 'UBO' | 'DIRECTOR';
     /** Ownership percentage (0–100) */
@@ -514,6 +1058,8 @@ export interface CreateStakeholderDto {
     /** Link to an existing Entity customer */
     entityId?: string;
 }
+/** @deprecated Use `StakeholderInput`. */
+export type CreateStakeholderDto = StakeholderInput;
 export interface CreateWebhookDto {
     /** Webhook destination name. */
     name: string;
@@ -598,15 +1144,25 @@ export interface EntityResponseDto {
     countryOfIncorporation?: string;
     dateOfIncorporation?: string;
     entityType?: string;
+    /** Tax Identification Number (TIN). */
+    taxId?: string;
     parentEntityId?: string;
     email?: string;
     phone?: string;
     riskRating: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
     kycTier?: 'NO_KYC' | 'SDD' | 'CDD' | 'EDD' | 'ONGOING';
+    /**
+     * Standing assignment — the users/teams responsible for compliance work on
+     * this customer. NOT ownership ("owner" here means UBO or account owner).
+     * Read by the CUSTOMER_ASSIGNEE routing block, so a new alert can go to
+     * whoever holds the customer.
+     */
+    assignedToUserIds?: string[];
+    assignedToTeamIds?: string[];
     alertCount: number;
     /** Operational footprint (REGISTERED office, BRANCH, WAREHOUSE, …). Read-only here;
      *  use granular add/update/remove/verify/reject mutations on the addresses endpoint. */
-    locations: AddressDto[];
+    addresses: AddressDto[];
     createdAt: string;
     updatedAt: string;
 }
@@ -645,14 +1201,28 @@ export interface IPSessionDto {
     country?: string;
     isVPN?: boolean;
     vpnProvider?: string;
+    asn?: string;
+    networkName?: string;
+    confidence?: number;
 }
 export interface IdentificationDocumentDto {
+    id?: string;
     /** Document type */
     type: string;
     number: string;
     /** ISO 3166-1 alpha-3 country code */
-    issuingCountry: string;
+    country: string;
+    /**
+     * @deprecated Accepted on write as an alias for `country`, but never
+     * returned — responses have always carried `country`. Read `country`.
+     */
+    issuingCountry?: string;
     expiryDate?: string;
+    dateOfIssue?: string;
+    notes?: string;
+    attachments?: AttachmentDto[];
+    /** @deprecated Use `attachments`. */
+    fileIds?: string[];
 }
 export type IdentificationDocumentStatus = 'PENDING' | 'APPROVED' | 'REJECTED';
 /** Computed status — also reflects expiry and archive state. */
@@ -742,7 +1312,7 @@ export interface IdentificationDocument {
     status: IdentificationDocumentStatus;
     effectiveStatus: IdentificationDocumentEffectiveStatus;
     rejectionNarrative?: string;
-    tags: string[];
+    tags: TagValue[];
     attachments: IdDocFileAttachment[];
     /** @deprecated Use attachments[].fileId instead. */
     fileIds?: string[];
@@ -775,7 +1345,7 @@ export interface CreateIdentificationDocumentInput {
     sex?: string;
     /** Free-form key/value metadata. */
     other?: Record<string, unknown>;
-    tags?: string[];
+    tags?: TagValueInput[];
     attachments?: IdDocFileAttachmentInput[];
     notes?: string;
 }
@@ -791,7 +1361,7 @@ export interface UpdateIdentificationDocumentInput {
     dateOfBirth?: string;
     sex?: string;
     other?: Record<string, unknown>;
-    tags?: string[];
+    tags?: TagValueInput[];
     attachments?: IdDocFileAttachmentInput[];
     notes?: string;
 }
@@ -816,7 +1386,7 @@ export interface DeleteIdentificationDocumentResponse {
     deletedId: string;
 }
 /** Resource types that can carry platform comments. */
-export type CommentResourceType = 'CUSTOMER' | 'ACCOUNT' | 'TRANSACTION' | 'TASK' | 'ALERT' | 'COMMENT' | 'COUNTERPARTY' | 'DEVICE' | 'RULE' | 'PRODUCT' | 'INSTRUMENT' | 'IDENTIFICATION_DOCUMENT';
+export type CommentResourceType = 'CUSTOMER' | 'ACCOUNT' | 'TRANSACTION' | 'TASK' | 'ALERT' | 'COMMENT' | 'COUNTERPARTY' | 'DEVICE' | 'RULE' | 'PRODUCT' | 'PAYMENT_INSTRUMENT' | 'IDENTIFICATION_DOCUMENT';
 export interface PlatformCommentAttachmentInput {
     /** fileId returned by /platform/v1/files/upload-url */
     fileId: string;
@@ -828,7 +1398,12 @@ export interface PlatformCommentAttachment extends PlatformCommentAttachmentInpu
     /** Short-lived presigned download URL (when resolved by the server). */
     downloadUrl?: string;
 }
+export interface CommentLinksInput {
+    /** Screening matches attached to this comment. Empty removes all attachments; omitting links on update preserves them. */
+    matchIds?: string[];
+}
 export interface PlatformCreateCommentDto {
+    links?: CommentLinksInput;
     resourceType: CommentResourceType;
     resourceId: string;
     /** Markdown body (GFM tables supported). */
@@ -838,6 +1413,7 @@ export interface PlatformCreateCommentDto {
     externalRequestId?: string;
 }
 export interface PlatformUpdateCommentDto {
+    links?: CommentLinksInput;
     /** Markdown body (GFM tables supported). */
     body: string;
 }
@@ -846,7 +1422,15 @@ export interface ListPlatformCommentsQuery {
     resourceId: string;
 }
 /** Comment response shape — the OpenAPI spec does not document a full schema, so callers should narrow as needed. */
+/** Stable references to screening results, with labels retained after a rescreen. */
+export interface PlatformCommentMatchReference {
+    matchId: string;
+    name: string;
+    category: 'WATCHLIST' | 'HIGH_RISK' | 'CUSTOM_LIST';
+}
 export interface PlatformComment {
+    /** Always present; empty when the comment references no screening result. */
+    matchReferences: PlatformCommentMatchReference[];
     id: string;
     resourceType: CommentResourceType;
     resourceId: string;
@@ -904,10 +1488,20 @@ export interface IndividualResponseDto {
     dateOfBirth?: string;
     nationality?: string[];
     countryOfResidence?: string[];
+    /** Tax Identification Number (TIN). */
+    taxId?: string;
     email?: string;
     phone?: string;
     riskRating: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
     kycTier?: 'NO_KYC' | 'SDD' | 'CDD' | 'EDD' | 'ONGOING';
+    /**
+     * Standing assignment — the users/teams responsible for compliance work on
+     * this customer. NOT ownership ("owner" here means UBO or account owner).
+     * Read by the CUSTOMER_ASSIGNEE routing block, so a new alert can go to
+     * whoever holds the customer.
+     */
+    assignedToUserIds?: string[];
+    assignedToTeamIds?: string[];
     alertCount: number;
     identificationDocuments: IdentificationDocumentDto[];
     /** Postal addresses (HOME / MAILING / BILLING / WORK). Read-only here;
@@ -932,22 +1526,65 @@ export interface IngestDevicePayloadDto {
     botProbability?: number;
     /** Detection confidence score (0-1). */
     confidence?: number;
+    /** Device location observation. Multiple observations are retained over time. */
+    location?: LocationObservationDto;
+}
+/** Resource an Event occurrence attaches to as its single primary subject. */
+export type EventResourceType = 'CUSTOMER' | 'ACCOUNT' | 'COUNTERPARTY' | 'EMPLOYEE' | 'BRANCH' | 'PAYMENT_INSTRUMENT';
+/** Resource a Risk Signal attaches to. */
+export type RiskSignalResourceType = 'CUSTOMER' | 'ACCOUNT' | 'COUNTERPARTY' | 'EMPLOYEE' | 'BRANCH' | 'PAYMENT_INSTRUMENT';
+/** The single resource an Event is about. Exactly one, always. */
+export interface EventResourceRef {
+    type: EventResourceType;
+    /** Id of the resource, which must already exist in your organization. */
+    id: string;
 }
 export interface IngestEventDto {
+    /**
+     * Your unique identifier for this event (max 255 chars). Used for
+     * idempotency: resubmitting the same eventId returns the original
+     * stored event (`cached: true`) instead of creating a duplicate — safe
+     * for client retries. Omit to skip deduplication.
+     */
+    eventId?: string;
     /** Event type (core or custom). Core types: customer.failed_login, customer.profile_updated. Custom types match event definitions. */
     type: string;
     /** When the event occurred. */
     timestamp: string;
-    /** Customer ID this event is associated with. */
-    customerId: string;
+    /**
+     * The single resource this event is about. Supply either `resource` or the
+     * legacy top-level `customerId` — `resource` wins when both are present.
+     * An event that names neither is rejected with 400.
+     *
+     * `deviceId` and `sessionId` may qualify an event but never substitute for
+     * its primary resource.
+     */
+    resource?: EventResourceRef;
+    /**
+     * Customer this event relates to.
+     *
+     * Two roles: as the legacy attachment field it is exactly equivalent to
+     * `resource: { type: 'CUSTOMER', id }`, and alongside a non-customer
+     * `resource` it is context that customer-scoped event aggregates read.
+     *
+     * @deprecated `resource` is the contract. A bare `customerId` is still
+     * accepted as the legacy spelling of `resource: { type: 'CUSTOMER', id }`,
+     * but new integrations should send `resource` — it is the only way to
+     * attach an event to an account, counterparty, employee, branch, or
+     * payment instrument.
+     */
+    customerId?: string;
     /** Account ID if the event is account-scoped. */
     accountId?: string;
     /** Device identifier for device-context rules. */
     deviceId?: string;
     /** Session identifier for session-context rules. */
     sessionId?: string;
-    /** Event-specific payload data. Schema depends on event type. */
-    data?: Record<string, unknown>;
+    /**
+     * Typed payload (Typed Fields primitive, Tier B). Validated via the
+     * canonical TypedFields validator and stored in `events.fields`.
+     */
+    fields?: TypedFieldValueInput[];
 }
 export interface IngestTransactionDto {
     /** Your unique identifier for this transaction. Used for idempotency. */
@@ -956,8 +1593,8 @@ export interface IngestTransactionDto {
     timestamp: string;
     /** The transaction payload. */
     transaction: TransactionBodyDto;
-    /** Payment instrument used for this transaction. */
-    instrument?: InstrumentPayloadDto;
+    /** Canonical Payment Instrument identity or protected credential for deterministic create-on-miss resolution. */
+    paymentInstrument?: PaymentInstrumentPayloadDto;
     /** Intermediary banks/institutions in the payment chain. */
     intermediaries?: IntermediaryDto[];
     /** Device / fingerprint data used for device-based rules and device-trust resolution. */
@@ -965,9 +1602,172 @@ export interface IngestTransactionDto {
     /** Set to true for async processing. Returns 202 Accepted immediately; results delivered via webhook. */
     async?: boolean;
 }
-export interface InitializeSetupDto {
-    /** Admin user full name */
-    name: string;
+/** Why a payment operation failed to become a transaction in the source system. */
+export type TransactionAttemptOutcome = 'FAILED' | 'BLOCKED' | 'UNKNOWN';
+export interface TransactionAttemptOutcomeDto {
+    type: TransactionAttemptOutcome;
+    code?: string;
+    reason?: string;
+    /** System or provider that supplied the outcome. */
+    source?: string;
+    retryable?: boolean;
+    /** Whether the integration considers this the final outcome for the operation. */
+    final?: boolean;
+}
+export interface AttemptedAmountDto {
+    /** Attempted value in the supplied currency's minor units. */
+    amountMinor: number;
+    /** Structured currency code, for example `FIAT:USD`. */
+    currency: string;
+    precision: number;
+}
+/**
+ * Durable behavioural record for an operation that did not become a source
+ * transaction. Snapshot objects must contain safe descriptors only—never PANs,
+ * raw payment tokens, API keys, or unprotected device fingerprints.
+ */
+export interface IngestTransactionAttemptDto {
+    /** Tenant-scoped idempotency key. */
+    attemptId: string;
+    /** When the source system observed the attempt. */
+    timestamp: string;
+    /** Integration-defined payment operation, for example `CARD_AUTHORIZATION`. */
+    operation: string;
+    outcome: TransactionAttemptOutcomeDto;
+    amount?: AttemptedAmountDto;
+    direction?: 'IN' | 'OUT';
+    mode?: Record<string, unknown>;
+    channel?: Record<string, unknown>;
+    authentication?: Record<string, unknown>;
+    principalParty?: Record<string, unknown>;
+    counterparty?: Record<string, unknown>;
+    /** Lookup-only Payment Instrument reference. A miss never creates a Payment Instrument. */
+    paymentInstrument?: AttemptPaymentInstrumentDto;
+    device?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+export interface IngestTransactionAttemptResponse {
+    attemptId: string;
+    /** Database record ID. */
+    id: string;
+    /** True when an identical tenant-scoped replay returned the existing record. */
+    cached: boolean;
+    observedAt: string;
+    expiresAt: string;
+}
+export type AttemptCoverage = 'ALL' | 'SELECTIVE';
+/**
+ * What event ingestion does with a type that has no Event Definition.
+ * `ACCEPT` (the default) records it as history that links to no Definition and
+ * emits no Risk Signals; `REJECT` fails the request instead.
+ */
+export type UnknownEventTypePolicy = 'ACCEPT' | 'REJECT';
+export interface TenantBehaviorSettings {
+    attemptRetentionDays: number;
+    attemptCoverage: AttemptCoverage;
+    unknownEventTypes: UnknownEventTypePolicy;
+}
+export interface UpdateTenantBehaviorSettingsInput {
+    attemptRetentionDays?: number;
+    attemptCoverage?: AttemptCoverage;
+    unknownEventTypes?: UnknownEventTypePolicy;
+}
+export interface ListTransactionAttemptsInput {
+    limit?: number;
+    cursor?: string;
+    outcomes?: TransactionAttemptOutcome[];
+    operation?: string;
+    observedFrom?: string;
+    observedTo?: string;
+    customerId?: string;
+    accountId?: string;
+    counterpartyId?: string;
+    paymentInstrumentId?: string;
+    deviceId?: string;
+    sessionId?: string;
+    channelEndpointId?: string;
+    iin?: string;
+}
+/** Safe read projection. Protected request/fingerprint/IP hashes are never returned. */
+export interface TransactionAttemptDto {
+    id: string;
+    attemptId: string;
+    observedAt: string;
+    outcome: TransactionAttemptOutcome;
+    outcomeCode?: string | null;
+    outcomeReason?: string | null;
+    outcomeSource?: string | null;
+    retryable?: boolean | null;
+    final: boolean;
+    operation: string;
+    mode?: Record<string, unknown> | null;
+    channel?: Record<string, unknown> | null;
+    authentication?: Record<string, unknown> | null;
+    direction?: 'IN' | 'OUT' | null;
+    originAmountMinor?: number | null;
+    originCurrency?: string | null;
+    originPrecision?: number | null;
+    baseAmountMinor?: number | null;
+    baseCurrency?: string | null;
+    basePrecision?: number | null;
+    customerId?: string | null;
+    accountId?: string | null;
+    counterpartyId?: string | null;
+    paymentInstrumentId?: string | null;
+    deviceId?: string | null;
+    sessionId?: string | null;
+    channelEndpointId?: string | null;
+    iin?: string | null;
+    countryCode?: string | null;
+    principalParty?: Record<string, unknown> | null;
+    counterparty?: Record<string, unknown> | null;
+    paymentInstrument?: Record<string, unknown> | null;
+    device?: Record<string, unknown> | null;
+    context?: Record<string, unknown> | null;
+    expiresAt: string;
+    createdAt: string;
+}
+export interface TransactionAttemptPage {
+    items: TransactionAttemptDto[];
+    nextCursor?: string | null;
+}
+export interface ContributingAttemptFact {
+    attemptId: string;
+    observedAt: string;
+    outcome?: string;
+    operation?: string;
+    customerId?: string | null;
+    accountId?: string | null;
+    counterpartyId?: string | null;
+    paymentInstrumentId?: string | null;
+    deviceId?: string | null;
+    sessionId?: string | null;
+    channelEndpointId?: string | null;
+    originAmountMinor?: number | null;
+    originCurrency?: string | null;
+    originPrecision?: number | null;
+    baseAmountMinor?: number | null;
+    baseCurrency?: string | null;
+    basePrecision?: number | null;
+    iin?: string | null;
+    countryCode?: string | null;
+    ipLookupHash?: string | null;
+}
+export interface AlertAttemptEvidence {
+    id: string;
+    alertId: string;
+    ruleId: string;
+    ruleVersion?: number | null;
+    attempts: ContributingAttemptFact[];
+    contributingAttemptCount: number;
+    capturedAttemptCount: number;
+    truncated: boolean;
+    capturedAt: string;
+    retainedUntil?: string | null;
+}
+export interface InitializeSetupDto {
+    /** Admin user full name */
+    name: string;
     /** Admin email address */
     email: string;
     /** Admin password (min 8 characters) */
@@ -976,6 +1776,8 @@ export interface InitializeSetupDto {
     organizationName: string;
     /** Organization slug (URL-friendly identifier) */
     organizationSlug: string;
+    /** Definition of the tenant base currency. Created as the only currency at setup. Defaults to FIAT USD. */
+    baseCurrency?: CreateCurrencyInput;
     /** Enable Transaction Intelligence product */
     transactionIntelligence?: boolean;
     /** Enable KYC vendor integration (within Customer Monitoring) */
@@ -986,18 +1788,6 @@ export interface InstitutionDetailsDto {
     lei?: string;
     regulatoryStatus?: string;
 }
-export interface InstrumentPayloadDto {
-    /** Instrument identifier. */
-    id: string;
-    /** Human-readable name persisted as instruments.displayName (e.g. "Personal Visa", "Travel Card"). */
-    name?: string;
-    /** Instrument type (CARD, VIRTUAL_CARD, WALLET_TOKEN, etc.). */
-    type?: string;
-    /** Instrument status (ACTIVE, BLOCKED, EXPIRED, etc.). */
-    status?: string;
-    /** Token or masked identifier. */
-    token?: string;
-}
 export interface IntermediaryDto {
     /** Role of the intermediary (e.g. CORRESPONDENT, CLEARING_BANK). */
     role: string;
@@ -1091,7 +1881,11 @@ export interface OtherPaymentDetailsDto {
 }
 export interface PaginationMeta {
     /** Cursor to fetch the next page, null if no more results */
-    nextCursor: Record<string, unknown> | null;
+    /**
+     * Opaque cursor for the next page — the last row's id — or `null` on the
+     * final page. Pass it straight back as `cursor`.
+     */
+    nextCursor: string | null;
     /** Total number of items matching the query */
     totalCount: number;
 }
@@ -1107,8 +1901,79 @@ export interface PatchTransactionStatusDto {
     /** Human-readable reason for terminal transitions (REJECTED, REVERSED, BLOCKED). Stored in statusHistory for audit. */
     terminalReason?: string;
 }
+/** Integer minor-unit amount with the currency and precision needed to display it. */
+export interface MonetaryAmountDto {
+    /** Integer amount in minor units (cents, satoshi, …). */
+    amountMinor: number;
+    /** Currency in `TYPE:CODE` form, e.g. `FIAT:USD`. */
+    currency: string;
+    /** Decimal places: `major = amountMinor / 10^precision`. */
+    precision: number;
+}
+export interface TransactionStatusHistoryEntryDto {
+    from?: string;
+    to: string;
+    /** ISO 8601 — when the change occurred in the caller's system. */
+    changedAt: string;
+    reason?: string;
+}
+/**
+ * A stored transaction as the platform holds it after ingestion: the caller's
+ * payload plus what resolution and normalisation added. Returned by
+ * `GET /v1/transactions/{transactionId}`.
+ */
+export interface TransactionResponseDto {
+    /** Internal transaction UUID (the `id` returned by `POST /transactions`). */
+    id: string;
+    /** Caller-supplied reference (the `transactionId` sent on ingest). */
+    transactionId: string;
+    kind: 'TRANSFER' | 'ACCOUNT_ENTRY' | (string & {});
+    status: 'PENDING' | 'PROCESSING' | 'COMPLETE' | 'REJECTED' | 'REVERSED' | 'BLOCKED' | (string & {});
+    statusChangedAt?: string | null;
+    statusHistory?: TransactionStatusHistoryEntryDto[];
+    /** Immutable window anchor. */
+    executedAt: string;
+    settledAt?: string | null;
+    direction?: 'IN' | 'OUT' | null;
+    entryType?: string | null;
+    mode?: Record<string, unknown> | null;
+    channel?: Record<string, unknown> | null;
+    memo?: string | null;
+    /** Amount as ingested. */
+    origin: MonetaryAmountDto;
+    /** Amount normalised to the tenant base currency. */
+    base?: MonetaryAmountDto | null;
+    destination?: MonetaryAmountDto | null;
+    baseExchangeRate?: number | null;
+    fees?: unknown[] | null;
+    baseFeeTotalMinor?: number | null;
+    paymentInfo?: Record<string, unknown> | null;
+    principalParty?: Record<string, unknown> | null;
+    counterparty?: Record<string, unknown> | null;
+    customerId?: string | null;
+    accountId?: string | null;
+    counterpartyId?: string | null;
+    counterpartyPaymentMethodId?: string | null;
+    counterpartyResolutionStatus?: string | null;
+    /** @deprecated Mirrors `paymentInstrumentId`. */
+    instrumentId?: string | null;
+    paymentInstrumentId?: string | null;
+    channelEndpointId?: string | null;
+    deviceId?: string | null;
+    sessionId?: string | null;
+    isInternalTxn?: boolean | null;
+    isSelfTransfer?: boolean | null;
+    internalCounterpartyCustomerId?: string | null;
+    internalCounterpartyAccountId?: string | null;
+    relatedTransactions?: unknown[] | null;
+    isFlagged: boolean;
+    flaggedAlertIds: string[];
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
 export interface PaymentDetailsDto {
-    /** Discriminator selecting which payment subtype block to populate. NOTE: card-on-file (the instrument the principal customer paid with) is modelled separately on the transaction `instrument` field — counterparty payment details describe how the OTHER party receives money. */
+    /** Discriminator selecting which payment subtype block to populate. NOTE: the Payment Instrument used by the principal customer is modelled separately on the transaction `paymentInstrument` field — counterparty payment details describe how the counterparty receives money. */
     type: 'BANK_ACCOUNT' | 'CRYPTO_WALLET' | 'DIGITAL_WALLET' | 'MERCHANT' | 'PROCESSOR' | 'CASH' | 'CHECK' | 'ATM' | 'OTHER';
     bankAccount?: BankAccountDetailsDto;
     cryptoWallet?: CryptoWalletDetailsDto;
@@ -1154,11 +2019,20 @@ export interface PaymentLocationAddressDto {
     /** ISO 3166-1 alpha-3 country code. */
     country?: string;
 }
+/**
+ * A point on an ingested payment location.
+ *
+ * Both spellings are accepted; send either. Exactly one point is stored.
+ */
 export interface PaymentLocationCoordinatesDto {
     /** Latitude (WGS84). */
-    lat: number;
+    latitude?: number;
     /** Longitude (WGS84). */
-    lng: number;
+    longitude?: number;
+    /** Latitude (WGS84). Prefer `latitude`. */
+    lat?: number;
+    /** Longitude (WGS84). Prefer `longitude`. */
+    lng?: number;
 }
 export interface PlaceOfBirthDto {
     cityOfBirth?: string;
@@ -1219,13 +2093,22 @@ export interface RegisterDeviceBrowserDetailsDto {
     userAgent?: string;
 }
 export interface RegisterDeviceDto {
-    /** Fingerprint provider identifier for the device */
-    fingerprint: string;
-    browserDetails: RegisterDeviceBrowserDetailsDto;
-    /** IP sessions observed for the device */
-    ipSessions?: unknown[];
+    /** Raw identities used only for tenant-bound protected resolution; values are never persisted or returned. */
+    fingerprints: RegisterDeviceFingerprintDto[];
+    browserDetails?: RegisterDeviceBrowserDetailsDto;
     botProbability?: number;
     confidence?: number;
+    /** ISO 8601 observation time. Defaults to server receipt time. */
+    observedAt?: string;
+}
+export interface RegisterDeviceFingerprintDto {
+    /** Raw identity value used in memory only. */
+    value: string;
+    /** Provider namespace. Defaults to INGEST to converge with transaction ingestion. */
+    provider?: string;
+    /** Provider-qualified identity type. Defaults to DEVICE. */
+    type?: string;
+    confidence?: number;
 }
 export interface RelatedTransactionDto {
     /** Transaction ID of the related transaction. Use the same identifier format as `transactionId` (your external reference). */
@@ -1253,7 +2136,7 @@ export interface RiskAssessmentAnswerDto {
     selectedOptionId?: string;
     notes?: string;
 }
-export interface RiskQuestionnaireAnswerDto {
+export interface CustomerRiskAssessmentAnswerDto {
     questionId: string;
     question: string;
     answer: string;
@@ -1269,9 +2152,23 @@ export interface TaxIdentificationDto {
     /** YYYY-MM-DD */
     registrationDate?: string;
 }
+/**
+ * Ledger-line classification for an `ACCOUNT_ENTRY` transaction — a fee, an
+ * interest movement, a payment, or an adjustment.
+ */
+export type AccountEntryType = 'MONTHLY_FEE' | 'WIRE_FEE' | 'OVERDRAFT_FEE' | 'LATE_PAYMENT_FEE' | 'ANNUAL_FEE' | 'ATM_FEE' | 'FOREIGN_TRANSACTION_FEE' | 'INTEREST_CHARGE' | 'INTEREST_PAYMENT' | 'PRINCIPAL_PAYMENT' | 'ESCROW_PAYMENT' | 'MINIMUM_PAYMENT' | 'STATEMENT_PAYMENT' | 'REWARD_REDEMPTION' | 'CASHBACK' | 'ADJUSTMENT' | 'CHARGEBACK' | 'PROMOTIONAL_CREDIT' | 'PENALTY' | 'REFUND';
 export interface TransactionBodyDto {
     /** Transaction kind discriminator. */
     kind: 'TRANSFER' | 'ACCOUNT_ENTRY';
+    /**
+     * What kind of ledger line an `ACCOUNT_ENTRY` is — a fee, an interest
+     * credit, an adjustment, and so on.
+     *
+     * Required when `kind` is `'ACCOUNT_ENTRY'`, ignored for `'TRANSFER'`. The
+     * read model exposes it as non-nullable, so an account entry ingested
+     * without one cannot be rendered.
+     */
+    entryType?: AccountEntryType;
     /** Two-level payment classification: closed category enum + open method string. */
     mode: Record<string, unknown>;
     /** Channel and session context for the transaction. */
@@ -1290,6 +2187,8 @@ export interface TransactionBodyDto {
     reference?: string;
     /** Free-text memo or note. */
     memo?: string;
+    /** Resource tags for this transaction, as catalogue values (slugs) or labels from the `txn.tags` tag catalogue (Settings → Tags). Stored on `transactions.tags`, read by rules as the `txn.tags` set field, and filterable inside aggregate brackets — e.g. `account.txn(24h).sum(amount)[tags IN (top-up)]`. Values not in the catalogue are rejected (HTTP 400). Tags are written at ingest only; status updates leave them unchanged. */
+    tags?: string[];
     /** IDs of related transactions (e.g. funding legs, reversals, fees). Useful when multiple transactions form a single logical transfer. */
     relatedTransactions?: RelatedTransactionDto[];
     /** Open per-transaction key/value bag stored on `transactions.metadata` and exposed to the rules engine as `txn.metadata.{key}`. Each value is either a **bare primitive** (string / number / boolean — coerced to `text` at ingest) or a **typed wrapper** `{ "type": "...", "value": ... }` so the evaluator can run typed comparisons. See spec evaluation/02 §1.M.
@@ -1302,23 +2201,22 @@ export interface TransactionBodyDto {
     metadata?: Record<string, string | number | boolean | MetadataTextWrapperDto | MetadataNumberWrapperDto | MetadataBooleanWrapperDto | MetadataDateWrapperDto | MetadataSetWrapperDto | MetadataCurrencyWrapperDto | MetadataMonetaryWrapperDto>;
 }
 export interface UpdateAccountDto {
-    /** Product ID this account is based on */
-    productId?: string;
     label?: string;
-    /** Currency code (ISO 4217) */
-    currency?: string;
-    bankName?: string;
-    bankSwift?: string;
-    iban?: string;
-    accountNumber?: string;
-    /** Arbitrary key-value properties */
-    customProperties?: Record<string, unknown>;
     /** Override account opening timestamp (ISO 8601). Used by data-loading tools to backfill historical accounts. */
     openedAt?: string;
+    /**
+     * Typed Field write input (Tier A). Merge semantics — supplied keys
+     * overwrite the stored bag, absent keys are preserved. Pass `[]` to clear.
+     * Banking-style values (IBAN, SWIFT, account number, …) live here now,
+     * not as flat columns (Phase 3b).
+     */
+    fields?: TypedFieldValueInput[];
+    /** Untyped escape hatch (Tier C). Stored verbatim. */
+    otherProperties?: UntypedKeyValueInput[];
 }
 export interface UpdateConstantDto {
     /** Constant type. If changed, `value` must be re-supplied in the new shape. */
-    type?: 'scalar' | 'monetary' | 'set' | 'range' | 'text' | 'number' | 'boolean' | 'date' | 'currency';
+    type?: 'scalar' | 'monetary' | 'set' | 'range' | 'text' | 'number' | 'boolean' | 'date' | 'currency' | 'regex';
     /** Payload shape depends on the constant's `type`. Pick the matching variant below. Validated at write time. */
     value?: {
         /** e.g. `"1000000@FIAT:USD"` = $10,000.00. Precision implied by currency: USD=2, JPY=0, BTC=8, ETH=9, USDT/USDC=6. */
@@ -1347,10 +2245,30 @@ export interface UpdateCounterpartyDto {
     institution?: InstitutionDetailsDto;
 }
 /** OpenAPI schema is empty; treated as an opaque key/value bag — narrow on the caller side. */
-export type UpdateCurrencyInput = Record<string, unknown>;
+export interface UpdateCurrencyInput {
+    name?: string;
+    symbol?: string;
+    /** Number of minor-unit decimal places (0–18). */
+    precision?: number;
+    isEnabled?: boolean;
+}
 export interface UpdateDeviceTrustDto {
     trustLevel: 'KNOWN' | 'NEW' | 'SUSPICIOUS';
 }
+export interface MergeDeviceDto {
+    sourceDeviceId: string;
+    reason: string;
+}
+export interface DeviceMergeResponseDto {
+    id: string;
+    organizationId: string;
+    sourceDeviceId: string;
+    targetDeviceId: string;
+    canonicalDeviceId: string;
+    reason: string;
+    mergedBy: Record<string, unknown>;
+    mergedAt: string;
+}
 export interface UpdateEntityDto {
     legalName?: string;
     tradingNames?: string[];
@@ -1359,6 +2277,8 @@ export interface UpdateEntityDto {
     countryOfIncorporation?: string;
     dateOfIncorporation?: string;
     entityType?: string;
+    /** Tax Identification Number (TIN). */
+    taxId?: string;
     /** Parent entity ID for subsidiaries */
     parentEntityId?: string;
     email?: string;
@@ -1384,8 +2304,22 @@ export interface UpdateEventDefinitionDto {
     description?: string;
     /** Event category. */
     category?: string;
-    /** Event properties schema. */
-    properties?: Record<string, unknown>[];
+    /** Event definition status. */
+    status?: 'ACTIVE' | 'DEPRECATED' | 'DRAFT';
+    /**
+     * Resources this event names, each as SUBJECT (what an occurrence is
+     * about) or CONTEXT (what it also references). Omit to accept any
+     * attachable subject and expect no context.
+     */
+    resources?: EventResourceDeclarationDto[];
+    /** Event property schema. Same shape as `TypedFieldDefinition` (including `options` for select types). */
+    properties?: TypedFieldDefinition[];
+    /**
+     * Risk Signals to emit on every valid occurrence of this event. Supplying
+     * the array replaces the declared effects; signals already recorded keep
+     * the weight and half-life snapshotted when they were created.
+     */
+    riskSignalEffects?: RiskSignalEffect[];
 }
 export interface UpdateExpectedActivityDto {
     expectedMonthlyTransactionCount: number;
@@ -1417,6 +2351,8 @@ export interface UpdateIndividualDto {
     countryOfResidence?: string[];
     /** Additional name variants the customer is known by. */
     aliases?: string[];
+    /** Tax Identification Number (TIN). */
+    taxId?: string;
     email?: string;
     phone?: string;
     identificationDocuments?: IdentificationDocumentDto[];
@@ -1480,38 +2416,86 @@ export interface UpdateProductDto {
     /** Product description. */
     description?: string;
     /** Product status. */
-    status?: string;
+    status?: ProductStatus;
+    /** Preferred product classification, governed by the `product.tags` catalogue. */
+    tags?: TagValueInput[];
     /** Supported transaction method IDs. */
     supportedMethodIds?: string[];
-    /** Arbitrary product metadata. */
-    metadata?: Record<string, unknown>;
+    /** Account field template for accounts created from this product. */
+    accountFieldConfig?: TypedFieldDefinition[];
+    /** @deprecated Use `accountFieldConfig`. */
+    typedAccountFieldConfig?: TypedFieldDefinition[];
+    /** Product-level typed bag (Tier B, self-declaring). */
+    fields?: TypedFieldValueInput[];
+    /** Untyped escape hatch (Tier C). */
+    otherProperties?: UntypedKeyValueInput[];
 }
 export interface UpdateRiskRatingDto {
     riskRating: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
     /** Justification for the override */
     justification?: string;
 }
+/** Lifecycle status of a customer (individual or entity). */
+export type CustomerStatus = 'ONBOARDING' | 'IN_REVIEW' | 'ACTIVE' | 'INACTIVE' | 'SUSPENDED' | 'REJECTED';
+export interface UpdateCustomerStatusDto {
+    /** New lifecycle status for the customer. */
+    status: CustomerStatus;
+    /** Audit reason for the status change. */
+    reason?: string;
+}
+export interface UpdateCustomerStatusResponse {
+    customerId: string;
+    status: CustomerStatus;
+    statusReason: string | null;
+    updatedAt: string;
+}
+/** Body for archiving a customer (admin-only, irreversible). */
+export interface ArchiveCustomerDto {
+    /** Audit reason for archiving the customer. */
+    reason?: string;
+}
+export interface ArchiveCustomerResponse {
+    customerId: string;
+    /** When the customer was archived (ISO 8601). */
+    archivedAt: string | null;
+    /** The original (clean) external ID, preserved for audit. The live external ID is freed for reuse. */
+    archivedExternalId: string | null;
+    archivedReason: string | null;
+}
 export interface UpdateRuleDto {
     /** Rule name. */
     name?: string;
     /** Rule description. */
     description?: string;
-    /** Rule subject. */
+    /** Rule subject: 'TRANSACTION' | 'EVENT' | 'CUSTOMER' | 'ALL'. */
     subject?: string;
-    /** Rule trigger. */
+    /**
+     * Rule trigger — see CreateRuleDto.trigger. The post-update
+     * subject/trigger pair is validated, so patching only the trigger must
+     * still be compatible with the rule's existing subject.
+     */
     trigger?: string;
     /** Rule severity. */
     severity?: 'HIGH' | 'MEDIUM' | 'LOW';
-    /** Tags for categorisation. */
-    tags?: string[];
+    /** Tags for categorisation (tag catalogue). */
+    tags?: TagValueInput[];
     /** Rule status. */
     status?: 'DRAFT' | 'ACTIVE' | 'DISABLED';
     /** Condition tree. */
     conditionTree?: Record<string, unknown>;
     /** Actions to execute. */
-    actions?: string[];
+    actions?: RuleAction[];
     /** Window period. */
     windowPeriod?: string;
+    /**
+     * Optional note recorded against the version this edit mints (audit trail).
+     * Ignored if the edit changes no definitional field.
+     */
+    changeNote?: string;
+    /** Product applicability. Pass null or empty products to unscope. */
+    scope?: {
+        products?: string[];
+    } | null;
 }
 export interface UpdateStakeholderDto {
     name?: string;
@@ -1565,6 +2549,8 @@ export interface IngestTransactionResponse {
     matches: IngestTransactionMatch[];
     /** Server-side evaluation time in milliseconds. */
     executionTimeMs: number;
+    /** The stored transaction after resolution and evaluation — the same shape `transactions.get()` returns. */
+    transaction?: TransactionResponseDto;
 }
 /** Async response (202) from POST /v1/transactions when accepted for background processing. */
 export interface IngestTransactionAsyncResponse {
@@ -1572,12 +2558,44 @@ export interface IngestTransactionAsyncResponse {
     id: string;
     async: true;
     status: 'ACCEPTED' | string;
+    /** The stored transaction after resolution; evaluation has not run yet, so flags are not set. */
+    transaction?: TransactionResponseDto;
 }
 export interface IngestEventResponse {
-    /** Database record ID for the ingested event. */
+    /**
+     * Echo of the request `eventId`; the database record ID when the
+     * request carried none.
+     */
     eventId: string;
+    /** Database record ID for the ingested event. */
+    id: string;
     /** Echoed event type. */
     type: string;
+    /**
+     * The Event Definition the type resolved to. `null` means the type has no
+     * Definition: the occurrence is recorded, but nothing described it and no
+     * Risk Signal fired for it — catch a typo here rather than by noticing the
+     * absence of signals days later. A tenant that would rather the request
+     * fail sets the `unknownEventTypes` behaviour setting to `REJECT`.
+     */
+    definitionId: string | null;
+    /**
+     * The resolved primary resource the event was attached to. Echoed back
+     * resolved, so a request that used the legacy `customerId` spelling reads
+     * back as `{ type: 'CUSTOMER', id }`.
+     */
+    resource: EventResourceRef;
+    /**
+     * Ids of the Risk Signals the event definition's `riskSignalEffects`
+     * emitted for this occurrence. Empty when the definition declares none.
+     *
+     * The Event and its signals are written in one transaction, and a replay
+     * echoes the signals the original ingestion produced — the event's
+     * idempotency covers its Risk Signals too.
+     */
+    riskSignalIds: string[];
+    /** Present (true) when this request deduplicated against an already-stored event. */
+    cached?: boolean;
 }
 export interface CursorPaginationQuery {
     cursor?: string;
@@ -1591,6 +2609,10 @@ export interface ListCurrenciesQuery {
 export interface SyncKeyQuery {
     syncKey?: string;
 }
+export interface ListConstantsQuery extends SyncKeyQuery {
+    /** Restrict to product-bound `$account.*` definitions for this product. */
+    productId?: string;
+}
 export interface DeleteConstantQuery {
     force?: boolean;
     reason?: string;
@@ -1599,6 +2621,11 @@ export interface GetCustomerQuery {
     /** If true, treat the path id as an external customer ID. */
     isExternal?: boolean;
 }
+/**
+ * Response DTOs not enumerated in the public OpenAPI schema. The backend
+ * returns these as full objects but the OpenAPI spec does not publish their
+ * shape. Treated as opaque records — narrow on the caller side.
+ */
 export type OpaqueResponse = Record<string, unknown>;
 export type ApiKeyResponseDto = OpaqueResponse;
 export type TokenResponseDto = OpaqueResponse;
@@ -1640,20 +2667,498 @@ export interface PlatformUploadUrlResponseDto {
 /** Response shape for `POST /v1/platform/v1/files/confirm` — typically `{ fileId, downloadUrl, ... }`. */
 export type PlatformConfirmUploadResponseDto = OpaqueResponse;
 export type StakeholderResponseDto = OpaqueResponse;
-export type DeviceResponseDto = OpaqueResponse;
-export type DeviceSummaryDto = OpaqueResponse;
-export type RiskQuestionnaireResponseDto = OpaqueResponse;
+export interface DevicePublicBrowserDetailsDto {
+    browserName: string;
+    browserMajorVersion: string;
+    browserFullVersion: string;
+    os: 'WINDOWS' | 'MACOS' | 'LINUX' | 'IOS' | 'ANDROID' | 'OTHER';
+    osVersion: string;
+    device: 'DESKTOP' | 'MOBILE' | 'TABLET' | 'UNKNOWN';
+    userAgent: string;
+}
+export interface DeviceGeolocationDto {
+    country: string;
+    city: string;
+    /** The observed point. Same numbers as `latitude`/`longitude`, kept paired. */
+    coordinates: CoordinatesDto;
+    latitude: number;
+    longitude: number;
+    timezone: string;
+    accuracyRadius: number;
+    continent?: string;
+    postalCode?: string;
+}
+export interface DeviceVpnDetectionMethodsDto {
+    timezoneMismatch: boolean;
+    publicVPN: boolean;
+    auxiliaryMobile: boolean;
+    relay: boolean;
+}
+export interface DeviceVpnDetectionDto {
+    result: boolean;
+    confidence: number;
+    originTimezone: string;
+    originCountry: string;
+    methods: DeviceVpnDetectionMethodsDto;
+}
+export interface DeviceIpSessionDto {
+    geolocation: DeviceGeolocationDto;
+    vpn: DeviceVpnDetectionDto;
+    isProxy: boolean;
+    isTor: boolean;
+    incognito: boolean;
+    seenAt: string;
+}
+/**
+ * A customer linked to a device.
+ *
+ * The dates are the link's own, not the device's: on a device used by more than
+ * one customer they say who had it when.
+ */
+export interface DeviceCustomerLinkDto {
+    customerId: string;
+    name?: string | null;
+    /** INDIVIDUAL or ENTITY. */
+    type?: string | null;
+    status?: string | null;
+    riskRating?: string | null;
+    externalId?: string | null;
+    firstSeenAt: string;
+    lastSeenAt: string;
+}
+/** Safe canonical Device response. It never contains raw fingerprint or IP identity values. */
+export interface DeviceResponseDto {
+    id: string;
+    requestId?: string | null;
+    browserDetails: DevicePublicBrowserDetailsDto;
+    ipSessions: DeviceIpSessionDto[];
+    botProbability: number;
+    confidence: number;
+    trustLevel: 'KNOWN' | 'NEW' | 'SUSPICIOUS';
+    firstSeenAt: string;
+    lastSeenAt: string;
+    /**
+     * Every customer linked to this device. Returned by `GET /devices/{id}`;
+     * absent on endpoints that list devices in bulk.
+     */
+    customers?: DeviceCustomerLinkDto[];
+}
+/** @deprecated Customer Device endpoints now return the canonical Device response. */
+export type DeviceSummaryDto = DeviceResponseDto;
+export type CustomerRiskAssessmentResponseDto = OpaqueResponse;
 export type RiskAssessmentResponseDto = OpaqueResponse;
 export type ExpectedActivityResponseDto = OpaqueResponse;
 export type ScreeningResultDto = OpaqueResponse;
 export type ConfirmedMatchDto = OpaqueResponse;
-export type RuleResponseDto = OpaqueResponse;
+/**
+ * The screening provider's automated false-positive assessment of a weak
+ * match — why the match is, or is not, the customer, decided from date of
+ * birth, geography, role timeline and entity kind rather than from the name.
+ *
+ * Present only where the provider ran it: the customer record carried
+ * attributes to compare against. Absence is not an implied `retain`.
+ *
+ * A `decision` of `discard` sets the match's `disposition` to
+ * `FALSE_POSITIVE` with no human involved — so whenever you see a disposition
+ * none of your users set, `rationale` is the reason.
+ */
+export interface MatchDisambiguationDto {
+    /**
+     * `discard` where an attribute positively contradicts identity — this is
+     * what auto-dispositions the match. `retain` is the default and is not a
+     * confirmation, only the absence of grounds to eliminate.
+     */
+    decision?: 'discard' | 'retain';
+    /**
+     * How to queue the match. `likely_false_positive` means the evidence
+     * pointed that way but did not clear the provider's confidence floor —
+     * deprioritise, do not dismiss.
+     */
+    dispositionHint?: 'false_positive' | 'likely_false_positive' | 'needs_review' | 'possible_match';
+    /** Confidence in the verdict. A `discard` is only ever emitted at `high`. */
+    confidence?: 'high' | 'medium' | 'low';
+    /**
+     * `hard` for a date-of-birth contradiction, an entity-type mismatch, an
+     * implausible age for the role timeline, or a nationality conflict;
+     * `soft` for jurisdiction or residence geography and gender. A sanctions
+     * listing is never discarded on soft evidence alone.
+     */
+    contradictionStrength?: 'hard' | 'soft' | 'none';
+    /**
+     * The rules that fired, from the provider's closed vocabulary — e.g.
+     * `DOB_CONTRADICTION`, `AGE_IMPLAUSIBLE_FOR_ROLE_TIMELINE`,
+     * `ENTITY_TYPE_MISMATCH`, `NATIONALITY_CONFLICT`, `INSUFFICIENT_DATA_TO_ELIMINATE`.
+     */
+    reasonCodes?: string[];
+    /**
+     * One to three sentences naming the field values compared — the audit
+     * answer to "why was this match eliminated".
+     */
+    rationale?: string;
+}
+/**
+ * A single screening match for a customer, read live with its current
+ * disposition. Returned by `GET /v1/customers/{customerId}/screening-results`
+ * — the full true-positive (`CONFIRMED`) / false-positive (`FALSE_POSITIVE`) /
+ * unresolved (`PENDING`) picture. Confirmed and false-positive matches persist
+ * across re-screens.
+ */
+export interface ScreeningMatchResultDto {
+    /** Match record ID. */
+    id: string;
+    matchType: 'WATCHLIST' | 'HIGH_RISK' | 'CUSTOM_LIST';
+    disposition: 'PENDING' | 'CONFIRMED' | 'FALSE_POSITIVE';
+    /** Matched entity name. */
+    matchedName: string;
+    /** List/source label, e.g. `OFAC SDN` (high-risk → `High Risk`, custom list → list name). */
+    source?: string;
+    /** For CUSTOM_LIST matches: the list's current tags. */
+    listTags?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /**
+     * Short role/bio line. Populated for `HIGH_RISK` (PEP) matches when the
+     * provider supplies one; always present and `""` otherwise — never omitted
+     * or null, so it can be read without a presence check.
+     */
+    tagline: string;
+    /** General free-text profile summary (composed by the screening provider). */
+    summary?: string;
+    /** Provider match confidence, 0–1. */
+    matchConfidence?: number;
+    /** ISO-8601 timestamp the disposition was set. */
+    resolvedAt?: string;
+    /** Who set the disposition. */
+    resolvedBy?: Record<string, unknown>;
+    /**
+     * The provider's automated false-positive assessment, where it ran. When
+     * `disposition` is `FALSE_POSITIVE` and `resolvedBy` is the screening
+     * service rather than one of your users, this is why.
+     */
+    disambiguation?: MatchDisambiguationDto;
+}
+/**
+ * A single screening run from
+ * `GET /v1/customers/{customerId}/screening-history[/latest]`. One entry per
+ * time the customer was screened (initial, ongoing, manual, event-triggered).
+ */
+export interface ScreeningHistoryEntryDto {
+    /** Screening log entry ID. */
+    id: string;
+    customerId: string;
+    customerName: string;
+    /** What triggered the screening, e.g. `INITIAL` | `ONGOING` | `MANUAL` | `EVENT_TRIGGERED`. */
+    screeningType: string;
+    /** Run status, e.g. `COMPLETED` | `PENDING` | `FAILED`. */
+    status: string;
+    /** Total matches surfaced across all sources. */
+    matchesFound: number;
+    /** Number of alerts raised from this screening. */
+    alertsGenerated: number;
+    /** Watchlist matches suppressed by whitelisting/dispositions. */
+    suppressedWatchlistCount: number;
+    /** High-risk/PEP matches suppressed by whitelisting/dispositions. */
+    suppressedHighRiskCount: number;
+    /** Custom-list matches suppressed by prior false-positive dispositions. */
+    suppressedCustomListCount: number;
+    /** Which checks were run, e.g. `['WATCHLIST', 'HIGH_RISK', 'CUSTOM_LIST']`. */
+    checksRun: string[];
+    /** ISO-8601 timestamp the screening was initiated. */
+    createdAt: string;
+    /** ISO-8601 timestamp the screening finished, if completed. */
+    completedAt?: string;
+    [key: string]: unknown;
+}
+/**
+ * Options for `individuals.create` / `entities.create`.
+ */
+export interface CreateCustomerOptions {
+    /**
+     * How the INITIAL screening runs. `async` (default) queues it and the
+     * call returns at once — poll `customers.screening.history` /
+     * `listResults`, or listen for the screening webhooks. `sync` runs it
+     * before responding and returns the run and its matches under
+     * `screening` on the response.
+     */
+    screening?: 'async' | 'sync';
+}
+/**
+ * Outcome of the INITIAL screening run performed inline by
+ * `individuals.create(input, { screening: 'sync' })` and the entities twin.
+ */
+export interface InitialScreeningResultDto {
+    /** Screening log entry ID — the same id `screening.history` returns. */
+    id: string;
+    /** Always `INITIAL` for a create-time run. */
+    screeningType: string;
+    /**
+     * `COMPLETED` when every configured check ran. `FAILED` when no provider
+     * is configured or every provider failed — the customer still exists;
+     * rerun with `customers.screening.trigger(customerId)`.
+     */
+    status: 'COMPLETED' | 'FAILED';
+    /** Why the run FAILED, e.g. `no_providers_configured`, `all_providers_failed`. */
+    statusReason?: string;
+    /** Which checks actually ran, e.g. `['WATCHLIST', 'HIGH_RISK', 'CUSTOM_LIST']`. */
+    checksRun: string[];
+    /** Total matches surfaced across all sources, including auto-dismissed ones. */
+    matchesFound: number;
+    /** Number of alerts raised from this screening (0 or 1). */
+    alertsGenerated: number;
+    /** The screening alert holding these matches, when any were found. Absent on a clear run. */
+    alertId?: string;
+    /**
+     * Matches the provider's attribute assessment eliminated as false
+     * positives. Still counted in `matchesFound` and listed in `matches`
+     * with disposition `FALSE_POSITIVE`.
+     */
+    autoDismissedMatchCount: number;
+    /** True when every match was auto-dismissed and the alert closed itself. */
+    alertAutoClosed: boolean;
+    /** ISO-8601 timestamp the screening was initiated. */
+    createdAt: string;
+    /** ISO-8601 timestamp the screening finished. */
+    completedAt?: string;
+    /**
+     * Every match this run surfaced, with its disposition — the same shape
+     * as `customers.screening.listResults`. Empty on a clear or FAILED run.
+     */
+    matches: ScreeningMatchResultDto[];
+}
+/**
+ * `individuals.create` response. Identical to `IndividualResponseDto` unless
+ * the call used `{ screening: 'sync' }`, in which case `screening` carries
+ * the INITIAL run's outcome and matches.
+ */
+export interface IndividualCreatedResponseDto extends IndividualResponseDto {
+    screening?: InitialScreeningResultDto;
+}
+/** `entities.create` response — see `IndividualCreatedResponseDto`. */
+export interface EntityCreatedResponseDto extends EntityResponseDto {
+    screening?: InitialScreeningResultDto;
+}
+/** KYC verification status, mirroring the backend `KYCVerificationStatus` enum. */
+export type KycVerificationStatus = 'VERIFIED' | 'FAILED' | 'PENDING' | 'EXPIRED';
+/**
+ * Result of starting a KYC session
+ * (`POST /v1/customers/{customerId}/kyc/sessions`). Hand `sessionUrl` to the
+ * customer to complete verification.
+ */
+export interface StartKycSessionResponseDto {
+    /** Local KYC session id. */
+    sessionId: string;
+    /** The provider's own session id. */
+    providerSessionId: string;
+    /** Hosted URL the customer visits to complete verification. */
+    sessionUrl: string;
+    status: KycVerificationStatus;
+    /** ISO-8601 expiry, or null. */
+    expiresAt?: string | null;
+    /** ISO-8601 creation time. */
+    createdAt: string;
+}
+/**
+ * A persisted KYC session, returned by
+ * `GET /v1/customers/{customerId}/kyc/sessions` and the refresh endpoint.
+ */
+export interface KycSessionDto {
+    id: string;
+    customerId: string;
+    status: KycVerificationStatus;
+    /** Which provider ran the session, e.g. `dossiers`. */
+    provider?: string | null;
+    /** Hosted URL the customer visits to complete verification. */
+    sessionUrl?: string | null;
+    /** Per-step verification progress (provider-normalized). */
+    steps: Record<string, unknown>[];
+    /** Verified identity documents (provider-normalized). */
+    documents: Record<string, unknown>[];
+    overallResult?: string | null;
+    /** ISO-8601 expiry, or null. */
+    expiresAt?: string | null;
+    /** ISO-8601 creation time. */
+    createdAt: string;
+    /** ISO-8601 completion time, if completed. */
+    completedAt?: string | null;
+    [key: string]: unknown;
+}
+/**
+ * A saved rule as returned by the Config — Rules API
+ * (`POST`/`GET`/`PATCH /v1/config/rules[/:id]`). Mirrors the backend
+ * `RULE_SCHEMA`.
+ */
+export interface RuleResponseDto {
+    id: string;
+    name: string;
+    description?: string;
+    /** Rule subject: 'TRANSACTION' | 'EVENT' | 'CUSTOMER' | 'ALL'. */
+    subject: string;
+    /** Rule trigger — see CreateRuleDto.trigger. */
+    trigger: string;
+    severity: 'HIGH' | 'MEDIUM' | 'LOW';
+    status: 'DRAFT' | 'ACTIVE' | 'DISABLED';
+    tags: string[];
+    /** Condition tree (AND/OR logic with leaf conditions). */
+    conditionTree: Record<string, unknown>;
+    /** Actions to execute when the rule triggers. */
+    actions: Record<string, unknown>[];
+    /** Window period for aggregate conditions. */
+    windowPeriod?: string;
+    /** Sync key for config-as-code management. */
+    syncKey?: string;
+    isSystemRule: boolean;
+    /** Product applicability. Null / empty products = unscoped. */
+    scope?: {
+        products?: string[];
+    } | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * A single immutable rule version snapshot from
+ * GET /v1/config/rules/{id}/versions[/{version}]. Carries the definitional
+ * fields plus audit metadata (version, changeKind, changeNote, actor, createdAt).
+ */
+export type RuleVersionResponseDto = OpaqueResponse;
+/** Response from GET /v1/config/rules/:id/analytics — disposition breakdown + precision (#42). */
+export type RuleAnalyticsResponseDto = OpaqueResponse;
+/** Input for POST /v1/config/rules/backtest (spec v0 rules §11 + synthetic source). */
+export interface SimulateRulesDto {
+    /** Default HISTORICAL. */
+    source?: 'HISTORICAL' | 'SYNTHETIC';
+    /** Existing rules to simulate; conditionTreeOverride A/B-tests changes without saving. */
+    rules?: Array<{
+        ruleId: string;
+        conditionTreeOverride?: Record<string, unknown>;
+    }>;
+    /** Inline unsaved rules — evaluated only for this run. */
+    adHocRules?: Array<{
+        name: string;
+        severity: string;
+        conditionTree: Record<string, unknown>;
+    }>;
+    period: {
+        from: string;
+        to: string;
+    };
+    filters?: {
+        customerIds?: string[];
+        accountIds?: string[];
+        modeCategories?: string[];
+        minAmountMinor?: number;
+    };
+    /** Cap on transactions evaluated (default 5000, max 100000). */
+    maxTransactions?: number;
+    /** Generator parameters (SYNTHETIC source only). */
+    synthetic?: {
+        count?: number;
+        customerIds?: string[];
+        minAmountMinor?: number;
+        maxAmountMinor?: number;
+        modeCategories?: string[];
+        directions?: string[];
+        /**
+         * Event occurrences to generate across the period (default one per 20
+         * transactions, max 500). Events that typically precede activity pull a
+         * run of transactions in behind them.
+         */
+        eventCount?: number;
+        /** Event Definition names to draw from. Default: the org's active definitions. */
+        eventTypes?: string[];
+    };
+    includeMatches?: boolean;
+}
+/** Dry-run simulation report — nothing was persisted, no actions executed. */
+export interface SimulationReportDto {
+    simulationId: string;
+    source: 'HISTORICAL' | 'SYNTHETIC';
+    dryRun: true;
+    periodFrom: string;
+    periodTo: string;
+    transactionsEvaluated: number;
+    totalMatches: number;
+    executionTimeMs: number;
+    /** Tenant base currency (TYPE:CODE) that per-rule matched volumes are denominated in. */
+    baseCurrency: string;
+    byRule: Array<{
+        ruleId: string;
+        ruleName: string;
+        severity: string;
+        matchCount: number;
+        distinctCustomers: number;
+        distinctAccounts: number;
+        totalMatchedVolumeMinor: number;
+        matches: Array<{
+            transactionId: string;
+            /** Internal transactions.id — null for synthetic rows (nothing stored). */
+            transactionDbId: string | null;
+            customerId: string | null;
+            bookedAt: string;
+            baseAmountMinor: number | null;
+            /** Currency of `baseAmountMinor` (TYPE:CODE) — pair these when formatting. */
+            baseCurrency: string | null;
+            /** Minor-unit precision of `baseCurrency`. */
+            basePrecision: number | null;
+            originCurrency: string | null;
+            flagReasons: string[];
+            wouldHaveExecuted: Array<Record<string, unknown>>;
+            /** Full transaction snapshot (mode, status, monetary legs, parties, metadata). */
+            transactionDetail: Record<string, unknown>;
+        }>;
+    }>;
+    /** Synthetic Events generated for the period, and the activity behind them. */
+    syntheticEvents: Array<{
+        /** Event Definition name the occurrences were generated from. */
+        type: string;
+        count: number;
+        /** Synthetic transactions clustered in the window behind these events. */
+        followedByTransactions: number;
+    }>;
+    coverageGaps: string[];
+    warnings: string[];
+}
 export type ConstantResponseDto = OpaqueResponse;
-export type ProductResponseDto = OpaqueResponse;
-export type CurrencyResponseDto = OpaqueResponse;
+export interface ProductResponseDto {
+    id: string;
+    externalId: string;
+    name: string;
+    description?: string | null;
+    category: AccountCategory;
+    tags: TagValue[];
+    /** @deprecated Use `tags`. Retained for API compatibility. */
+    baseType: AccountType;
+    status: ProductStatus;
+    defaultCurrency: string;
+    /** @deprecated Use `tags` when product classification is needed. */
+    country?: string | null;
+    supportedMethodIds: string[];
+    accountFieldConfig?: TypedFieldDefinition[];
+    /** @deprecated Use `accountFieldConfig`. */
+    typedAccountFieldConfig?: TypedFieldDefinition[];
+    fields?: TypedFieldValueInput[];
+    otherProperties?: UntypedKeyValueInput[];
+    syncKey?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CurrencyResponseDto {
+    id: string;
+    type: CurrencyType;
+    code: string;
+    /** Composite identifier in TYPE:CODE form (e.g. FIAT:USD). */
+    currencyId: string;
+    /** Number of minor-unit decimal places. */
+    precision: number;
+    name: string;
+    symbol: string;
+    isEnabled: boolean;
+    isCustom: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
 export type EventDefinitionResponseDto = OpaqueResponse;
 export type WebhookResponseDto = OpaqueResponse;
-export type SyncExportDto = OpaqueResponse;
 export interface SyncSnapshotActor {
     userId: string;
     name: string;
@@ -1677,9 +3182,1132 @@ export interface SyncDriftDto {
 export interface CreateSyncSnapshotInput {
     note?: string;
 }
-export type ResetConfigResponseDto = OpaqueResponse;
-export type PushExchangeRatesResponseDto = OpaqueResponse;
-export type BulkCurrencyStatusResponseDto = OpaqueResponse;
-/** Bulk update body for `PATCH /v1/config/currencies/bulk-status` (schema undocumented). */
-export type BulkCurrencyStatusInput = Record<string, unknown>;
+export interface SyncConfig {
+    $schema?: string;
+    version: number;
+    tenant: {
+        organizationId: string;
+        baseCurrency?: string;
+        displayName?: string;
+    };
+    productDefinitions?: Record<string, SyncProductDefinitionConfig | string>;
+    constants?: Record<string, SyncConstantConfig>;
+    eventDefinitions?: Record<string, SyncEventDefConfig>;
+    webhooks?: Record<string, SyncWebhookConfig>;
+    rules?: Record<string, SyncRuleConfig>;
+    /** Keyed by TYPE:CODE (e.g. "FIAT:USD", "CRYPTO:BTC"). */
+    currencies?: Record<string, SyncCurrencyConfig>;
+    /**
+     * Tag catalogue vocabulary — keyed by `<fieldKey>:<value>` (e.g.
+     * "rule.tags:high-risk"). Unlike the other sections, an ABSENT section is
+     * "unmanaged", not "empty": omitting it never retires live tags.
+     */
+    tagCatalogue?: Record<string, SyncTagCatalogueEntryConfig>;
+    /**
+     * Tag groups — keyed `<fieldKey>:<groupValue>` (e.g.
+     * "customer.tags:primary-branch"). Same "absent means unmanaged" rule as
+     * `tagCatalogue`, and applied BEFORE it so a namespaced tag can resolve
+     * the group that owns it.
+     */
+    tagGroups?: Record<string, SyncTagGroupConfig>;
+    /**
+     * @deprecated Retired. Assignment policies were replaced by alert
+     * workflows; the server rejects a bundle whose `assignmentPolicies`
+     * section is non-empty. Configure stage assignment through
+     * `config.alertWorkflows` instead.
+     */
+    assignmentPolicies?: Record<string, SyncAssignmentPolicyConfig>;
+    /**
+     * Tenant-wide attempt retention/coverage. Absent means unmanaged and
+     * supplied fields update only those values.
+     */
+    behaviorSettings?: SyncBehaviorSettingsConfig;
+    customerFieldPolicy?: Record<string, SyncCustomerFieldPolicyConfig>;
+    accountStatusPolicy?: SyncAccountStatusPolicyConfig;
+}
+export interface SyncBehaviorSettingsConfig {
+    attemptRetentionDays?: number;
+    attemptCoverage?: 'ALL' | 'SELECTIVE';
+    unknownEventTypes?: 'ACCEPT' | 'REJECT';
+}
+/**
+ * Assignment policy (screening-alert auto-assignment routing). Targets are
+ * org-local better-auth user ids / domain team uuids, validated against
+ * membership on apply.
+ *
+ * @deprecated Retired with `SyncConfig.assignmentPolicies`; the server
+ * rejects a non-empty section. Use `config.alertWorkflows`.
+ */
+export interface SyncAssignmentPolicyConfig {
+    name: string;
+    description?: string;
+    /** Default true. */
+    enabled?: boolean;
+    /** Evaluation order, ascending. First match wins. Must be unique per config. */
+    priority: number;
+    /** Qualifier tree; `{logic:'AND', conditions:[]}` = catch-all. */
+    conditionTree: AssignmentPolicyConditionGroup;
+    /** STATIC (default): fixed targets. TAG_MAP: route by `tagMap`. */
+    targetMode?: AssignmentTargetMode;
+    tagMap?: AssignmentPolicyTagMap;
+    assignToUserIds?: string[];
+    assignToTeamIds?: string[];
+}
+export interface SyncTagCatalogueEntryConfig {
+    /** Human-readable display label. The value slug lives in the section key. */
+    label: string;
+    /** Fixed palette token (e.g. `neutral`, `red`, `blue`), not a hex value. */
+    color?: string;
+    description?: string;
+    /**
+     * Owning group's slug, unqualified (e.g. `primary-branch`). When set, the
+     * section key must already carry the namespace:
+     * `<fieldKey>:<group>:<tag>`.
+     */
+    group?: string;
+}
+export interface SyncTagGroupConfig {
+    /** Human-readable display label. The namespace slug lives in the section key. */
+    label: string;
+    description?: string;
+    color?: string;
+    /** `SINGLE` allows one member tag per record. Defaults to `MULTI`. */
+    cardinality?: TagGroupCardinality;
+    sortOrder?: number;
+}
+export interface SyncCurrencyConfig {
+    name: string;
+    symbol?: string;
+    precision: number;
+    enabled?: boolean;
+    custom?: boolean;
+}
+export interface SyncConstantConfig {
+    type: 'scalar' | 'monetary' | 'set' | 'range' | 'text' | 'number' | 'boolean' | 'date' | 'currency' | 'regex';
+    description: string;
+    values?: string[];
+    value?: string | number | boolean | null;
+    min?: number;
+    max?: number;
+}
+export interface SyncProductDefinitionConfig {
+    name: string;
+    description?: string;
+    category: string;
+    /** Plain tag labels governed by the `product.tags` catalogue. */
+    tags?: string[];
+    /** @deprecated Use `tags`. Omitted values are persisted as `OTHER`. */
+    baseType?: string;
+    defaultCurrency: string;
+    /** @deprecated Use `tags` when product classification is needed. */
+    country?: string;
+    supportedMethods: string[];
+    /** Account field template inherited by accounts created from this product. */
+    accountFieldConfig?: TypedFieldDefinition[];
+    metadata?: Record<string, unknown>;
+}
+export interface SyncEventDefConfig {
+    name: string;
+    description: string;
+    subject: 'CUSTOMER' | 'ACCOUNT' | 'TRANSACTION';
+}
+export interface SyncWebhookConfig {
+    description: string;
+    url: string;
+    headers?: Record<string, string>;
+    events: string[];
+}
+export interface SyncRuleConfig {
+    name: string;
+    description: string;
+    subject: string;
+    trigger: string;
+    severity: 'HIGH' | 'MEDIUM' | 'LOW';
+    tags?: string[];
+    conditionTree: unknown;
+    actions?: RuleAction[];
+    initialStatus?: 'DRAFT' | 'ACTIVE' | 'DISABLED';
+    status?: 'DRAFT' | 'ACTIVE' | 'DISABLED';
+}
+export interface SyncCustomerFieldPolicyConfig {
+    source: string;
+    syncTrigger: string;
+    usedBy: string[];
+}
+export interface SyncAccountStatusPolicyConfig {
+    statuses: string[];
+    dormancyThresholdDays?: number;
+    dormancyStrategy?: 'MANUAL' | 'AUTO';
+    usedBy?: Record<string, string[]>;
+}
+/** Request body for `validate` / `plan` / `apply`. */
+export interface SyncConfigBody {
+    config: SyncConfig;
+}
+export type SyncDiffOpType = 'create' | 'update' | 'destroy' | 'archive' | 'tombstone';
+export interface SyncDiffOp {
+    type: SyncDiffOpType;
+    key: string;
+    config?: unknown;
+    changes?: string[];
+}
+export interface SyncImmutableViolation {
+    section: string;
+    key: string;
+    field: string;
+    liveValue: unknown;
+    configValue: unknown;
+}
+export interface SyncPlan {
+    products: SyncDiffOp[];
+    constants: SyncDiffOp[];
+    eventDefs: SyncDiffOp[];
+    webhooks: SyncDiffOp[];
+    rules: SyncDiffOp[];
+    currencies: SyncDiffOp[];
+    tagGroups: SyncDiffOp[];
+    tagCatalogue: SyncDiffOp[];
+    assignmentPolicies: SyncDiffOp[];
+    behaviorSettings: SyncDiffOp[];
+    immutableViolations: SyncImmutableViolation[];
+}
+/** `POST /v1/config/sync/validate` response. */
+export interface SyncValidationResult {
+    errors: string[];
+    warnings: string[];
+}
+/** `POST /v1/config/sync/plan` response (validation + advisory diff). */
+export interface SyncPlanResult extends SyncValidationResult {
+    plan: SyncPlan;
+}
+export interface SyncApplyResultItem {
+    section: string;
+    key: string;
+    type: SyncDiffOpType;
+    status: 'applied' | 'failed';
+    error?: string;
+}
+/** `POST /v1/config/sync/apply` response. */
+export interface SyncApplyResult {
+    succeeded: number;
+    failed: number;
+    results: SyncApplyResultItem[];
+    immutableViolations: SyncImmutableViolation[];
+}
+export interface SyncExportQuery {
+    /** Include rows without a sync key (keyed by natural id). Used by import/pull. */
+    includeUnsynced?: boolean;
+}
+export type ResetConfigResponseDto = OpaqueResponse;
+export type PushExchangeRatesResponseDto = OpaqueResponse;
+export interface BulkCurrencyStatusResponseDto {
+    updatedCount: number;
+}
+/** Bulk update body for `PATCH /v1/config/currencies/bulk-status`. */
+export interface BulkCurrencyStatusInput {
+    ids: string[];
+    enabled: boolean;
+}
+/** Catalogue-governed tag: slugified `value` + human-readable `label`. */
+export interface CustomListTagValue {
+    value: string;
+    label: string;
+}
+/** Offset pagination meta returned by the custom-lists list endpoints. */
+export interface CustomListPageMeta {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+/**
+ * A tenant-managed screening list. Enabled LIVE lists are checked by every
+ * screening run (initial, ongoing, manual, ad-hoc search) alongside external
+ * providers; the list's tags are shown against every match it produces.
+ */
+export interface CustomScreeningListDto {
+    id: string;
+    name: string;
+    description?: string | null;
+    /** Disabled lists are skipped by screening but stay editable. */
+    enabled: boolean;
+    tags: CustomListTagValue[];
+    entryCount: number;
+    /** `LIVE` | `ARCHIVED`. Archived lists are read-only and never screened. */
+    lifecycle: string;
+    archivedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CustomListEntryDto {
+    id: string;
+    listId: string;
+    name: string;
+    entryType: 'INDIVIDUAL' | 'ENTITY';
+    aliases: string[];
+    /** YYYY-MM-DD. */
+    dateOfBirth?: string | null;
+    /** ISO 3166-1 alpha-3 country code. */
+    country?: string | null;
+    idNumber?: string | null;
+    notes?: string | null;
+    /** Caller identifier; bulk imports upsert rows carrying the same externalRef. */
+    externalRef?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateCustomScreeningListInput {
+    name: string;
+    description?: string;
+    /** Defaults to true. */
+    enabled?: boolean;
+    tags?: CustomListTagValue[];
+}
+export interface UpdateCustomScreeningListInput {
+    name?: string;
+    description?: string;
+    enabled?: boolean;
+    tags?: CustomListTagValue[];
+}
+export interface CustomListEntryInput {
+    name: string;
+    /** Defaults to INDIVIDUAL. */
+    entryType?: 'INDIVIDUAL' | 'ENTITY';
+    aliases?: string[];
+    /** YYYY-MM-DD. */
+    dateOfBirth?: string;
+    /** ISO 3166-1 alpha-3 country code. */
+    country?: string;
+    idNumber?: string;
+    notes?: string;
+    externalRef?: string;
+}
+export type UpdateCustomListEntryInput = Partial<CustomListEntryInput>;
+/** One rejected row from a bulk import, with the zero-based batch index. */
+export interface BulkCustomListImportRejectedRow {
+    index: number;
+    reason: string;
+    name?: string | null;
+}
+/**
+ * Result of a bulk entry import. The request succeeds even with rejections —
+ * invalid rows are reported per-row instead of failing the batch.
+ */
+export interface BulkCustomListImportResultDto {
+    createdCount: number;
+    updatedCount: number;
+    rejectedCount: number;
+    rejected: BulkCustomListImportRejectedRow[];
+}
+export interface CustomScreeningListListResponse {
+    data: CustomScreeningListDto[];
+    meta: CustomListPageMeta;
+}
+export interface CustomListEntryListResponse {
+    data: CustomListEntryDto[];
+    meta: CustomListPageMeta;
+}
+export interface AssignmentPolicyConditionLeaf {
+    /** Qualifier field key (e.g. `customer.riskRating`, `screening.type`). */
+    field: string;
+    /** Operator from the rules-engine matrix (e.g. `=`, `IN`, `CONTAINS_ANY`, `>`). */
+    operator: string;
+    /** Comparison value. Omitted for null-aware operators (IS_NULL, IS_EMPTY, …). */
+    value?: string;
+    /** Result when the field resolves null under a non-null-aware operator. Default 'FALSE'. */
+    whenMissing?: 'TRUE' | 'FALSE';
+}
+export interface AssignmentPolicyConditionGroup {
+    logic: 'AND' | 'OR' | 'NOT';
+    conditions: (AssignmentPolicyConditionLeaf | AssignmentPolicyConditionGroup)[];
+}
+export type AssignmentTargetMode = 'STATIC' | 'TAG_MAP';
+export interface AssignmentPolicyTagMapEntry {
+    /** Catalogue value slug this entry routes (e.g. "branch-colombo-01"). */
+    tag: string;
+    assignToUserIds?: string[];
+    assignToTeamIds?: string[];
+}
+/**
+ * TAG_MAP routing table: routes by the customer's tag values (branch
+ * workflow — one policy covers any number of branch→team mappings).
+ * Entries are ordered; for a customer carrying several mapped values the
+ * FIRST matching entry wins. No entry matching → the policy does not match
+ * and evaluation falls through to the next one.
+ */
+/** @deprecated Superseded by {@link AssignmentRouting}, which supports several blocks per policy. */
+export interface AssignmentPolicyTagMap {
+    field: 'customer.tags' | 'customer.activeRiskTags' | 'customer.country';
+    /**
+     * Tag group whose membership this table routes, e.g. `primary-branch`.
+     * When set, every entry's `tag` must be a member of that group — that is,
+     * namespaced as `primary-branch:…` — and the server rejects the write
+     * otherwise. Not consulted at match time; it exists so a row that could
+     * never match is caught on save instead of failing silently forever.
+     *
+     * Null / omitted for a table over ungrouped tags, and required to be null
+     * for `customer.country`, which has no tag catalogue.
+     */
+    groupValue?: string | null;
+    entries: AssignmentPolicyTagMapEntry[];
+}
+/**
+ * How a policy resolves its targets, when not the fixed
+ * `assignToUserIds` / `assignToTeamIds`. Exactly ONE of these — anything more
+ * (ordering, cross-field matching) is expressed as additional policies with
+ * their own qualifiers, which is what the policy list already does.
+ *
+ * Supersedes {@link AssignmentPolicyTagMap}. A policy written before this
+ * existed is served here in the current shape, so clients read one thing.
+ */
+export type AssignmentRouting = {
+    /**
+     * Route to whoever is standing-assigned the customer. Carries no
+     * targets of its own — they come from the customer record, so this
+     * can replace a per-branch routing table entirely.
+     *
+     * Does NOT match an unassigned customer: the alert falls through to
+     * the next policy.
+     */
+    kind: 'CUSTOMER_ASSIGNEE';
+    /** Which side of the assignment to use. Default BOTH. */
+    use?: 'BOTH' | 'TEAMS' | 'USERS' | null;
+} | {
+    /** Look the customer up in one tag group's table; first match wins. */
+    kind: 'TAG_GROUP';
+    field: 'customer.tags' | 'customer.activeRiskTags' | 'customer.country';
+    /**
+     * Tag group whose membership this table routes. Every entry must be a
+     * member (`primary-branch:…`), or the write is rejected. Null routes
+     * ungrouped values, or country, which has no catalogue.
+     */
+    groupValue?: string | null;
+    entries: AssignmentPolicyTagMapEntry[];
+};
+export interface AssignmentPolicyResponseDto {
+    id: string;
+    name: string;
+    description: string | null;
+    enabled: boolean;
+    /** Evaluation order, ascending. First match wins. */
+    priority: number;
+    /** Qualifier tree. `{logic:'AND', conditions:[]}` = catch-all. */
+    conditionTree: AssignmentPolicyConditionGroup;
+    /** STATIC: fixed targets. TAG_MAP: routed via `routing`. */
+    targetMode: AssignmentTargetMode;
+    /** @deprecated Read `routing`. Null on anything saved since blocks landed. */
+    tagMap: AssignmentPolicyTagMap | null;
+    /** TAG_MAP: the ordered routing blocks. Legacy rows are served as one block. */
+    routing: AssignmentRouting | null;
+    assignToUserIds: string[];
+    assignToTeamIds: string[];
+    syncKey: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateAssignmentPolicyDto {
+    name: string;
+    description?: string | null;
+    /** Default true. */
+    enabled?: boolean;
+    /** Omitted = catch-all. */
+    conditionTree?: AssignmentPolicyConditionGroup;
+    /** Default STATIC. TAG_MAP requires `routing` and ignores the static targets. */
+    targetMode?: AssignmentTargetMode;
+    routing?: AssignmentRouting | null;
+    /** STATIC mode: at least one user or team target is required. */
+    assignToUserIds?: string[];
+    assignToTeamIds?: string[];
+    syncKey?: string | null;
+}
+export interface UpdateAssignmentPolicyDto {
+    name?: string;
+    description?: string | null;
+    enabled?: boolean;
+    conditionTree?: AssignmentPolicyConditionGroup;
+    targetMode?: AssignmentTargetMode;
+    routing?: AssignmentRouting | null;
+    assignToUserIds?: string[];
+    assignToTeamIds?: string[];
+}
+export interface ReorderAssignmentPoliciesDto {
+    /** Complete permutation of the org's policy ids in the desired evaluation order. */
+    orderedIds: string[];
+}
+export interface TeamRefDto {
+    teamId: string;
+    name: string;
+    memberCount: number;
+    /** Catalogue-governed tags (`team.tags`). */
+    tags: TagValue[];
+}
+export interface TeamMemberDto {
+    userId: string;
+    name: string;
+    email?: string;
+    role?: string;
+    avatar?: string;
+}
+export interface TeamDto {
+    id: string;
+    name: string;
+    description?: string | null;
+    archivedAt?: string | null;
+    /** Catalogue-governed tags (`team.tags`). */
+    tags: TagValue[];
+    memberCount: number;
+    members: TeamMemberDto[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateTeamDto {
+    name: string;
+    description?: string | null;
+    /** Initial members (better-auth user ids). Each must be a member of the organization. */
+    memberUserIds?: string[];
+    /**
+     * Catalogue-governed tags (`team.tags`). Every value must already exist in
+     * the org tag catalogue — the catalogue is closed.
+     */
+    tags?: TagValueInput[];
+}
+export interface UpdateTeamDto {
+    name?: string;
+    description?: string | null;
+    /**
+     * Replaces the full tag set — send every tag the team should end up with,
+     * not a delta. Omit to leave the tags unchanged; pass `[]` to clear them.
+     */
+    tags?: TagValueInput[];
+}
+export interface TeamMemberIdsDto {
+    userIds: string[];
+}
+/** An array with at least one item. */
+export type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Assignment targets. The API rejects a request unless at least one target
+ * array is present and non-empty.
+ */
+export type CustomerAssignmentInput = {
+    userIds: NonEmptyArray<string>;
+    teamIds?: string[];
+} | {
+    userIds?: string[];
+    teamIds: NonEmptyArray<string>;
+};
+/**
+ * Bulk assignment preflight-validates every customer and target before
+ * assignment begins.
+ */
+export type BulkCustomerAssignmentInput = CustomerAssignmentInput & {
+    customerIds: NonEmptyArray<string>;
+};
+export interface CustomerAssignmentResponse {
+    id: string;
+    assignedToUserIds: string[];
+    assignedToTeamIds: string[];
+}
+export interface BulkCustomerAssignmentResult {
+    /** How many customers actually changed. Already-assigned targets are skipped. */
+    updated: number;
+}
+/** @deprecated Use `CustomerAssignmentInput`. */
+export type CustomerAssignmentDto = CustomerAssignmentInput;
+/** @deprecated Use `BulkCustomerAssignmentInput`. */
+export type BulkCustomerAssignmentDto = BulkCustomerAssignmentInput;
+/** @deprecated Use `CustomerAssignmentResponse`. */
+export type CustomerAssignmentResponseDto = CustomerAssignmentResponse;
+/** @deprecated Use `BulkCustomerAssignmentResult`. */
+export type BulkAssignResultDto = BulkCustomerAssignmentResult;
+export type * from './alert-workflow-types';
+export interface AlertWorkflowSettings {
+    id: string;
+    name: string;
+    alertType: import('./alert-workflow-types').WorkflowAlertType;
+    revision: number;
+    publishedVersion: number;
+    draft: import('./alert-workflow-types').WorkflowDefinition;
+    published: import('./alert-workflow-types').WorkflowPublication | null;
+}
+export interface SaveAlertWorkflowInput {
+    id?: string;
+    name: string;
+    expectedRevision: number;
+    definition: import('./alert-workflow-types').WorkflowDefinition;
+    publish: boolean;
+}
+/** Organization-wide creation experience. Existing alerts retain their saved behavior. */
+export type AlertWorkflowExperience = 'SIMPLE' | 'DEFINED';
+export interface AlertWorkflowExperienceSettings {
+    id: string;
+    experience: AlertWorkflowExperience;
+    revision: number;
+}
+export interface SaveAlertWorkflowExperienceInput {
+    experience: AlertWorkflowExperience;
+    expectedRevision: number;
+}
+/** Published workflow snapshot. Older entries may lack a recoverable definition. */
+export interface AlertWorkflowVersion {
+    id: string;
+    version: number;
+    isCurrent: boolean;
+    definition: import('./alert-workflow-types').WorkflowDefinition | null;
+    publishedAt: string | null;
+    publishedBy: string | null;
+}
+export interface RestoreAlertWorkflowInput {
+    version: number;
+    expectedRevision: number;
+}
+export type PaymentInstrumentType = 'CARD' | 'VIRTUAL_CARD' | 'WALLET_TOKEN' | 'ACH_CREDENTIAL' | 'ONLINE_LOGIN' | 'DIGITAL_TOKEN' | 'CREDIT_CARD' | 'DEBIT_CARD' | 'PAYMENT_TOKEN' | 'API_KEY' | 'CRYPTO_WALLET' | 'OTHER';
+export type PaymentInstrumentStatus = 'ACTIVE' | 'BLOCKED' | 'EXPIRED' | 'LOST' | 'STOLEN' | 'FROZEN' | 'INACTIVE' | 'REVOKED' | 'COMPROMISED';
+export type ChannelEndpointStatus = 'ACTIVE' | 'INACTIVE' | 'SUSPENDED' | 'RETIRED' | 'UNKNOWN';
+export interface SessionDto {
+    id: string;
+    externalSessionId: string;
+    customerId?: string | null;
+    deviceId?: string | null;
+    startedAt: string;
+    lastActivityAt: string;
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+}
+export interface UpdateSessionDto {
+    customerId?: string | null;
+    deviceId?: string | null;
+    startedAt?: string;
+    lastActivityAt?: string;
+    metadata?: Record<string, unknown> | null;
+}
+export interface ChannelEndpointDto {
+    id: string;
+    externalId: string;
+    kind: string;
+    provider: string;
+    displayName?: string | null;
+    status: ChannelEndpointStatus;
+    metadata?: Record<string, unknown> | null;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    createdAt: string;
+    updatedAt: string;
+    /** Catalogue-governed tags (`channelEndpoint.tags`). */
+    tags: TagValue[];
+    /** Set by the latest risk assessment. */
+    riskRating?: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL' | null;
+}
+export interface UpdateChannelEndpointDto {
+    displayName?: string | null;
+    status?: ChannelEndpointStatus;
+    metadata?: Record<string, unknown> | null;
+    firstSeenAt?: string;
+    lastSeenAt?: string;
+}
+export type PaymentInstrumentRelationshipSource = 'EXPLICIT' | 'TRANSACTION' | 'ANALYST' | 'RESOLUTION';
+export type PaymentInstrumentFingerprintType = 'CARD_PAN' | 'NETWORK_TOKEN' | 'WALLET_TOKEN' | 'ACH_CREDENTIAL' | 'ONLINE_LOGIN' | 'API_KEY' | 'CRYPTO_ADDRESS' | 'EXTERNAL_ID' | 'OTHER';
+export interface PaymentInstrumentFingerprintDto {
+    type: PaymentInstrumentFingerprintType;
+    /** Raw credential used only for protected fingerprint resolution; never persisted. */
+    value: string;
+}
+export interface PaymentInstrumentPayloadDto {
+    /** Internal Payment Instrument ID. */
+    paymentInstrumentId?: string;
+    /** Integration-owned stable Payment Instrument ID. */
+    externalId?: string;
+    type?: PaymentInstrumentType;
+    fingerprint?: PaymentInstrumentFingerprintDto;
+}
+type PaymentInstrumentDecimalDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+/** A safe masked payment-instrument suffix containing exactly four decimal digits. */
+export type PaymentInstrumentLast4 = `${PaymentInstrumentDecimalDigit}${PaymentInstrumentDecimalDigit}${PaymentInstrumentDecimalDigit}${PaymentInstrumentDecimalDigit}`;
+export interface AttemptPaymentInstrumentDto extends PaymentInstrumentPayloadDto {
+    /** Safe issuer identification number for BIN/IIN attack analysis. */
+    iin?: string;
+    /** Safe masked suffix containing exactly four decimal digits. */
+    last4?: PaymentInstrumentLast4;
+}
+export interface PaymentInstrumentDto {
+    id: string;
+    organizationId: string;
+    externalId?: string | null;
+    type: PaymentInstrumentType;
+    status: PaymentInstrumentStatus;
+    parentPaymentInstrumentId?: string | null;
+    displayName?: string | null;
+    createdSource: PaymentInstrumentRelationshipSource;
+    managedAt?: string | null;
+    firstSeenAt?: string | null;
+    lastUsedAt?: string | null;
+    issuedAt?: string | null;
+    expiresAt?: string | null;
+    riskFlags: string[];
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreatePaymentInstrumentDto {
+    externalId?: string;
+    type: PaymentInstrumentType;
+    status?: PaymentInstrumentStatus;
+    parentPaymentInstrumentId?: string;
+    displayName?: string;
+    createdSource: PaymentInstrumentRelationshipSource;
+    managedAt?: string;
+    firstSeenAt?: string;
+    issuedAt?: string;
+    expiresAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdatePaymentInstrumentDto {
+    status?: PaymentInstrumentStatus;
+    parentPaymentInstrumentId?: string | null;
+    displayName?: string | null;
+    managedAt?: string | null;
+    issuedAt?: string | null;
+    expiresAt?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface LinkPaymentInstrumentAccountDto {
+    accountId: string;
+    relationshipType: 'ACCESS_CREDENTIAL' | 'FUNDING_SOURCE' | 'SETTLEMENT_DESTINATION' | 'OTHER';
+    source: PaymentInstrumentRelationshipSource;
+    validFrom?: string;
+    validTo?: string;
+    confidence?: number;
+}
+export interface LinkPaymentInstrumentCustomerDto {
+    customerId: string;
+    role: 'PRIMARY_HOLDER' | 'AUTHORIZED_USER' | 'CORPORATE_USER' | 'CUSTODIAN' | 'OBSERVED_USER';
+    source: PaymentInstrumentRelationshipSource;
+    validFrom?: string;
+    validTo?: string;
+    confidence?: number;
+}
+export interface PaymentInstrumentAccountRelationshipDto {
+    id: string;
+    accountId: string;
+    paymentInstrumentId: string;
+    relationshipType: 'ACCESS_CREDENTIAL' | 'FUNDING_SOURCE' | 'SETTLEMENT_DESTINATION' | 'OTHER';
+    validFrom: string;
+    validTo?: string | null;
+    source: PaymentInstrumentRelationshipSource;
+    confidence?: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PaymentInstrumentCustomerRelationshipDto {
+    id: string;
+    customerId: string;
+    paymentInstrumentId: string;
+    role: 'PRIMARY_HOLDER' | 'AUTHORIZED_USER' | 'CORPORATE_USER' | 'CUSTODIAN' | 'OBSERVED_USER';
+    validFrom: string;
+    validTo?: string | null;
+    source: PaymentInstrumentRelationshipSource;
+    confidence?: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** @deprecated Use the account- or customer-specific relationship response type. */
+export type PaymentInstrumentRelationshipDto = PaymentInstrumentAccountRelationshipDto | PaymentInstrumentCustomerRelationshipDto;
+export interface ConnectionEdge<T> {
+    node: T;
+    /** Opaque offset cursor. */
+    cursor: string;
+}
+export interface ConnectionPageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string;
+    endCursor?: string;
+}
+export interface ConnectionPageMeta {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+/** Where a Risk Signal came from. Immutable provenance, set by the server. */
+export type RiskSignalSourceType = 'EVENT' | 'RULE' | 'MANUAL';
+export interface RiskSignal {
+    id: string;
+    /** Caller-supplied idempotency key, for explicitly created signals. */
+    externalId?: string | null;
+    /** Dotted signal type. Tenant vocabulary — not a fixed platform enum. */
+    type: string;
+    resourceType: RiskSignalResourceType;
+    resourceId: string;
+    /** Strength at `occurredAt`. Immutable. */
+    weight: number;
+    /** Half-life in seconds. Immutable. */
+    halfLifeSeconds: number;
+    /** Half-life as an ISO 8601 duration, e.g. `P7D`. Immutable. */
+    halfLife: string;
+    occurredAt: string;
+    /** Decayed weight at the requested `asOf` time. */
+    effectiveWeight: number;
+    sourceType: RiskSignalSourceType;
+    /** The Event id, evaluation id, or acting user id behind this signal. */
+    sourceId: string;
+    /** Safe audit facts only — never secrets or raw source payloads. */
+    sourceSnapshot: Record<string, unknown>;
+    createdBy: unknown;
+    createdAt: string;
+}
+/**
+ * Explicit Risk Signal creation.
+ *
+ * The caller does not choose the source: the server sets `sourceType: 'MANUAL'`
+ * and captures the authenticated actor. There is deliberately no way to claim a
+ * signal came from an Event or a Rule.
+ */
+export interface CreateRiskSignalInput {
+    /**
+     * Your idempotency key for this signal (max 255 chars). Resubmitting the
+     * same `externalId` returns the original signal rather than adding a
+     * second one.
+     */
+    externalId?: string | null;
+    /** Dotted signal type, e.g. `analyst.concerning_account_behaviour`. */
+    type: string;
+    resourceType: RiskSignalResourceType;
+    resourceId: string;
+    /** Strength at `occurredAt`. Must be greater than zero. */
+    weight: number;
+    /**
+     * Half-life as a positive ISO 8601 duration, e.g. `P14D`. Calendar units
+     * (Y/M) are rejected — they have no fixed length.
+     */
+    halfLife: string;
+    /** When the evidence occurred (ISO 8601). Defaults to now. */
+    occurredAt?: string | null;
+    /** Analyst justification, recorded in the signal's source snapshot (max 2000 chars). */
+    note?: string | null;
+}
+export interface ListRiskSignalsQuery {
+    /** Required. Which kind of resource to read signals for. */
+    resourceType: RiskSignalResourceType;
+    /** Required. Id of that resource. */
+    resourceId: string;
+    /**
+     * ISO 8601 timestamp the decay is computed as of. Defaults to server time;
+     * a historical `asOf` returns what the resource looked like at that moment.
+     */
+    asOf?: string;
+    /** Restrict which signal types contribute. Repeatable. */
+    type?: string[];
+    /** Restrict which provenances contribute. Repeatable. */
+    sourceType?: RiskSignalSourceType[];
+    /** 1–200. Defaults to 50. */
+    limit?: number;
+    /** Defaults to 0. */
+    offset?: number;
+}
+/**
+ * A resource's Risk Signals with their decayed weights, plus the aggregate.
+ *
+ * `type` / `sourceType` filter which records contribute; they never change how
+ * far a contributing signal has decayed — age is always measured to `asOf`.
+ */
+export interface RiskSignalListResponse {
+    edges: ConnectionEdge<RiskSignal>[];
+    pageInfo: ConnectionPageInfo;
+    totalCount: number;
+    /** The time the decay was computed as of. */
+    asOf: string;
+    /**
+     * Sum of every contributing signal's effective weight at `asOf`. Computed
+     * on read — not a cached score on the resource.
+     */
+    aggregateEffectiveWeight: number;
+    /** Number of contributing signal records. */
+    contributingCount: number;
+    /** Latest contributing occurrence. */
+    latestAt?: string | null;
+    /** Distinct contributing signal types. */
+    uniqueTypeCount: number;
+}
+export type EmployeeStatus = 'ACTIVE' | 'INACTIVE' | 'SUSPENDED' | 'TERMINATED';
+export type BranchStatus = 'ACTIVE' | 'INACTIVE' | 'CLOSED';
+export interface Employee {
+    id: string;
+    /** The institution's own staff identifier. */
+    externalEmployeeId?: string | null;
+    fullName: string;
+    email?: string | null;
+    jobTitle?: string | null;
+    department?: string | null;
+    /** Home Branch id. */
+    branchId?: string | null;
+    status: EmployeeStatus;
+    /**
+     * Optional link to the Dossiers organization member who is this same
+     * person. Null for employees without a Dossiers login. Never an identity
+     * substitute — Events and Risk Signals always attach by Employee id.
+     */
+    orgMemberId?: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    lifecycle: Lifecycle;
+    archivedAt?: string | null;
+    tombstonedAt?: string | null;
+}
+export interface CreateEmployeeInput {
+    fullName: string;
+    /**
+     * The institution's own staff identifier. Unique within the organization;
+     * lets ingestion resolve an Employee without a Dossiers UUID round-trip.
+     */
+    externalEmployeeId?: string | null;
+    email?: string | null;
+    jobTitle?: string | null;
+    department?: string | null;
+    /** Home Branch id. Must belong to the same organization. */
+    branchId?: string | null;
+    /** Defaults to `ACTIVE`. */
+    status?: EmployeeStatus;
+    /**
+     * Optional link to the Dossiers organization member who is this same
+     * person. Leave unset for employees without a Dossiers login.
+     */
+    orgMemberId?: string | null;
+}
+export interface UpdateEmployeeInput {
+    fullName?: string;
+    email?: string | null;
+    jobTitle?: string | null;
+    department?: string | null;
+    branchId?: string | null;
+    status?: EmployeeStatus;
+    orgMemberId?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface EmployeeListResponse {
+    data: Employee[];
+    edges: ConnectionEdge<Employee>[];
+    pageInfo: ConnectionPageInfo;
+    meta: ConnectionPageMeta;
+}
+export interface Branch {
+    id: string;
+    /** The institution's own branch identifier. */
+    externalBranchId?: string | null;
+    name: string;
+    code?: string | null;
+    country?: string | null;
+    city?: string | null;
+    /**
+     * Owning Institution id, when the tenant models its own legal entities as
+     * Institutions.
+     */
+    institutionId?: string | null;
+    status: BranchStatus;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    lifecycle: Lifecycle;
+    archivedAt?: string | null;
+    tombstonedAt?: string | null;
+}
+export interface CreateBranchInput {
+    name: string;
+    /**
+     * The institution's own branch identifier. Unique within the organization;
+     * lets ingestion resolve a Branch without a Dossiers UUID round-trip.
+     */
+    externalBranchId?: string | null;
+    code?: string | null;
+    country?: string | null;
+    city?: string | null;
+    institutionId?: string | null;
+    /** Defaults to `ACTIVE`. */
+    status?: BranchStatus;
+}
+export interface UpdateBranchInput {
+    name?: string;
+    code?: string | null;
+    country?: string | null;
+    city?: string | null;
+    institutionId?: string | null;
+    status?: BranchStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface BranchListResponse {
+    data: Branch[];
+    edges: ConnectionEdge<Branch>[];
+    pageInfo: ConnectionPageInfo;
+    meta: ConnectionPageMeta;
+}
+export type PartyRelationshipDirection = 'DIRECTED' | 'SYMMETRIC';
+export type PartyRelationshipPartyType = 'CUSTOMER' | 'COUNTERPARTY';
+export interface PartyRelationshipType {
+    id: string;
+    key: string;
+    label: string;
+    description?: string | null;
+    direction: PartyRelationshipDirection;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreatePartyRelationshipTypeInput {
+    key: string;
+    label: string;
+    description?: string;
+    direction: PartyRelationshipDirection;
+}
+/** One end of a relationship, resolved to something displayable. */
+export interface PartyRef {
+    type: PartyRelationshipPartyType;
+    id: string;
+    label: string;
+}
+export interface PartyRelationship {
+    id: string;
+    typeId: string;
+    relationshipType: PartyRelationshipType;
+    sourceType: PartyRelationshipPartyType;
+    sourceId: string;
+    targetType: PartyRelationshipPartyType;
+    targetId: string;
+    sourceParty?: PartyRef | null;
+    targetParty?: PartyRef | null;
+    description?: string | null;
+    validFrom?: string | null;
+    validTo?: string | null;
+    source?: string | null;
+    confidence?: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreatePartyRelationshipInput {
+    typeId: string;
+    sourceType: PartyRelationshipPartyType;
+    sourceId: string;
+    targetType: PartyRelationshipPartyType;
+    targetId: string;
+    description?: string;
+    validFrom?: string;
+    validTo?: string;
+    source?: string;
+    confidence?: number;
+}
+export type AlertRiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+/**
+ * An org-defined alert type. CUSTOM alerts name one of these and carry typed
+ * field values validated against `fields` (Tier A) when raised. Editing the
+ * schema never re-validates existing alerts.
+ */
+export interface CustomAlertTypeResponseDto {
+    id: string;
+    /** Stable snake_case machine name; integrators raise alerts by it. Immutable. */
+    name: string;
+    displayName: string;
+    description: string | null;
+    fields: TypedFieldDefinition[];
+    /** Applied when the creator does not choose a risk level. */
+    defaultRiskLevel: AlertRiskLevel;
+    lifecycle: 'LIVE' | 'ARCHIVED' | 'TOMBSTONED';
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string | null;
+    tombstonedAt?: string | null;
+}
+export interface CreateCustomAlertTypeDto {
+    /** snake_case, starts with a letter, max 64 chars. */
+    name: string;
+    displayName: string;
+    description?: string | null;
+    fields?: TypedFieldDefinition[];
+    /** Defaults to MEDIUM. */
+    defaultRiskLevel?: AlertRiskLevel;
+}
+export interface UpdateCustomAlertTypeDto {
+    displayName?: string;
+    description?: string | null;
+    /** Replaces the schema. Applies to alerts raised afterwards only. */
+    fields?: TypedFieldDefinition[];
+    defaultRiskLevel?: AlertRiskLevel;
+}
+/** A resource to link to an alert. `resourceType` is case-insensitive (`customer` and `CUSTOMER` both work). */
+export interface AlertResourceRefDto {
+    resourceType: string;
+    resourceId: string;
+}
+export interface AlertResourceDto {
+    /** Link id — pass this to `removeResource`, not the target's id. */
+    id: string;
+    resourceType: string;
+    resourceId: string;
+    addedBy: {
+        userId: string;
+        name: string;
+    };
+    createdAt: string;
+}
+export interface CreateCustomAlertDto {
+    /**
+     * Optional. Machine name (or id) of a LIVE custom alert type. Omit for a
+     * free-form alert. With a type that declares fields, `fields` are validated
+     * against its schema; otherwise they are self-declaring.
+     */
+    alertType?: string | null;
+    subject: string;
+    /** Defaults to the type's `defaultRiskLevel`. */
+    riskLevel?: AlertRiskLevel;
+    /** Customer the alert is about. Archived customers are allowed. */
+    customerId?: string | null;
+    /** Markdown narrative. */
+    notes?: string | null;
+    /** Structured details. Validated against the type's schema when one is given, self-declaring otherwise. */
+    fields?: TypedFieldValueInput[];
+    /** Org member ids to assign at creation; they are notified. */
+    assignedToUserIds?: string[];
+    /** Team ids to assign at creation; members are notified. */
+    assignedToTeamIds?: string[];
+    resources?: AlertResourceRefDto[];
+    /**
+     * Idempotency key, scoped per **organization** (not per API key): two
+     * keys replaying the same upstream event converge on one alert.
+     */
+    externalRequestId?: string | null;
+}
+export interface UpdateAlertNotesDto {
+    /** Markdown. Null or empty clears the notes. */
+    notes?: string | null;
+}
+/** Flat REST view of an alert (any type). The GraphQL surface carries the rich per-type shape. */
+export interface AlertResponseDto {
+    id: string;
+    type: 'SCREENING' | 'RULE_TRIGGER' | 'CUSTOM';
+    customAlertTypeId: string | null;
+    status: 'OPEN' | 'CLOSED';
+    subject: string;
+    riskLevel: AlertRiskLevel;
+    customerId: string | null;
+    assignedToUserIds: string[];
+    assignedToTeamIds: string[];
+    /** Stored typed-field bag (`{ [key]: { type, value } }`) for CUSTOM alerts; `{}` otherwise. */
+    fields: Record<string, unknown>;
+    notes: string | null;
+    createdBy: {
+        type: 'USER' | 'SERVICE' | 'UNRESOLVED';
+        userId: string;
+        name: string;
+    } | null;
+    externalRequestId: string | null;
+    disposition: string | null;
+    dispositionReason: string | null;
+    closedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on `alerts.create` and `alerts.get`. */
+    resources?: AlertResourceDto[];
+}
 //# sourceMappingURL=types.d.ts.map