@neus/sdk 1.0.2 → 1.0.4

package/types.d.ts

@@ -31,18 +31,17 @@ declare module '@neus/sdk' {
     verify(params: VerifyParams): Promise<VerificationResult>;
     
     /**
-     * Get verification status by proof ID
-     * @param qHash - Proof ID (wire field: qHash)
-     * @returns Promise resolving to current status
+     * Get proof record by receipt ID.
+     * @param proofId - Proof receipt ID (0x + 64 hex).
      */
-    getStatus(qHash: string): Promise<StatusResult>;
+    getProof(proofId: string): Promise<StatusResult>;
     
     /**
-     * Get private proof status (owner-signed)
-     * @param qHash - Proof ID (wire field: qHash)
+     * Get private proof record (owner-signed)
+     * @param proofId - Proof receipt ID.
      * @param wallet - Optional injected wallet/provider (MetaMask/ethers Wallet)
      */
-    getPrivateStatus(qHash: string, wallet?: WalletLike): Promise<StatusResult>;
+    getPrivateProof(proofId: string, wallet?: WalletLike | GatePrivateAuth): Promise<StatusResult>;
     
     /**
      * Check API health
@@ -52,24 +51,27 @@ declare module '@neus/sdk' {
     
     /** List available verifiers */
     getVerifiers(): Promise<string[]>;
+
+    /** Get the public verifier catalog, including per-verifier capabilities. */
+    getVerifierCatalog(): Promise<VerifierCatalog>;
     
   /**
    * Poll verification status until completion
-   * @param qHash - Proof ID (wire field: qHash)
+   * @param proofId - Proof ID to poll.
    * @param options - Polling configuration options
    * @returns Promise resolving to final status
    * @example
-   * const finalStatus = await client.pollProofStatus(qHash, {
+   * const finalStatus = await client.pollProofStatus(proofId, {
    *   interval: 3000,
    *   onProgress: (status) => {
    *     // Handle status updates
    *   }
    * });
    */
-   pollProofStatus(qHash: string, options?: PollOptions): Promise<StatusResult>;
+   pollProofStatus(proofId: string, options?: PollOptions): Promise<StatusResult>;
     
     /** Revoke own proof (owner-signed) */
-    revokeOwnProof(qHash: string, wallet?: { address: string }): Promise<boolean>;
+    revokeOwnProof(proofId: string, wallet?: { address: string }): Promise<boolean>;
 
     // ═══════════════════════════════════════════════════════════════
     // PROOFS & GATING METHODS
@@ -90,11 +92,21 @@ declare module '@neus/sdk' {
     getPrivateProofsByWallet(walletAddress: string, options?: GetProofsOptions, wallet?: WalletLike): Promise<ProofsResult>;
 
     /**
-     * Minimal eligibility check against public + discoverable proofs only (API-backed).
+     * Minimal eligibility check against public + unlisted proofs by default (API-backed).
      * Prefer this for server-side integrations that do not need full proof payloads.
      */
     gateCheck(params: GateCheckApiParams): Promise<GateCheckApiResponse>;
 
+    /**
+     * Pre-sign owner auth payload for repeated includePrivate gate checks (single prompt).
+     */
+    createGatePrivateAuth(params: {
+      address: string;
+      wallet?: WalletLike;
+      chain?: string;
+      signatureMethod?: string;
+    }): Promise<GatePrivateAuth>;
+
     /**
      * Evaluate gate requirements against existing proofs
      * Returns whether wallet satisfies all requirements, with missing items listed
@@ -125,10 +137,18 @@ declare module '@neus/sdk' {
   export interface NeusClientConfig {
     /** API endpoint URL (defaults to hosted public API) */
     apiUrl?: string;
-    /** Optional deployment API key (server-side only; do not embed in browser apps) */
+    /** Optional API key (server-side only; do not embed in browser apps) */
     apiKey?: string;
+    /** Optional public app attribution ID (maps to X-Neus-App) */
+    appId?: string;
+    /** Optional x402 receipt token for retry calls (maps to PAYMENT-SIGNATURE) */
+    paymentSignature?: string;
+    /** Optional extra passthrough headers for advanced integrations */
+    extraHeaders?: Record<string, string>;
     /** Request timeout in milliseconds */
     timeout?: number;
+    /** Advanced. NEUS protocol primary-chain id override; most integrators omit. */
+    hubChainId?: number;
     /** Enable SDK logging */
     enableLogging?: boolean;
   }
@@ -152,6 +172,24 @@ declare module '@neus/sdk' {
     /** Verifier-specific options */
     verifierOptions?: Record<string, any>;
   }
+
+  export interface VerifierCatalogMetadataEntry {
+    category?: string;
+    description?: string;
+    flowType?: 'instant' | 'interactive' | 'external_lookup' | string;
+    expiryType?: 'permanent' | 'point_in_time' | 'expiring' | string;
+    supportsDirectApi?: boolean;
+    supportsHostedVerify?: boolean;
+    dataSchema?: Record<string, any>;
+    requiredFields?: string[];
+    optionalFields?: string[];
+  }
+
+  export interface VerifierCatalog {
+    data: string[];
+    metadata: Record<string, VerifierCatalogMetadataEntry>;
+    meta?: Record<string, any>;
+  }
   
   /**
    * Parameters for manual verification
@@ -174,7 +212,7 @@ declare module '@neus/sdk' {
     signature?: string;
     /** Advanced/manual path: signed timestamp */
     signedTimestamp?: number;
-    /** Advanced/manual path: chain ID for verification context; optional, managed by protocol */
+    /** Advanced/optional. EVM signing-context hint; when omitted, resolved to the NEUS protocol primary chain for signing. For chain-specific asset claims (NFT, token, contract), set chainId inside verifier data instead. */
     chainId?: number;
     /** CAIP-2 chain reference for universal mode (e.g. eip155:1, solana:mainnet) */
     chain?: string;
@@ -188,14 +226,16 @@ declare module '@neus/sdk' {
    * Result from proof creation
    */
   export interface ProofResult {
-    /** Proof ID (qHash) */
+    /** Proof receipt ID */
+    proofId: string;
+    /** HTTP wire field for the proof receipt ID. */
     qHash: string;
     /** Current status */
     status: string;
     /** Wallet address that created proof */
     walletAddress?: string;
-    /** Status check URL */
-    statusUrl?: string;
+    /** Stable URL for GET proof record */
+    proofUrl?: string;
     /** Cross-chain enabled */
     crossChain?: boolean;
   }
@@ -204,7 +244,9 @@ declare module '@neus/sdk' {
    * Verification result
    */
   export interface VerificationResult {
-    /** Proof ID (qHash) */
+    /** Proof receipt ID */
+    proofId: string;
+    /** HTTP wire field for the proof receipt ID. */
     qHash: string;
     /** Current status */
     status: VerificationStatus;
@@ -218,13 +260,21 @@ declare module '@neus/sdk' {
    * Status check result
    */
   export interface StatusResult {
+    /** Proof receipt ID */
+    proofId?: string;
+    /** HTTP wire field for the proof receipt ID. */
+    qHash?: string;
+    /** Stable URL for GET proof record */
+    proofUrl?: string | null;
     /** Whether verification succeeded */
     success: boolean;
     /** Current status */
     status: VerificationStatus;
     /** Full verification data */
     data?: {
-      qHash: string;
+      proofId?: string;
+      /** HTTP wire field for the proof receipt ID. */
+      qHash?: string;
       status: string;
       walletAddress: string;
       verifierIds?: string[];
@@ -257,6 +307,7 @@ declare module '@neus/sdk' {
         }>;
         createdVouchers?: string[];
       };
+      /** Advanced. Primary-chain transaction metadata from the NEUS protocol. */
       hubTransaction?: {
         txHash: string;
         timestamp: number;
@@ -320,14 +371,17 @@ declare module '@neus/sdk' {
   export type CoreVerifierId =
     // Public verifiers (auto-path via verify())
     | 'ownership-basic'
+    | 'ownership-social'       // Hosted OAuth social ownership
     | 'ownership-pseudonym'    // Pseudonymous identity verification
+    | 'ownership-org-oauth'    // Hosted OAuth organization ownership
     | 'nft-ownership'
     | 'token-holding'
     | 'ownership-dns-txt'
     | 'wallet-link'
     | 'contract-ownership'
     | 'wallet-risk'            // Wallet risk assessment
-    // AI & Agent verifiers (ERC-8004 aligned)
+    | 'proof-of-human'         // Hosted ZK personhood verification
+    // AI & Agent verifiers (portable, protocol-agnostic)
     | 'agent-identity'
     | 'agent-delegation'
     | 'ai-content-moderation'
@@ -374,13 +428,22 @@ declare module '@neus/sdk' {
     signedTimestamp: number;
     data: any;
     verifierIds: VerifierId[];
-    chainId: number;
+    chainId?: number;
+    chain?: string;
   }): string;
+
+  /** CAIP-380 six-line signer message — line 1 */
+  export const PORTABLE_PROOF_SIGNER_HEADER: string;
   
   /**
    * Validate Ethereum wallet address
    */
   export function validateWalletAddress(address: string): boolean;
+
+  /**
+   * Validate universal wallet address format (EVM/non-EVM).
+   */
+  export function validateUniversalAddress(address: string, chain?: string): boolean;
   
   /**
    * Validate timestamp freshness
@@ -388,7 +451,7 @@ declare module '@neus/sdk' {
   export function validateTimestamp(timestamp: number, maxAgeMs?: number): boolean;
   
   /**
-   * Validate Proof ID (qHash) format
+   * Validate Proof ID format (`qHash` wire alias)
    */
   export function validateQHash(qHash: string): boolean;
   
@@ -397,6 +460,71 @@ declare module '@neus/sdk' {
    */
   export function normalizeAddress(address: string): string;
 
+  /**
+   * Resolve DID from wallet identity via profile resolver endpoint.
+   * EVM wallets resolve to the NEUS protocol primary chain by default; chainId is optional.
+   * Use `chain` (CAIP-2) for non-EVM wallets (e.g. `solana:mainnet`).
+   */
+  export function resolveDID(
+    params: {
+      walletAddress?: string;
+      chainId?: number;
+      chain?: string;
+    },
+    options?: {
+      endpoint?: string;
+      apiUrl?: string;
+      credentials?: 'omit' | 'same-origin' | 'include';
+      headers?: Record<string, string>;
+    }
+  ): Promise<{
+    did: string;
+    data: unknown;
+    raw: unknown;
+  }>;
+
+  /**
+   * Build a server-standardized signing payload.
+   */
+  export function standardizeVerificationRequest(
+    params: Record<string, any>,
+    options?: {
+      endpoint?: string;
+      apiUrl?: string;
+      credentials?: 'omit' | 'same-origin' | 'include';
+      headers?: Record<string, string>;
+    }
+  ): Promise<any>;
+
+  /**
+   * Resolve ZK Passport default configuration.
+   */
+  export function resolveZkPassportConfig(overrides?: Record<string, any>): {
+    provider: string;
+    scope: string;
+    checkSanctions: boolean;
+    requireFaceMatch: boolean;
+    faceMatchMode: string;
+    [key: string]: any;
+  };
+
+  /**
+   * Convert a UTF-8 message string to a 0x-prefixed hex payload.
+   */
+  export function toHexUtf8(message: string): string;
+
+  /**
+   * Sign a message with an injected/provider wallet.
+   * Uses `personal_sign` and retries with UTF-8 hex payloads when providers
+   * report encoding/non-hex input issues (common with some embedded wallets).
+   */
+  export function signMessage(params: {
+    provider?: any;
+    message: string;
+    walletAddress?: string;
+    chain?: string;
+  }): Promise<string>;
+
   /**
    * Validate a verifier payload for basic structural integrity
    */
@@ -410,9 +538,10 @@ declare module '@neus/sdk' {
     data: any;
     walletAddress: string;
     chainId?: number;
+    chain?: string;
     options?: any;
     signedTimestamp?: number;
-  }): { message: string; request: { verifierIds: string[]; data: any; walletAddress: string; signedTimestamp: number; chainId: number; options?: any } };
+  }): { message: string; request: { verifierIds: string[]; data: any; walletAddress: string; signedTimestamp: number; chainId?: number; chain?: string; options?: any } };
   
   /**
    * Check if status is terminal (complete)
@@ -443,7 +572,7 @@ declare module '@neus/sdk' {
    * Status polling utility
    */
   export class StatusPoller {
-    constructor(client: NeusClient, qHash: string, options?: { interval?: number; maxAttempts?: number; exponentialBackoff?: boolean; maxInterval?: number });
+    constructor(client: NeusClient, proofId: string, options?: { interval?: number; maxAttempts?: number; exponentialBackoff?: boolean; maxInterval?: number });
     poll(): Promise<StatusResult>;
   }
   
@@ -472,19 +601,51 @@ declare module '@neus/sdk' {
     backoffFactor?: number;
   }): Promise<T>;
   
-  /**
-   * Proof status
-   */
-  // Use NeusClient.getStatus(qHash) for status checks.
-  
-  
   // ============================================================================
   // CONSTANTS & REGISTRY
   // ============================================================================
+
+  /**
+   * Build `agent-delegation` maxSpend from a display decimal (e.g. USDC `"100.50"` with six decimal places).
+   * Returns a whole-number string in token base units (no decimal point) for the verifier API.
+   */
+  export function toAgentDelegationMaxSpend(
+    humanAmount: string | number,
+    decimals: number
+  ): string;
   
   /**
    * NEUS Network constants
    */
+  export const DEFAULT_HOSTED_VERIFY_URL: string;
+
+  export function getHostedCheckoutUrl(opts?: {
+    gateId?: string;
+    returnUrl?: string;
+    verifiers?: string[];
+    preset?: string;
+    mode?: string;
+    intent?: string;
+    origin?: string;
+    oauthProvider?: string;
+    baseUrl?: string;
+  }): string;
+
+  /**
+   * Public gate monetization.charge from GET /api/v1/profile/gates/{gateId} (sanitized).
+   * Safe for clients: no payout secrets; `recipient` is the published settlement address when enabled.
+   */
+  export type NeusPublicGateCharge = {
+    enabled: boolean;
+    scheme: string;
+    label: string;
+    amountUsd: number;
+    methods: string[];
+    appliesTo: string;
+    executionOrder?: string;
+    recipient?: string;
+  };
+
   export const NEUS_CONSTANTS: {
     HUB_CHAIN_ID: number;
     TESTNET_CHAINS: number[];
@@ -549,12 +710,6 @@ declare module '@neus/sdk' {
    */
   export class AuthenticationError extends SDKError {}
   
-  // ============================================================================
-  // SCHEMA ACCESS
-  // ============================================================================
-  
-  
-  
   // ============================================================================
   // PROOFS & GATING TYPES
   // ============================================================================
@@ -567,6 +722,10 @@ declare module '@neus/sdk' {
     limit?: number;
     /** Offset for pagination */
     offset?: number;
+    /** CAIP-2 signer chain for owner-signed private access (non-EVM) */
+    chain?: string;
+    /** Signature method hint for owner-signed private access (eip191, ed25519, ...) */
+    signatureMethod?: string;
   }
 
   /**
@@ -624,10 +783,10 @@ declare module '@neus/sdk' {
 
   /**
    * Parameters for gateCheck() (API-backed).
-   * Mirrors `GET /api/v1/proofs/gate/check` query parameters.
+   * Mirrors `GET /api/v1/proofs/check` query parameters.
    */
   export interface GateCheckApiParams {
-    /** Wallet address to check (0x...) */
+    /** Wallet identity to check (EVM/Solana/NEAR) */
     address: string;
     /** Verifier IDs to match (array or comma-separated string) */
     verifierIds?: string[] | string;
@@ -641,6 +800,18 @@ declare module '@neus/sdk' {
     since?: number;
     /** Max rows to scan (server may clamp) */
     limit?: number;
+    /** Include private proofs for owner/controller-authorized checks */
+    includePrivate?: boolean;
+    /** Include matched qHashes in response (minimal identifiers only) */
+    includeQHashes?: boolean;
+    /** Optional wallet/provider used to sign includePrivate owner checks */
+    wallet?: WalletLike;
+    /** CAIP-2 signer chain for universal owner signatures (e.g. solana:mainnet) */
+    chain?: string;
+    /** Signature method hint for universal owner signatures (eip191, ed25519, ...) */
+    signatureMethod?: string;
+    /** Optional pre-signed owner auth payload to reuse across multiple gateCheck calls */
+    privateAuth?: GatePrivateAuth;
 
     // Common match filters
     referenceType?: string;
@@ -651,9 +822,10 @@ declare module '@neus/sdk' {
     content?: string;
     contentHash?: string;
 
-    // Asset/ownership filters
+    // Asset/ownership filters — chainId here is the chain where the asset lives (e.g. 8453 for Base, 1 for Ethereum)
     contractAddress?: string;
     tokenId?: string;
+    /** EVM chain ID of the asset (e.g. 1, 8453). Required for nft-ownership, token-holding, contract-ownership. */
     chainId?: number;
     domain?: string;
     minBalance?: string;
@@ -661,6 +833,10 @@ declare module '@neus/sdk' {
     // Wallet filters
     /** Risk assessment provider hint. Known value: webacy. */
     provider?: string;
+    /** Social handle (ownership-social) or pseudonym handle (ownership-pseudonym); server matches data.handle / pseudonymId */
+    handle?: string;
+    /** ownership-pseudonym namespace filter (matches GET /api/v1/proofs/check `namespace` query) */
+    namespace?: string;
     ownerAddress?: string;
     riskLevel?: string;
     sanctioned?: boolean;
@@ -670,12 +846,22 @@ declare module '@neus/sdk' {
     verificationMethod?: string;
   }
 
+  export interface GatePrivateAuth {
+    walletAddress: string;
+    signature: string;
+    signedTimestamp: number;
+    chain?: string;
+    signatureMethod?: string;
+  }
+
   export interface GateCheckApiResponse {
     success: boolean;
     data?: {
       eligible: boolean;
       matchedCount?: number;
       matchedQHashes?: string[];
+      /** @deprecated matchedProofIds is a compatibility alias of matchedQHashes (same values when provided). */
+      matchedProofIds?: string[];
       matchedTags?: string[];
       projections?: Array<Record<string, any>> | null;
       criteria?: Record<string, any>;
@@ -842,7 +1028,8 @@ declare module '@neus/sdk' {
     primaryWalletAddress: string;
     secondaryWalletAddress: string;
     signature: string;
-    chainId: number;
+    chain: string;
+    signatureMethod: string;
     signedTimestamp: number;
     relationshipType?: 'primary' | 'personal' | 'org' | 'affiliate' | 'agent' | 'linked';
     label?: string;
@@ -872,6 +1059,13 @@ declare module '@neus/sdk' {
     agentType?: 'ai' | 'bot' | 'service' | 'automation' | 'agent';
     description?: string;
     capabilities?: any[];
+    instructions?: string;
+    skills?: string[];
+    services?: Array<{
+      name: string;
+      endpoint: string;
+      version?: string;
+    }>;
     [key: string]: any;
   };
 
@@ -881,10 +1075,13 @@ declare module '@neus/sdk' {
     agentId?: string;
     scope?: string;
     permissions?: any[];
+    /** Whole-number string, token base units (1–78 digits, no decimal point). Build via `toAgentDelegationMaxSpend`. */
     maxSpend?: string;
     allowedPaymentTypes?: string[];
     receiptDisclosure?: 'none' | 'summary' | 'full';
     expiresAt?: number;
+    instructions?: string;
+    skills?: string[];
     [key: string]: any;
   };
 
@@ -981,28 +1178,45 @@ declare module '@neus/sdk/widgets' {
     requiredVerifiers?: string[];
     /** Callback when verification completes successfully */
     onVerified?: (result: {
+      proofId: string;
+      /** HTTP wire field for the proof receipt ID. */
       qHash: string;
+      proofIds?: string[];
+      /** HTTP wire fields for proof receipt IDs. */
       qHashes?: string[];
       address?: string;
       txHash?: string | null;
       verifierIds: string[];
       verifiedVerifiers?: any[];
-      statusUrl?: string | null;
+      proofUrl?: string | null;
       existing?: boolean;
+      eligible?: boolean;
       mode?: 'create' | 'access';
       data?: any;
       results?: Array<{
         verifierId: string;
+        proofId: string;
+        /** HTTP wire field for the proof receipt ID. */
         qHash: string;
         address?: string;
         txHash?: string | null;
         verifiedVerifiers?: any[];
-        statusUrl?: string | null;
+        proofUrl?: string | null;
       }>;
       proofsByVerifierId?: Record<string, any>;
     }) => void;
     /** Custom API endpoint URL */
     apiUrl?: string;
+    /** Optional public app attribution ID (maps to X-Neus-App) */
+    appId?: string;
+    /** Optional x402 receipt token for retry calls (maps to PAYMENT-SIGNATURE) */
+    paymentSignature?: string;
+    /** Optional extra passthrough headers for advanced integrations */
+    extraHeaders?: Record<string, string>;
+    /** Hosted checkout URL for interactive verifiers (default: https://neus.network/verify) */
+    hostedCheckoutUrl?: string;
+    /** Optional OAuth provider id to pre-select for social/org verifiers (hosted flow) */
+    oauthProvider?: string;
     /** Custom inline styles */
     style?: Record<string, any>;
     /** Child content to show when verified */
@@ -1011,7 +1225,7 @@ declare module '@neus/sdk/widgets' {
     verifierOptions?: Record<string, any>;
     /** Pre-built verifier data for each verifier */
     verifierData?: Record<string, any>;
-    /** Proof creation options (privacyLevel, publicDisplay, storeOriginalContent) */
+    /** Proof creation options (defaults: private, publicDisplay false, storeOriginalContent true) */
     proofOptions?: Record<string, any>;
     /** Proof reuse strategy */
     strategy?: 'reuse-or-create' | 'reuse' | 'fresh';
@@ -1029,8 +1243,16 @@ declare module '@neus/sdk/widgets' {
     buttonText?: string;
     /** Mode: 'create' for new verification, 'access' for private proof access */
     mode?: 'create' | 'access';
-    /** qHash for private proof access (required when mode='access') */
+    /** proofId for private proof access (required when mode='access') */
+    proofId?: string | null;
+    /** HTTP wire field for callers that receive API-shaped proof records. */
     qHash?: string | null;
+    /** Optional injected wallet/provider for signing flows */
+    wallet?: WalletLike | any;
+    /** Optional CAIP-2 chain context for non-EVM owner signatures */
+    chain?: string;
+    /** Optional signature method hint for non-EVM owner signatures */
+    signatureMethod?: string;
     /** Callback for state changes */
     onStateChange?: (state: string) => void;
     /** Callback for errors */
@@ -1040,8 +1262,12 @@ declare module '@neus/sdk/widgets' {
   export function VerifyGate(props: VerifyGateProps): any;
 
   export interface ProofBadgeProps {
-    /** Proof ID (qHash) */
-    qHash: string;
+    /** Proof receipt ID. */
+    proofId?: string;
+    /** HTTP wire field for callers that receive API-shaped proof records. Prefer proofId. */
+    qHash?: string;
+    /** URL path pattern for proof links. Supports :proofId. */
+    proofUrlPattern?: string;
     /** Badge size */
     size?: 'sm' | 'md';
     /** UI platform base URL */
@@ -1054,8 +1280,10 @@ declare module '@neus/sdk/widgets' {
     showChains?: boolean;
     /** Show status label (default: true) */
     showLabel?: boolean;
+    /** Logo URL override (defaults to bundled NEUS logo) */
+    logoUrl?: string;
     /** Custom click handler */
-    onClick?: (data: { qHash: string; status: string; chainCount?: number }) => void;
+    onClick?: (data: { proofId: string; qHash: string; status: string; chainCount?: number }) => void;
     /** Additional CSS class */
     className?: string;
   }
@@ -1063,41 +1291,59 @@ declare module '@neus/sdk/widgets' {
   export function ProofBadge(props: ProofBadgeProps): any;
 
   export interface SimpleProofBadgeProps {
-    qHash: string;
+    proofId?: string;
+    /** HTTP wire field for callers that receive API-shaped proof records. Prefer proofId. */
+    qHash?: string;
+    /** URL path pattern for proof links. Supports :proofId. */
+    proofUrlPattern?: string;
     uiLinkBase?: string;
     apiUrl?: string;
     size?: 'sm' | 'md';
     /** Label text (default: 'Verified') */
     label?: string;
+    /** Logo URL override (defaults to bundled NEUS logo) */
+    logoUrl?: string;
     proof?: any;
-    onClick?: (data: { qHash: string; status: string }) => void;
+    onClick?: (data: { proofId: string; qHash: string; status: string }) => void;
     className?: string;
   }
 
   export function SimpleProofBadge(props: SimpleProofBadgeProps): any;
 
   export interface NeusPillLinkProps {
+    proofId?: string;
+    /** HTTP wire field for callers that receive API-shaped proof records. Prefer proofId. */
     qHash?: string;
+    /** URL path pattern for proof links. Supports :proofId. */
+    proofUrlPattern?: string;
     uiLinkBase?: string;
     label?: string;
     size?: 'sm' | 'md';
-    onClick?: (data: { qHash?: string }) => void;
+    /** Logo URL override (defaults to bundled NEUS logo) */
+    logoUrl?: string;
+    onClick?: (data: { proofId?: string; qHash?: string }) => void;
     className?: string;
   }
 
   export function NeusPillLink(props: NeusPillLinkProps): any;
 
   export interface VerifiedIconProps {
-    /** Proof ID (qHash) for link */
+    /** Proof receipt ID for link */
+    proofId?: string;
+    /** HTTP wire field for callers that receive API-shaped proof records. Prefer proofId. */
     qHash?: string;
+    /** URL path pattern for proof links. Supports :proofId. */
+    proofUrlPattern?: string;
     /** UI platform base URL */
     uiLinkBase?: string;
     /** Icon size in pixels */
     size?: number;
+    /** Logo URL override (defaults to bundled NEUS logo) */
+    logoUrl?: string;
     /** Tooltip text */
     tooltip?: string;
     /** Custom click handler */
-    onClick?: (data: { qHash?: string }) => void;
+    onClick?: (data: { proofId?: string; qHash?: string }) => void;
     /** Additional CSS class */
     className?: string;
   }
@@ -1107,4 +1353,8 @@ declare module '@neus/sdk/widgets' {
 
 declare module '@neus/sdk/widgets/verify-gate' {
   export * from '@neus/sdk/widgets';
-}
+}
+
+declare module '@neus/sdk/client' {
+  export { NeusClient } from '@neus/sdk';
+}