@trusset/sdk 0.1.0 → 0.5.0

package/dist/index-Dl4U8vUM.d.mts

@@ -0,0 +1,956 @@
+import { S as SignedStep, P as PaginationOptions, d as TransactionSigner, H as HttpClient, e as ChainSource, b as SignOptions, C as ConfirmOptions } from './flow-Cz8A09rn.mjs';
+
+type InvestorType = 'RETAIL' | 'PROFESSIONAL' | 'ELIGIBLE_COUNTERPARTY';
+/**
+ * Investor type input. Either one of the three presets or the key of a
+ * custom verification profile configured on the instance.
+ */
+type InvestorTypeInput = InvestorType | (string & {});
+type KYCStatus = 'active' | 'soft_expired' | 'hard_expired' | 'revoked' | 'none' | 'unknown';
+type CustomerStatus = 'pending' | 'verified' | 'revoked';
+type CustomerType = 'INDIVIDUAL' | 'COMPANY';
+type IdLinkStatus = 'PENDING' | 'COMPLETED' | 'EXPIRED';
+/**
+ * On-chain claim types in the identity registry.
+ * KYC, ACCREDITATION, RESIDENCY, and CITIZENSHIP are derived from a KYC
+ * proof manifest (see `addClaimsFromProof`). AML, TAX_RESIDENCY,
+ * SANCTIONS_CHECK, and PEP_CHECK are added manually via `addClaim`.
+ */
+type ClaimType = 'KYC' | 'AML' | 'ACCREDITATION' | 'RESIDENCY' | 'CITIZENSHIP' | 'TAX_RESIDENCY' | 'SANCTIONS_CHECK' | 'PEP_CHECK';
+interface Customer {
+    id: string;
+    instanceId: string;
+    issuerId: string;
+    walletAddress: string | null;
+    name: string | null;
+    country: string | null;
+    investorType: string;
+    customerType: CustomerType;
+    companyUrl: string | null;
+    companyId: string | null;
+    externalId: string | null;
+    referenceKey: string | null;
+    status: CustomerStatus;
+    frozen: boolean;
+    kycHash: string | null;
+    onChainTxHash: string | null;
+    contactChannels: string[];
+    metadata: Record<string, unknown> | null;
+    archived: boolean;
+    archivedAt: string | null;
+    verifiedAt: string | null;
+    revokedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on single-customer fetches: the linked company record. */
+    company?: {
+        id: string;
+        name: string | null;
+        companyUrl: string | null;
+    } | null;
+    /** Present on single-customer fetches of COMPANY customers. */
+    members?: Array<{
+        id: string;
+        name: string | null;
+        walletAddress: string | null;
+        status: string;
+        country: string | null;
+        createdAt: string;
+    }>;
+    /** Present on single-customer fetches. */
+    linkedWallets?: Array<{
+        id: string;
+        walletAddress: string;
+        label: string | null;
+        addedAt: string;
+        addedBy: string;
+    }>;
+}
+interface CreateCustomerInput {
+    walletAddress?: string;
+    name?: string;
+    country?: string;
+    investorType?: InvestorTypeInput;
+    /** INDIVIDUAL (default) or COMPANY. Immutable after creation. */
+    customerType?: CustomerType;
+    /** Company customers only. */
+    companyUrl?: string;
+    /** Individual customers only: id of a COMPANY customer to link to. */
+    companyId?: string;
+    externalId?: string;
+    /** Up to 20 contact strings (email, phone, ...), 200 chars each. */
+    contactChannels?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface UpdateCustomerInput {
+    name?: string;
+    country?: string;
+    investorType?: InvestorTypeInput;
+    walletAddress?: string;
+    status?: CustomerStatus;
+    companyUrl?: string | null;
+    companyId?: string | null;
+    contactChannels?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface ListCustomersOptions extends PaginationOptions {
+    includeArchived?: boolean;
+    search?: string;
+    customerType?: CustomerType;
+}
+interface LinkWalletInput {
+    referenceKey: string;
+    walletAddress: string;
+}
+interface LinkedWallet {
+    /** Only set for non-primary wallets. */
+    id?: string;
+    address: string;
+    label: string | null;
+    isPrimary: boolean;
+    addedAt: string;
+    addedBy?: string;
+}
+interface LinkedWalletsResult {
+    primary: string | null;
+    total: number;
+    wallets: LinkedWallet[];
+}
+/**
+ * An unsigned transaction for the wallet holder to sign and broadcast.
+ * Trusset holds no keys: every on-chain write is prepared as calldata here,
+ * signed by your wallet, and then confirmed back to the backend, which reads
+ * the mined receipt before recording anything.
+ */
+interface PreparedTransaction {
+    action: 'SIGN_TRANSACTION';
+    registerKind?: RegisterKind;
+    chainId?: number;
+    transaction: {
+        to: string;
+        data: string;
+    };
+    functionName: string;
+    description: string;
+}
+type RegisterKind = 'TRUSSET' | 'TREX';
+type RegisterPhase = 'DEPLOY_IDENTITY' | 'SIGN_CLAIMS' | 'REGISTER';
+interface ClaimSignature {
+    walletAddress: string;
+    signature: string;
+    claimType?: ClaimType;
+}
+interface RegisterPlanInput {
+    signerAddress?: string;
+    claimSignatures?: ClaimSignature[];
+    identities?: Record<string, string>;
+}
+interface RegisterPlanStep {
+    action: 'SIGN_TRANSACTION';
+    stepType: string;
+    walletAddress?: string;
+    walletAddresses?: string[];
+    identity?: string;
+    managementKey?: string;
+    implementationAuthority?: string;
+    transaction: {
+        to: string | null;
+        data: string;
+        create?: true;
+    };
+    functionName: string;
+    description: string;
+    claimType?: ClaimType;
+    dataHash?: string;
+    expiry?: number;
+}
+interface ClaimSigningRequest {
+    walletAddress: string;
+    identity: string;
+    topic: string;
+    claimIssuer: string;
+    data: string;
+    messageHash: string;
+    scheme: 'eip191';
+    description: string;
+    claimType: ClaimType;
+}
+interface RegisterPlan {
+    registerKind: 'TREX';
+    register: string;
+    signerAddress: string | null;
+    claimSigners?: string[];
+    action: 'SIGN_TRANSACTIONS' | 'SIGN_MESSAGES';
+    phase: RegisterPhase;
+    steps?: RegisterPlanStep[];
+    messages?: ClaimSigningRequest[];
+    confirmStepIndex?: number;
+    registerStep?: string | null;
+    identities: Record<string, string>;
+    claimIssuer: string;
+    claimTopic: string;
+    next?: string;
+    warnings?: string[];
+    description?: string;
+}
+interface PreparedOnchainId {
+    registerKind: 'TREX';
+    walletAddress: string;
+    exists: boolean;
+    identity?: string;
+    registered?: boolean;
+    action?: 'SIGN_TRANSACTION';
+    stepType?: 'deployIdentity';
+    managementKey?: string;
+    implementationAuthority?: string;
+    transaction?: {
+        to: null;
+        data: string;
+        create: true;
+    };
+    functionName?: string;
+    description?: string;
+    confirmWith: {
+        endpoint: string;
+        fields: string[];
+    };
+}
+interface OnchainIdResult {
+    registerKind: 'TREX';
+    walletAddress: string;
+    identity: string;
+    txHash: string;
+    blockNumber: number;
+    from: string;
+    implementationAuthority: string | null;
+    managementKey: string | null;
+    managementKeyHeld: boolean | null;
+    alreadyRecorded: boolean;
+    transactions?: SignedStep[];
+}
+/** Where a signed transaction is confirmed, echoed by every write endpoint. */
+interface ConfirmWith {
+    endpoint: string;
+    field: string;
+    shape?: string;
+}
+interface VerifyIdentityInput extends RegisterPlanInput {
+    walletAddress: string;
+    country: string;
+    investorType?: InvestorTypeInput;
+    softExpiryDays?: number;
+    hardExpiryDays?: number;
+    /**
+     * The KYC root hash produced by the Trusset KYC zk-proof tool
+     * (`kycHash` in the bundle's manifest.json / kycHash.hex).
+     * This exact hash is stored on-chain and later checked against the
+     * manifest when adding claims via `addClaimsFromProof`.
+     */
+    kycHash?: string;
+    /**
+     * Legacy fallback: arbitrary data the backend hashes with
+     * keccak256(JSON.stringify(kycData)). Ignored when `kycHash` is set.
+     * Prefer `kycHash` - claims from a proof manifest only work with it.
+     */
+    kycData?: Record<string, unknown>;
+}
+/**
+ * The unsigned identity write, returned when no signer and no txHash is given.
+ * `kycHash` is the hash that was encoded into the calldata - confirm with it,
+ * not with a freshly derived one, or the record and the chain disagree.
+ */
+interface PreparedVerifyIdentity extends PreparedTransaction {
+    walletAddress: string;
+    kycHash: string;
+    investorType: number;
+    softExpiry: number;
+    hardExpiry: number;
+    /** 'verify' for a new on-chain identity, 'update' when one already existed. */
+    operation: 'verify' | 'update';
+    confirmWith: ConfirmWith;
+    warnings?: string[];
+}
+type PreparedVerifyPlan = RegisterPlan & Omit<PreparedVerifyIdentity, keyof PreparedTransaction>;
+interface VerifyIdentityResult {
+    walletAddress: string;
+    status: string;
+    /** 'verify' for a new on-chain identity, 'update' when one already existed. */
+    operation?: string;
+    txHash: string;
+    gasUsed: string;
+    kycHash: string;
+    alreadyRecorded?: boolean;
+    transactions?: SignedStep[];
+}
+interface BatchVerifyEntry {
+    walletAddress: string;
+    country: string;
+    investorType?: InvestorTypeInput;
+    softExpiryDays?: number;
+    hardExpiryDays?: number;
+    /** KYC root hash from the zk-proof tool for this subject. */
+    kycHash?: string;
+}
+/** An entry the backend refused, with its position in the submitted array. */
+interface BatchVerifyRejection {
+    index: number;
+    walletAddress: string | null;
+    code: string;
+    message: string;
+}
+/** An accepted entry, carrying the root hash that went into the calldata. */
+interface PreparedBatchEntry {
+    walletAddress: string;
+    country: string;
+    investorType?: string;
+    kycHash: string;
+}
+interface PreparedBatchVerify extends PreparedTransaction {
+    submitted: number;
+    accepted: number;
+    totalEntries: number;
+    rejectedCount: number;
+    rejected: BatchVerifyRejection[];
+    entries: PreparedBatchEntry[];
+    confirmWith: ConfirmWith;
+    warnings?: string[];
+}
+type PreparedBatchVerifyPlan = RegisterPlan & Omit<PreparedBatchVerify, keyof PreparedTransaction>;
+interface BatchVerifyResult {
+    submitted: number;
+    accepted: number;
+    totalEntries: number;
+    rejectedCount: number;
+    rejected: BatchVerifyRejection[];
+    onChainSkipped?: string[];
+    txHash: string;
+    gasUsed: string;
+    transactions?: SignedStep[];
+}
+interface PreparedRevokeIdentity extends PreparedTransaction {
+    walletAddress: string;
+    confirmWith: ConfirmWith;
+}
+interface RevokeIdentityResult {
+    walletAddress: string;
+    status: string;
+    txHash: string;
+    gasUsed: string;
+    transactions?: SignedStep[];
+}
+interface OnChainIdentity {
+    kycHash: string;
+    investorType: number;
+    kycProvider: string;
+    timestamp: number;
+    softExpiry: number;
+    hardExpiry: number;
+    status: KYCStatus;
+    statusCode: number;
+    frozen: boolean;
+    isVerified: boolean;
+}
+interface IdentityStatusResult {
+    walletAddress: string;
+    onChain: OnChainIdentity | null;
+    offChain: {
+        status: CustomerStatus;
+        country: string | null;
+        investorType: string;
+        verifiedAt: string | null;
+    } | null;
+}
+interface TransferCheckInput {
+    from: string;
+    to: string;
+    amount?: string;
+    fromBalance?: string;
+    toBalance?: string;
+}
+interface TransferCheckResult {
+    allowed: boolean;
+    reason: number;
+    senderStatus: KYCStatus;
+    receiverStatus: KYCStatus;
+}
+interface Claim {
+    claimType: number;
+    claimTypeLabel: ClaimType | 'UNKNOWN';
+    dataHash: string;
+    issuer: string;
+    issuedAt: number;
+    expiry: number;
+    active: boolean;
+}
+interface ClaimsResult {
+    walletAddress: string;
+    claims: Claim[];
+}
+interface AddClaimInput extends RegisterPlanInput {
+    walletAddress: string;
+    /** Manual claim types only: AML, TAX_RESIDENCY, SANCTIONS_CHECK, PEP_CHECK (or their numeric ids). */
+    claimType: ClaimType | number;
+    /** Pre-computed 32-byte hash of the claim evidence. */
+    dataHash?: string;
+    /** Alternative to dataHash: a string the backend hashes for you. */
+    dataInput?: string;
+    expiryDays?: number;
+}
+interface PreparedAddClaim extends PreparedTransaction {
+    walletAddress: string;
+    claimType: ClaimType;
+    dataHash: string;
+    expiry: number;
+    confirmWith: ConfirmWith;
+    warnings?: string[];
+}
+type PreparedAddClaimPlan = RegisterPlan & Omit<PreparedAddClaim, keyof PreparedTransaction>;
+interface AddClaimResult {
+    walletAddress: string;
+    claimType: ClaimType;
+    dataHash: string;
+    expiry: number;
+    txHash: string;
+    gasUsed: string;
+    transactions?: SignedStep[];
+}
+interface PreparedRevokeClaim extends PreparedTransaction {
+    walletAddress: string;
+    claimType: ClaimType;
+    confirmWith: ConfirmWith;
+}
+interface RevokeClaimResult {
+    walletAddress: string;
+    claimType: ClaimType;
+    txHash: string;
+    gasUsed: string;
+    transactions?: SignedStep[];
+}
+/**
+ * One proof leaf inside a KYC bundle manifest. The tool writes more fields
+ * than listed here; extras are passed through untouched.
+ */
+interface KycProofLeaf {
+    fieldName: string;
+    circuit: string;
+    leafHash: string;
+    commitment: string;
+    [key: string]: unknown;
+}
+/**
+ * The `manifest.json` produced per subject by the Trusset KYC zk-proof tool
+ * (github.com/Trusset/trusset-kyc-zk-proofs). `kycHash` is the Merkle root
+ * hash - the value verified on-chain. `mode: 'stub'` manifests are only
+ * accepted by development instances.
+ */
+interface KycProofManifest {
+    version: string;
+    mode: 'stub' | 'production';
+    walletAddress: string;
+    kycHash: string;
+    leaves: KycProofLeaf[];
+    /** Verification parameters echoed from the tool's input row. */
+    passthrough?: {
+        country?: string;
+        investorType?: string;
+        softExpiryDays?: number;
+        hardExpiryDays?: number;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface ProofClaimsInput extends RegisterPlanInput {
+    walletAddress: string;
+    /** The full manifest.json object from the proof bundle. */
+    manifest: KycProofManifest;
+    /** The bundle's manifest.sig as its 64 raw bytes or their base64, never the file read as text. */
+    manifestSig?: string | Uint8Array;
+    /**
+     * The bundle's proofs, as fieldName -> base64 of the matching proofs/*.bin.
+     * Required on instances with proof verification enabled; stub manifests on
+     * development instances are accepted without them.
+     */
+    proofs?: Record<string, string>;
+    /** Limit which proof-backed claim types to add. Default: all derivable. */
+    selected?: ClaimType[];
+    /** Claim expiry. Default: the identity's on-chain hardExpiry, if set. */
+    expiryDays?: number;
+}
+/** The outcome of verifying the proof bundle, echoed on both phases. */
+interface ProofVerificationInfo {
+    verified: boolean;
+    mode: string;
+    reportId: string | null;
+    verifierVersion: string | null;
+    cached: boolean;
+}
+/** One claim to sign, in the order the steps are returned. */
+interface PreparedProofClaimStep extends PreparedTransaction {
+    claimType: ClaimType;
+    dataHash: string;
+    expiry: number;
+}
+/**
+ * A multi-step write: one transaction per derived claim. Sign and broadcast
+ * the steps in order, then confirm them together.
+ */
+interface PreparedProofClaims {
+    action: 'SIGN_TRANSACTIONS';
+    steps: PreparedProofClaimStep[];
+    walletAddress: string;
+    kycHash: string;
+    total: number;
+    verification: ProofVerificationInfo;
+    confirmWith: ConfirmWith;
+}
+type PreparedProofClaimsPlan = RegisterPlan & {
+    walletAddress: string;
+    kycHash: string;
+};
+/** One signed step, paired back to the claim it belongs to. */
+interface ProofClaimTxResult {
+    claimType: ClaimType;
+    txHash: string;
+}
+/** Confirm proof claims you signed and broadcast yourself, in step order. */
+interface ProofConfirmOptions {
+    txResults: ProofClaimTxResult[];
+}
+interface ProofClaimOutcome {
+    claimType: ClaimType;
+    dataHash: string;
+    /** 'skipped' when no transaction was submitted for this claim. */
+    status: 'confirmed' | 'failed' | 'skipped';
+    txHash?: string;
+    gasUsed?: string;
+    error?: string;
+}
+interface ProofClaimsResult {
+    walletAddress: string;
+    kycHash: string;
+    added: number;
+    total: number;
+    claims: ProofClaimOutcome[];
+    verification: ProofVerificationInfo;
+    transactions?: SignedStep[];
+}
+interface CreateIdLinkInput {
+    recipientEmail?: string;
+    recipientWallet?: string;
+    recipientPhone?: string;
+    note?: string;
+    expiryDays?: number;
+    sendVia?: ('email' | 'sms')[];
+    customRedirectUrl?: string;
+    customMessage?: string;
+    investorType?: InvestorTypeInput;
+    country?: string;
+    /** Charge the recipient before verification. Integer cents, 50 - 1,000,000. */
+    feeCents?: number;
+    /** Required when feeCents is set: 'eur' or 'usd'. */
+    currency?: 'eur' | 'usd';
+}
+interface IdLink {
+    id: string;
+    token: string;
+    verificationUrl: string;
+    status: IdLinkStatus;
+    recipientEmail: string | null;
+    recipientWallet: string | null;
+    recipientPhone: string | null;
+    expiresAt: string;
+    sumsubApplicantId: string | null;
+    feeCents: number | null;
+    currency: string | null;
+    delivery: Record<string, {
+        sent: boolean;
+        error?: string;
+    }>;
+}
+interface IdLinkListItem {
+    id: string;
+    token: string;
+    recipientEmail: string | null;
+    recipientWallet: string | null;
+    recipientPhone: string | null;
+    status: IdLinkStatus;
+    note: string | null;
+    investorType: string;
+    country: string | null;
+    expiresAt: string;
+    used: boolean;
+    usedAt: string | null;
+    createdAt: string;
+    feeCents: number | null;
+    currency: string | null;
+    paidAt: string | null;
+    verificationUrl: string;
+}
+interface ListIdLinksOptions extends PaginationOptions {
+    status?: IdLinkStatus;
+}
+interface ProfileRequiredField {
+    id: string;
+    idDocSetType: string;
+    types?: string[];
+    required: boolean;
+    label: string;
+}
+interface VerificationProfile {
+    id: string;
+    key: string;
+    name: string;
+    description: string | null;
+    onChainInvestorType: number;
+    sumsubLevelName: string;
+    requiredFields: ProfileRequiredField[];
+    isPreset: boolean;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SyncRecord {
+    /** Unique ID in the institution's system. Maps to externalId. */
+    externalId: string;
+    walletAddress?: string;
+    name?: string;
+    country?: string;
+    investorType?: InvestorTypeInput;
+    /** KYC root hash from the zk-proof tool, used when verifyOnChain is set. */
+    kycHash?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SyncResult {
+    total: number;
+    created: number;
+    updated: number;
+    skipped: number;
+    errors: SyncError[];
+}
+interface SyncError {
+    externalId: string;
+    code: string;
+    message: string;
+}
+interface SyncOptions {
+    /** Batch size per API call. Default: 50, max: 200. */
+    batchSize?: number;
+    /**
+     * Conflict strategy when a customer with the same externalId already exists.
+     * 'skip' = do nothing, 'update' = overwrite fields. Default: 'update'.
+     */
+    onConflict?: 'skip' | 'update';
+    /**
+     * If true, also verifies entries with a walletAddress on-chain, in batches
+     * of 500. Requires `signer`, since every transaction is signed by the wallet
+     * holder. Default: false.
+     */
+    verifyOnChain?: boolean;
+    /** Signs the batch verification transactions. Required by `verifyOnChain`. */
+    signer?: TransactionSigner;
+    /** Confirmations to wait for per batch. Default: 1. */
+    confirmations?: number;
+    /** Country and expiry defaults for on-chain verification. */
+    verificationDefaults?: {
+        softExpiryDays?: number;
+        hardExpiryDays?: number;
+    };
+    /** Called after each batch completes. */
+    onProgress?: (processed: number, total: number) => void;
+}
+
+declare class CustomerManagement {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List customers for the current instance.
+     */
+    list(options?: ListCustomersOptions): Promise<{
+        customers: Customer[];
+        total: number;
+    }>;
+    /**
+     * Get a customer by wallet address, ID, externalId, or referenceKey.
+     *
+     * Note: the backend routes 20-30 character identifiers to the internal-ID
+     * lookup, so an externalId in that length range will not resolve here -
+     * use `searchByExternalId`, which handles the ambiguity.
+     */
+    get(identifier: string): Promise<Customer>;
+    /**
+     * Create a new customer record.
+     */
+    create(input: CreateCustomerInput): Promise<Customer>;
+    /**
+     * Update an existing customer.
+     */
+    update(customerId: string, input: UpdateCustomerInput): Promise<Customer>;
+    /**
+     * Archive (soft-delete) a customer.
+     */
+    archive(customerId: string): Promise<{
+        archived: boolean;
+    }>;
+    /**
+     * Link a wallet address to a customer created via referenceKey.
+     */
+    linkWallet(input: LinkWalletInput): Promise<Customer>;
+    /**
+     * Batch-fetch country codes for a list of wallet addresses.
+     */
+    batchGetCountries(addresses: string[]): Promise<Record<string, string>>;
+    /**
+     * List all wallets of a customer: the primary plus any linked wallets.
+     */
+    listWallets(customerId: string): Promise<LinkedWalletsResult>;
+    /**
+     * Link an additional wallet to a customer. The wallet must not be in use
+     * by any other customer in the instance.
+     */
+    addWallet(customerId: string, walletAddress: string, label?: string): Promise<LinkedWallet>;
+    /**
+     * Remove a linked (non-primary) wallet from a customer.
+     */
+    removeWallet(customerId: string, walletAddress: string): Promise<{
+        removed: boolean;
+        address: string;
+    }>;
+    /**
+     * Promote a linked wallet to primary. The previous primary becomes a
+     * linked wallet labeled "Previously primary".
+     */
+    promoteWallet(customerId: string, walletAddress: string): Promise<Customer>;
+    /**
+     * Search customers by name substring.
+     */
+    searchByName(name: string, options?: ListCustomersOptions): Promise<{
+        customers: Customer[];
+        total: number;
+    }>;
+    /**
+     * Find a customer by wallet address.
+     */
+    searchByWallet(walletAddress: string): Promise<Customer>;
+    /**
+     * Find a customer by external ID (your system's unique identifier).
+     */
+    searchByExternalId(externalId: string): Promise<Customer>;
+    /**
+     * Find a customer by reference key (for pre-wallet customers).
+     */
+    searchByReference(referenceKey: string): Promise<Customer>;
+}
+
+declare class CustomerIdentity {
+    private readonly http;
+    private readonly chain;
+    constructor(http: HttpClient, chain?: ChainSource);
+    /**
+     * Verify a customer's identity on-chain via the IdentityRegistry contract.
+     *
+     * Called with input alone this returns an unsigned transaction for your
+     * wallet to sign - Trusset never holds a key. Pass `{ signer }` to sign,
+     * broadcast, and confirm in one call, or `{ txHash }` to confirm a
+     * transaction you broadcast yourself. Only a confirmed transaction updates
+     * the customer record, and only after the backend has read its receipt.
+     *
+     * Pass `kycHash` with the root hash from the KYC zk-proof tool - that hash
+     * is stored on-chain and is later required to add claims from the proof
+     * manifest. When you confirm yourself, send back the `kycHash` from the
+     * prepared transaction, otherwise the record and the chain disagree.
+     * If the identity already exists on-chain it is updated instead (the
+     * `operation` field tells you which happened).
+     */
+    verify(input: VerifyIdentityInput, options: SignOptions | ConfirmOptions): Promise<VerifyIdentityResult>;
+    verify(input: VerifyIdentityInput): Promise<PreparedVerifyIdentity | PreparedVerifyPlan>;
+    /**
+     * Verify a customer on-chain straight from a KYC proof bundle manifest.
+     * Wallet, root hash, and the passthrough parameters (country, investorType,
+     * expiry days) are read from the manifest; `overrides` win where given.
+     */
+    verifyFromManifest(manifest: KycProofManifest, overrides: Omit<Partial<VerifyIdentityInput>, 'kycHash' | 'kycData'> | undefined, options: SignOptions | ConfirmOptions): Promise<VerifyIdentityResult>;
+    verifyFromManifest(manifest: KycProofManifest, overrides?: Omit<Partial<VerifyIdentityInput>, 'kycHash' | 'kycData'>): Promise<PreparedVerifyIdentity | PreparedVerifyPlan>;
+    /**
+     * Batch-verify up to 500 identities in a single transaction. Include each
+     * subject's `kycHash` from the zk-proof tool so proof-backed claims can be
+     * added later.
+     *
+     * Entries that fail validation are reported in `rejected` and left out of
+     * the transaction; the rest are accepted. Confirmation is checked against
+     * the accepted entries, so confirm with the `entries` from the prepared
+     * transaction rather than the ones you submitted.
+     */
+    batchVerify(entries: BatchVerifyEntry[], options: SignOptions | ConfirmOptions): Promise<BatchVerifyResult>;
+    batchVerify(entries: BatchVerifyEntry[], plan?: RegisterPlanInput): Promise<PreparedBatchVerify | PreparedBatchVerifyPlan>;
+    /**
+     * Revoke an identity on-chain.
+     */
+    revoke(walletAddress: string, options: SignOptions | ConfirmOptions): Promise<RevokeIdentityResult>;
+    revoke(walletAddress: string): Promise<PreparedRevokeIdentity>;
+    /**
+     * Get combined on-chain and off-chain identity status.
+     */
+    getStatus(walletAddress: string): Promise<IdentityStatusResult>;
+    /**
+     * Check whether a token transfer between two addresses is compliant.
+     * Runs identity checks + all registered compliance modules.
+     */
+    canTransfer(input: TransferCheckInput): Promise<TransferCheckResult>;
+    deployOnchainId(walletAddress: string, options: SignOptions | ConfirmOptions): Promise<OnchainIdResult | PreparedOnchainId>;
+    deployOnchainId(walletAddress: string, plan?: {
+        signerAddress?: string;
+    }): Promise<PreparedOnchainId>;
+    /**
+     * List the active on-chain claims of a wallet.
+     */
+    getClaims(walletAddress: string): Promise<ClaimsResult>;
+    /**
+     * Add claims backed by a KYC proof bundle. The wallet must already be
+     * verified on-chain with the manifest's root hash (see `verify` /
+     * `verifyFromManifest`), otherwise the backend rejects with HASH_MISMATCH.
+     *
+     * Derivable claims: KYC (always), RESIDENCY (country leaf), CITIZENSHIP
+     * (nationality leaf), ACCREDITATION (investorType leaf). Use `selected`
+     * to add a subset. One transaction is prepared per claim, to be signed and
+     * broadcast in the order returned; `{ signer }` does that for you, and
+     * `{ txResults }` confirms steps you broadcast yourself.
+     *
+     * Instances with proof verification enabled also require the bundle's
+     * `proofs` and `manifestSig`.
+     */
+    addClaimsFromProof(input: ProofClaimsInput, options: SignOptions | ProofConfirmOptions): Promise<ProofClaimsResult>;
+    addClaimsFromProof(input: ProofClaimsInput): Promise<PreparedProofClaims | PreparedProofClaimsPlan>;
+    /**
+     * Add a manual claim (AML, TAX_RESIDENCY, SANCTIONS_CHECK, PEP_CHECK).
+     * Provide either a pre-computed 32-byte `dataHash` or a `dataInput` string
+     * for the backend to hash. Proof-backed claim types must go through
+     * `addClaimsFromProof` instead.
+     */
+    addClaim(input: AddClaimInput, options: SignOptions | ConfirmOptions): Promise<AddClaimResult>;
+    addClaim(input: AddClaimInput): Promise<PreparedAddClaim | PreparedAddClaimPlan>;
+    /**
+     * Revoke an on-chain claim.
+     */
+    revokeClaim(walletAddress: string, claimType: ClaimType | number, options: SignOptions | ConfirmOptions): Promise<RevokeClaimResult>;
+    revokeClaim(walletAddress: string, claimType: ClaimType | number): Promise<PreparedRevokeClaim>;
+    private confirmVerify;
+    private confirmBatchVerify;
+    private confirmRevoke;
+    private confirmAddClaim;
+    private confirmRevokeClaim;
+    private confirmProofClaims;
+    private confirmOnchainId;
+}
+
+declare class CustomerIdLinks {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a KYC verification link to send to an investor.
+     */
+    create(input: CreateIdLinkInput): Promise<IdLink>;
+    /**
+     * List all verification links for the current instance.
+     */
+    list(options?: ListIdLinksOptions): Promise<{
+        links: IdLinkListItem[];
+        total: number;
+    }>;
+    /**
+     * Revoke (expire) a verification link so it can no longer be used.
+     */
+    revoke(linkId: string): Promise<void>;
+    /**
+     * Resend a verification link via the specified channels.
+     */
+    resend(linkId: string, channels: ('email' | 'sms')[]): Promise<{
+        verificationUrl: string;
+        delivery: Record<string, {
+            sent: boolean;
+            error?: string;
+        }>;
+    }>;
+}
+
+/**
+ * Synchronize an existing customer database with Trusset in bulk.
+ *
+ * This module handles:
+ * - Batched upsert of customer records mapped by externalId
+ * - Conflict resolution (skip or update)
+ * - Optional on-chain identity verification for entries that include a wallet
+ * - Progress callbacks for long-running imports
+ *
+ * Usage:
+ * ```ts
+ * const result = await trusset.customers.sync.importRecords(records, {
+ *   onConflict: 'update',
+ *   verifyOnChain: true,
+ *   signer: issuerWallet,
+ *   onProgress: (done, total) => console.log(`${done}/${total}`),
+ * })
+ * ```
+ */
+declare class CustomerSync {
+    private readonly http;
+    private readonly manage;
+    private readonly identity;
+    constructor(http: HttpClient, identity?: CustomerIdentity);
+    /**
+     * Import customer records from an external system.
+     *
+     * Each record is mapped by `externalId`. If a customer with that externalId
+     * already exists, the `onConflict` strategy determines whether to skip or
+     * update.
+     *
+     * When `verifyOnChain` is true, records that include a `walletAddress` and
+     * `country` are batch-verified on-chain after the database import. That
+     * needs `signer`: verification transactions are signed by your wallet, not
+     * by Trusset.
+     */
+    importRecords(records: SyncRecord[], options?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Export all customers from Trusset as flat records.
+     * Useful for syncing data back into your system.
+     */
+    exportRecords(options?: {
+        includeArchived?: boolean;
+    }): Promise<SyncRecord[]>;
+    private processRecord;
+    private runBatchVerification;
+}
+
+/**
+ * Verification profiles (beta): the reusable KYC requirement sets of the
+ * instance. Profile keys are valid `investorType` values for customers
+ * and ID links. Read-only on the API surface.
+ */
+declare class CustomerVerificationProfiles {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all verification profiles of the current instance,
+     * presets (RETAIL, PROFESSIONAL, ELIGIBLE_COUNTERPARTY) first.
+     */
+    list(): Promise<VerificationProfile[]>;
+}
+
+/**
+ * Customer module providing full lifecycle management:
+ *
+ * - `manage`   - CRUD operations, search, wallet linking
+ * - `identity` - On-chain KYC verification + claims via IdentityRegistry
+ * - `idLinks`  - Send and manage KYC verification links
+ * - `profiles` - Verification profiles of the instance (beta, read-only)
+ * - `sync`     - Bulk import/export for existing database integration
+ */
+declare class Customers {
+    readonly manage: CustomerManagement;
+    readonly identity: CustomerIdentity;
+    readonly idLinks: CustomerIdLinks;
+    readonly profiles: CustomerVerificationProfiles;
+    readonly sync: CustomerSync;
+    constructor(http: HttpClient, chain?: ChainSource);
+}
+
+export { type ProfileRequiredField as $, type AddClaimInput as A, type BatchVerifyEntry as B, Customers as C, type LinkedWallet as D, type LinkedWalletsResult as E, type ListCustomersOptions as F, type ListIdLinksOptions as G, type OnchainIdResult as H, type IdLink as I, type PreparedAddClaimPlan as J, type KycProofManifest as K, type LinkWalletInput as L, type PreparedBatchEntry as M, type PreparedBatchVerify as N, type OnChainIdentity as O, type PreparedAddClaim as P, type PreparedBatchVerifyPlan as Q, type PreparedOnchainId as R, type PreparedProofClaimStep as S, type PreparedProofClaims as T, type PreparedProofClaimsPlan as U, type VerifyIdentityInput as V, type PreparedRevokeClaim as W, type PreparedRevokeIdentity as X, type PreparedTransaction as Y, type PreparedVerifyIdentity as Z, type PreparedVerifyPlan as _, type AddClaimResult as a, type ProofClaimOutcome as a0, type ProofClaimTxResult as a1, type ProofClaimsInput as a2, type ProofClaimsResult as a3, type ProofConfirmOptions as a4, type ProofVerificationInfo as a5, type RegisterKind as a6, type RegisterPhase as a7, type RegisterPlan as a8, type RegisterPlanInput as a9, type RegisterPlanStep as aa, type RevokeClaimResult as ab, type RevokeIdentityResult as ac, type SyncError as ad, type SyncOptions as ae, type SyncRecord as af, type SyncResult as ag, type TransferCheckInput as ah, type TransferCheckResult as ai, type UpdateCustomerInput as aj, type VerificationProfile as ak, type VerifyIdentityResult as al, type BatchVerifyRejection as b, type BatchVerifyResult as c, type Claim as d, type ClaimSignature as e, type ClaimSigningRequest as f, type ClaimType as g, type ClaimsResult as h, type ConfirmWith as i, type CreateCustomerInput as j, type CreateIdLinkInput as k, type Customer as l, CustomerIdLinks as m, CustomerIdentity as n, CustomerManagement as o, type CustomerStatus as p, CustomerSync as q, type CustomerType as r, CustomerVerificationProfiles as s, type IdLinkListItem as t, type IdLinkStatus as u, type IdentityStatusResult as v, type InvestorType as w, type InvestorTypeInput as x, type KYCStatus as y, type KycProofLeaf as z };